Fixed higher level functions for Predicates

Author: CollinAlpert

README.MD

@@ -56,7 +56,7 @@ You can include the Maven dependency:
 <dependency>
     <groupId>com.github.collinalpert</groupId>
     <artifactId>lambda2sql</artifactId>
-    <version>1.8</version>
+    <version>1.8.1</version>
 </dependency>
 ```
 

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.github.collinalpert</groupId>
     <artifactId>lambda2sql</artifactId>
-    <version>1.8</version>
+    <version>1.8.1</version>
     <packaging>jar</packaging>
 
     <name>lambda2sql</name>
@@ -141,6 +141,14 @@
             </plugin>
             <plugin>
                 <artifactId>maven-assembly-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
                 <configuration>
                     <descriptorRefs>
                         <descriptorRef>jar-with-dependencies</descriptorRef>

src/main/java/com/github/collinalpert/lambda2sql/LinkedListStack.java

@@ -0,0 +1,119 @@
+package com.github.collinalpert.lambda2sql;
+
+import java.util.EmptyStackException;
+
+/**
+ * Custom implementation of a stack that uses a linked list functionality approach.
+ *
+ * @param <T> The type of the Stack.
+ * @author Collin Alpert
+ * @see Node
+ */
+public class LinkedListStack<T> {
+
+	/**
+	 * Element representing the head of the stack and the entry point for finding other elements.
+	 */
+	private Node head;
+	private int elementCount;
+
+	/**
+	 * Constructor for creating an empty stack.
+	 */
+	public LinkedListStack() {
+		elementCount = 0;
+	}
+
+	/**
+	 * Pushes (adds) an element to the top of the stack.
+	 *
+	 * @param element The element to be added.
+	 */
+	public void push(T element) {
+		head = new Node(head, element);
+		elementCount++;
+	}
+
+	/**
+	 * Pops (removes and returns) the top of the stack.
+	 *
+	 * @return The top element on the stack.
+	 */
+	public T pop() {
+		if (isEmpty()) {
+			throw new EmptyStackException();
+		}
+		Node firstElement = head;
+		head = head.getNext();
+		elementCount--;
+		return firstElement.getValue();
+	}
+
+	/**
+	 * Returns the top of the stack.
+	 *
+	 * @return The first element on the stack.
+	 */
+	public T top() {
+		if (isEmpty()) {
+			throw new EmptyStackException();
+		}
+		return head.getValue();
+	}
+
+	/**
+	 * Checks if the stack is empty.
+	 *
+	 * @return <code>True</code> if there are elements in the stack, otherwise <code>false</code>.
+	 */
+	public boolean isEmpty() {
+		return elementCount == 0;
+	}
+
+	/**
+	 * @return the number of elements in this stack.
+	 */
+	public int size() {
+		return elementCount;
+	}
+
+	/**
+	 * A class which represents an element in a stack and includes a reference to the next element, as per linked list approach.
+	 *
+	 * @author Collin Alpert
+	 * @see LinkedListStack
+	 */
+	private class Node {
+
+		/**
+		 * Reference to the next element in the stack.
+		 */
+		private Node next;
+		private T value;
+
+		/**
+		 * Constructor for creating an element with a value and a reference to the next element in the stack.
+		 *
+		 * @param next  The next element in the stack.
+		 * @param value This element's value.
+		 */
+		Node(Node next, T value) {
+			this.next = next;
+			this.value = value;
+		}
+
+		/**
+		 * @return the reference to the next element in the stack.
+		 */
+		Node getNext() {
+			return next;
+		}
+
+		/**
+		 * @return the value of this element.
+		 */
+		T getValue() {
+			return value;
+		}
+	}
+}

src/main/java/com/github/collinalpert/lambda2sql/ToSqlVisitor.java

@@ -11,24 +11,23 @@
 import com.trigersoft.jaque.expression.ParameterExpression;
 import com.trigersoft.jaque.expression.UnaryExpression;
 
-import java.util.LinkedList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * Converts a lambda expression to an SQL where condition.
  */
 public class ToSqlVisitor implements ExpressionVisitor<StringBuilder> {
 
 	private final String prefix;
+	private LinkedListStack<List<ConstantExpression>> arguments;
 	private StringBuilder sb;
-
 	private Expression body;
-	private List<ConstantExpression> parameters;
 
 	ToSqlVisitor(String prefix) {
 		this.prefix = prefix;
 		this.sb = new StringBuilder();
-		this.parameters = new LinkedList<>();
+		arguments = new LinkedListStack<>();
 	}
 
 	/**
@@ -62,7 +61,7 @@ private static String toSqlOp(int expressionType) {
 	 */
 	@Override
 	public StringBuilder visit(BinaryExpression e) {
-		boolean quote = e != body && e.getExpressionType() == ExpressionType.LogicalOr;
+		boolean quote = e != this.body && e.getExpressionType() == ExpressionType.LogicalOr;
 
 		if (quote) sb.append('(');
 
@@ -92,19 +91,21 @@ public StringBuilder visit(ConstantExpression e) {
 
 	/**
 	 * An expression which represents an invocation of a lambda expression.
-	 * It is the last {@link #visit} where the parameters of {@link ParameterExpression}s are available which is why
+	 * It is the last {@link #visit} where the arguments of {@link ParameterExpression}s are available which is why
 	 * they are temporarily saved in a list to be inserted into the SQL where condition later.
 	 *
 	 * @param e The {@link InvocationExpression} to convert.
 	 * @return A {@link StringBuilder} containing the body/target of the lambda expression.
 	 */
 	@Override
 	public StringBuilder visit(InvocationExpression e) {
-		e.getArguments()
+		var list = e.getArguments()
 				.stream()
-				.filter(x -> x instanceof ConstantExpression && x.getResultType() != LambdaExpression.class)
-				.map(ConstantExpression.class::cast)
-				.forEach(parameters::add);
+				.filter(x -> x instanceof ConstantExpression)
+				.map(ConstantExpression.class::cast).collect(Collectors.toList());
+		if (!list.isEmpty()) {
+			arguments.push(list);
+		}
 		return e.getTarget().accept(this);
 	}
 
@@ -116,8 +117,10 @@ public StringBuilder visit(InvocationExpression e) {
 	 */
 	@Override
 	public StringBuilder visit(LambdaExpression<?> e) {
-		this.body = e.getBody();
-		return body.accept(this);
+		if (this.body == null && e.getBody() instanceof BinaryExpression) {
+			this.body = e.getBody();
+		}
+		return e.getBody().accept(this);
 	}
 
 	/**
@@ -148,7 +151,7 @@ public StringBuilder visit(MemberExpression e) {
 	 */
 	@Override
 	public StringBuilder visit(ParameterExpression e) {
-		parameters.get(e.getIndex()).accept(this);
+		arguments.top().get(e.getIndex()).accept(this);
 		return sb;
 	}
 

src/main/java/module-info.java

@@ -35,7 +35,7 @@ void testMultipleLogicalOps() {
 	void testWithVariables() {
 		var name = "Donald";
 		var age = 80;
-		assertPredicateEqual("person.name = 'Donald' AND person.age > 80", person -> person.getName() == name && person.getAge() > age);
+		assertPredicateEqual("person.name = 'Donald' OR person.age > 80", person -> person.getName() == name || person.getAge() > age);
 	}
 
 	@Test
@@ -63,8 +63,18 @@ void testAndFunction() {
 	void testOrFunction() {
 		var id = 1;
 		SqlPredicate<IPerson> personPredicate = person -> person.getId() == id;
-		SqlPredicate<IPerson> personSqlPredicateAnd = personPredicate.or(x -> true);
-		assertPredicateEqual("person.id = 1 OR true", personSqlPredicateAnd);
+		SqlPredicate<IPerson> personSqlPredicateOr = personPredicate.or(x -> true);
+		assertPredicateEqual("person.id = 1 OR true", personSqlPredicateOr);
+	}
+
+	@Test
+	void testHigherLevelWithParameters() {
+		var name1 = "Donald";
+		var age1 = 80;
+		var name2 = "Steve";
+		SqlPredicate<IPerson> personPredicate = p -> (p.getName() == name1 || p.getAge() == age1);
+		personPredicate = personPredicate.and(p -> p.getName() == name2);
+		assertPredicateEqual("(person.name = 'Donald' OR person.age = 80) AND person.name = 'Steve'", personPredicate);
 	}
 
 	@Test