added limits

src/main/java/jef/Queryable.java

@@ -3,6 +3,7 @@ package jef;
 import jef.expressions.Expression;
 import jef.operations.CountOp;
 import jef.operations.FilterOp;
+import jef.operations.LimitOp;
 import jef.serializable.SerializablePredicate;
 
 import java.io.Serializable;
@@ -104,13 +105,13 @@ public interface Queryable<T extends Serializable> {
 //        return null;
 //    }
 //
-//    default Queryable<T> limit(long l) {
+    default Queryable<T> limit(long l) {
-//        return null;
+        return new LimitOp<>(this, null, l);
-//    }
+    }
-//
+
-//    default Queryable<T> skip(long l) {
+    default Queryable<T> skip(long l) {
-//        return null;
+        return new LimitOp<>(this, l, null);
-//    }
+    }
 
     //<editor-fold desc="terminating operations">
 //    default void forEach(Consumer<? super T> consumer) {

src/main/java/jef/expressions/Expression.java

@@ -14,6 +14,7 @@ public interface Expression {
         CONSTANT,
         FIELD,
         INTERMEDIATE_FIELD,
+        LIMIT,
         NULL,
         OR,
         PARAMETER,

src/main/java/jef/expressions/LimitExpression.java

@@ -0,0 +1,34 @@
+package jef.expressions;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class LimitExpression implements Expression {
+    private final Expression expr;
+    private final Long start;
+    private final Long count;
+
+    @Override
+    public Type getType() {
+        return Type.LIMIT;
+    }
+
+    @Override
+    public Priority getPriority() {
+        return Priority.UNDEFINED;
+    }
+
+    @Override
+    public String toString() {
+        var ret = expr.toString();
+        if (count != null) {
+            ret += " LIMIT " + count;
+        }
+        if (start != null) {
+            ret += " OFFSET " + start;
+        }
+        return ret;
+    }
+}

src/main/java/jef/expressions/modifier/ExpressionModifier.java

@@ -6,6 +6,7 @@ import jef.expressions.ConstantExpression;
 import jef.expressions.Expression;
 import jef.expressions.FieldExpression;
 import jef.expressions.IntermediateFieldExpression;
+import jef.expressions.LimitExpression;
 import jef.expressions.NullExpression;
 import jef.expressions.OrExpression;
 import jef.expressions.ParameterExpression;
@@ -27,6 +28,7 @@ public abstract class ExpressionModifier {
             case CONSTANT -> modifyConstant((ConstantExpression) expr);
             case FIELD -> modifyField((FieldExpression) expr);
             case INTERMEDIATE_FIELD -> modifyIntermediateField((IntermediateFieldExpression) expr);
+            case LIMIT -> modifyLimit((LimitExpression) expr);
             case NULL -> modifyNull((NullExpression) expr);
             case OR -> modifyOr((OrExpression) expr);
             case PARAMETER -> modifyParameter((ParameterExpression) expr);
@@ -63,6 +65,10 @@ public abstract class ExpressionModifier {
         return expr;
     }
 
+    public Expression modifyLimit(LimitExpression expr) {
+        return new LimitExpression(modify(expr.getExpr()), expr.getStart(), expr.getCount());
+    }
+
     public Expression modifyNull(NullExpression expr) {
         return expr;
     }

src/main/java/jef/expressions/visitors/DebugExpressionVisitor.java

@@ -5,6 +5,7 @@ import jef.expressions.BinaryExpression;
 import jef.expressions.ConstantExpression;
 import jef.expressions.FieldExpression;
 import jef.expressions.IntermediateFieldExpression;
+import jef.expressions.LimitExpression;
 import jef.expressions.NullExpression;
 import jef.expressions.OrExpression;
 import jef.expressions.ParameterExpression;
@@ -58,6 +59,18 @@ public class DebugExpressionVisitor extends ExpressionVisitor {
         System.out.println(i() + expr.toString());
     }
 
+    public void visitLimit(LimitExpression expr) {
+        visit(expr.getExpr());
+        var s = "";
+        if (expr.getCount() != null) {
+            s += " LIMIT " + expr.getCount();
+        }
+        if (expr.getStart() != null) {
+            s += " OFFSET " + expr.getStart();
+        }
+        System.out.println(i() + s);
+    }
+
     @Override
     public void visitNull(NullExpression expr) {
         System.out.println(i() + expr.toString());

src/main/java/jef/expressions/visitors/ExpressionVisitor.java

@@ -6,6 +6,7 @@ import jef.expressions.ConstantExpression;
 import jef.expressions.Expression;
 import jef.expressions.FieldExpression;
 import jef.expressions.IntermediateFieldExpression;
+import jef.expressions.LimitExpression;
 import jef.expressions.NullExpression;
 import jef.expressions.OrExpression;
 import jef.expressions.ParameterExpression;
@@ -23,6 +24,7 @@ public abstract class ExpressionVisitor {
             case CONSTANT -> visitConstant((ConstantExpression) expr);
             case FIELD -> visitField((FieldExpression) expr);
             case INTERMEDIATE_FIELD -> visitIntermediateField((IntermediateFieldExpression) expr);
+            case LIMIT -> visitLimit((LimitExpression) expr);
             case NULL -> visitNull((NullExpression) expr);
             case OR -> visitOr((OrExpression) expr);
             case PARAMETER -> visitParameter((ParameterExpression) expr);
@@ -55,6 +57,10 @@ public abstract class ExpressionVisitor {
     public void visitIntermediateField(IntermediateFieldExpression expr) {
     }
 
+    public void visitLimit(LimitExpression expr) {
+        visit(expr.getExpr());
+    }
+
     public void visitNull(NullExpression expr) {
     }
 

src/main/java/jef/operations/LimitOp.java

@@ -0,0 +1,49 @@
+package jef.operations;
+
+import jef.Queryable;
+import jef.expressions.Expression;
+import jef.expressions.LimitExpression;
+import jef.expressions.SelectExpression;
+import jef.expressions.selectable.DatabaseSelectAllExpression;
+
+import java.io.Serializable;
+import java.util.List;
+
+public class LimitOp<T extends Serializable> implements Queryable<T> {
+    private final Queryable<T> queryable;
+    private Long start;
+    private Long count;
+
+    public LimitOp(Queryable<T> queryable, Long start, Long count) {
+        this.queryable = queryable;
+        this.start = start;
+        this.count = count;
+    }
+
+    @Override
+    public String getTableAlias() {
+        return String.valueOf((char) (queryable.getTableAlias().charAt(0) + (char) 1));
+    }
+
+    @Override
+    public Expression getExpression() {
+        return new LimitExpression(new SelectExpression(List.of(new DatabaseSelectAllExpression()), queryable.getExpression(), getTableAlias()), start, count);
+    }
+
+    @Override
+    public String toString() {
+        return getExpression().toString();
+    }
+
+    @Override
+    public Queryable<T> limit(long l) {
+        count = l;
+        return this;
+    }
+
+    @Override
+    public Queryable<T> skip(long l) {
+        start = l;
+        return this;
+    }
+}

src/test/java/jef/operations/LimitOpTest.java

@@ -0,0 +1,34 @@
+package jef.operations;
+
+import jef.DBSet;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class LimitOpTest {
+    @Test
+    public void test() {
+        String act;
+        act = new DBSet<FilterOpTest.TestClass>("table1")
+                .limit(10).skip(5)
+                .toString();
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a LIMIT 10 OFFSET 5", act);
+
+
+        act = new DBSet<FilterOpTest.TestClass>("table1")
+                .skip(5).limit(10)
+                .toString();
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a LIMIT 10 OFFSET 5", act);
+
+
+        act = new DBSet<FilterOpTest.TestClass>("table1")
+                .skip(5)
+                .toString();
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a OFFSET 5", act);
+
+
+        act = new DBSet<FilterOpTest.TestClass>("table1")
+                .limit(10)
+                .toString();
+        Assertions.assertEquals("SELECT * FROM (SELECT * FROM `table1`) a LIMIT 10", act);
+    }
+}