Allow limits to sql queries

rchodava · Sep 1, 2016 · 2a72631 · 2a72631
1 parent adad9de
commit 2a72631
Show file tree

Hide file tree

Showing 12 changed files with 203 additions and 92 deletions.
diff --git a/core/src/main/java/foundation/stack/datamill/LimitBuilder.java b/core/src/main/java/foundation/stack/datamill/LimitBuilder.java
@@ -0,0 +1,9 @@
+package foundation.stack.datamill;
+
+/**
+ * @author Ravi Chodavarapu (rchodava@gmail.com)
+ */
+public interface LimitBuilder<R> {
+    R all();
+    R limit(int count);
+}
diff --git a/core/src/main/java/foundation/stack/datamill/db/JoinBuilder.java b/core/src/main/java/foundation/stack/datamill/db/JoinBuilder.java
@@ -6,8 +6,8 @@
  * @author Ravi Chodavarapu (rchodava@gmail.com)
  */
 public interface JoinBuilder<R> {
-    WhereBuilder<R> onEq(String column1, String column2);
-    WhereBuilder<R> onEq(String table1, String column1, String table2, String column2);
-    WhereBuilder<R> onEq(Member member1, Member member2);
-    WhereBuilder<R> onEq(String table1, String column1, Member member2);
+    SelectWhereBuilder<R> onEq(String column1, String column2);
+    SelectWhereBuilder<R> onEq(String table1, String column1, String table2, String column2);
+    SelectWhereBuilder<R> onEq(Member member1, Member member2);
+    SelectWhereBuilder<R> onEq(String table1, String column1, Member member2);
 }
diff --git a/core/src/main/java/foundation/stack/datamill/db/QueryBuilder.java b/core/src/main/java/foundation/stack/datamill/db/QueryBuilder.java
@@ -1,15 +1,19 @@
 package foundation.stack.datamill.db;
 
+import foundation.stack.datamill.LimitBuilder;
 import foundation.stack.datamill.reflection.Outline;
 
 /**
  * @author Ravi Chodavarapu (rchodava@gmail.com)
  */
 public interface QueryBuilder extends SelectQueryBuilder {
-    WhereBuilder<UpdateQueryExecution> deleteFrom(String table);
-    WhereBuilder<UpdateQueryExecution> deleteFrom(Outline<?> outline);
-    WhereBuilder<UpdateQueryExecution> deleteFromNamed(String table);
-    WhereBuilder<UpdateQueryExecution> deleteFromNamed(Outline<?> outline);
+    WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> deleteFrom(String table);
+    WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> deleteFrom(
+            Outline<?> outline);
+    WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> deleteFromNamed(
+            String table);
+    WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> deleteFromNamed(
+            Outline<?> outline);
     InsertBuilder insertInto(String table);
     InsertBuilder insertInto(Outline<?> outline);
     SelectBuilder selectAll();

diff --git a/core/src/main/java/foundation/stack/datamill/db/SelectBuilder.java b/core/src/main/java/foundation/stack/datamill/db/SelectBuilder.java
@@ -7,6 +7,6 @@
  * @author Ravi Chodavarapu (rchodava@gmail.com)
  */
 public interface SelectBuilder {
-    WhereBuilder<Observable<Row>> from(String table);
-    WhereBuilder<Observable<Row>> from(Outline<?> outline);
+    SelectWhereBuilder<Observable<Row>> from(String table);
+    SelectWhereBuilder<Observable<Row>> from(Outline<?> outline);
 }
diff --git a/core/src/main/java/foundation/stack/datamill/db/SelectLimitBuilder.java b/core/src/main/java/foundation/stack/datamill/db/SelectLimitBuilder.java
@@ -0,0 +1,10 @@
+package foundation.stack.datamill.db;
+
+import foundation.stack.datamill.LimitBuilder;
+
+/**
+ * @author Ravi Chodavarapu (rchodava@gmail.com)
+ */
+public interface SelectLimitBuilder<R> extends LimitBuilder<R> {
+    R limit(int offset, int count);
+}
diff --git a/core/src/main/java/foundation/stack/datamill/db/SelectWhereBuilder.java b/core/src/main/java/foundation/stack/datamill/db/SelectWhereBuilder.java
@@ -0,0 +1,12 @@
+package foundation.stack.datamill.db;
+
+import foundation.stack.datamill.reflection.Outline;
+
+/**
+ * @author Ravi Chodavarapu (rchodava@gmail.com)
+ */
+public interface SelectWhereBuilder<R> extends WhereBuilder<R, SelectLimitBuilder<R>> {
+    R limit(int offset, int count);
+    JoinBuilder<R> leftJoin(String table);
+    JoinBuilder<R> leftJoin(Outline<?> outline);
+}
diff --git a/core/src/main/java/foundation/stack/datamill/db/UpdateBuilder.java b/core/src/main/java/foundation/stack/datamill/db/UpdateBuilder.java
@@ -1,12 +1,16 @@
 package foundation.stack.datamill.db;
 
+import foundation.stack.datamill.LimitBuilder;
+
 import java.util.Map;
 import java.util.function.Function;
 
 /**
  * @author Ravi Chodavarapu (rchodava@gmail.com)
  */
 public interface UpdateBuilder {
-    WhereBuilder<UpdateQueryExecution> set(Map<String, ?> values);
-    WhereBuilder<UpdateQueryExecution> set(Function<RowBuilder, Map<String, ?>> rowConstructor);
+    WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> set(
+            Map<String, ?> values);
+    WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> set(
+            Function<RowBuilder, Map<String, ?>> rowConstructor);
 }
diff --git a/core/src/main/java/foundation/stack/datamill/db/WhereBuilder.java b/core/src/main/java/foundation/stack/datamill/db/WhereBuilder.java
@@ -1,14 +1,13 @@
 package foundation.stack.datamill.db;
 
-import foundation.stack.datamill.reflection.Outline;
+import foundation.stack.datamill.LimitBuilder;
 import rx.functions.Func1;
 
 /**
  * @author Ravi Chodavarapu (rchodava@gmail.com)
  */
-public interface WhereBuilder<R> {
+public interface WhereBuilder<R, L extends LimitBuilder<R>> {
     R all();
-    R where(Func1<ConditionBuilder, TerminalCondition> conditionBuilder);
-    JoinBuilder<R> leftJoin(String table);
-    JoinBuilder<R> leftJoin(Outline<?> outline);
+    R limit(int count);
+    L where(Func1<ConditionBuilder, TerminalCondition> conditionBuilder);
 }
diff --git a/core/src/main/java/foundation/stack/datamill/db/impl/QueryBuilderImpl.java b/core/src/main/java/foundation/stack/datamill/db/impl/QueryBuilderImpl.java
@@ -1,6 +1,7 @@
 package foundation.stack.datamill.db.impl;
 
 import com.google.common.base.Joiner;
+import foundation.stack.datamill.LimitBuilder;
 import foundation.stack.datamill.db.*;
 import foundation.stack.datamill.reflection.Member;
 import foundation.stack.datamill.reflection.Outline;
@@ -27,6 +28,7 @@
  * @author Ravi Chodavarapu (rchodava@gmail.com)
  */
 public abstract class QueryBuilderImpl implements QueryBuilder {
+    private static final Object[] EMPTY_PARAMETERS = new Object[0];
     private static final InsertSuffixBuilder EMPTY_UPDATE_BUILDER = new EmptyUpdateSuffixBuilder();
 
     private static void appendUpdateAssignments(StringBuilder query, List<Object> parameters, Map<String, ?> values) {
@@ -61,7 +63,8 @@ public UpdateQuery(String table) {
         }
 
         @Override
-        public WhereBuilder<UpdateQueryExecution> set(Map<String, ?> values) {
+        public WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> set(
+                Map<String, ?> values) {
             if (values.size() < 1) {
                 return new UpdateWhereClause(query, parameters);
             }
@@ -72,7 +75,8 @@ public WhereBuilder<UpdateQueryExecution> set(Map<String, ?> values) {
         }
 
         @Override
-        public WhereBuilder<UpdateQueryExecution> set(Function<RowBuilder, Map<String, ?>> rowConstructor) {
+        public WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> set(
+                Function<RowBuilder, Map<String, ?>> rowConstructor) {
             return set(rowConstructor.apply(new RowBuilderImpl()));
         }
     }
@@ -205,14 +209,13 @@ public UpdateWhereClause(StringBuilder query, List<Object> parameters) {
             super(query, parameters);
         }
 
-        @Override
-        public UpdateQueryExecution all() {
-            return QueryBuilderImpl.this.update(query.toString(), parameters.toArray(new Object[parameters.size()]));
-        }
-
         @Override
         public UpdateQueryExecution execute() {
-            return QueryBuilderImpl.this.update(query.toString(), parameters.toArray(new Object[parameters.size()]));
+            if (!parameters.isEmpty()) {
+                return QueryBuilderImpl.this.update(query.toString(), parameters.toArray(new Object[parameters.size()]));
+            } else {
+                return QueryBuilderImpl.this.update(query.toString(), EMPTY_PARAMETERS);
+            }
         }
     }
 
@@ -222,18 +225,13 @@ public SelectWhereClause(StringBuilder query) {
         }
 
         @Override
-        public Observable<Row> all() {
+        public Observable<Row> execute() {
             if (!parameters.isEmpty()) {
                 return QueryBuilderImpl.this.query(query.toString(), parameters.toArray(new Object[parameters.size()]));
             } else {
                 return QueryBuilderImpl.this.query(query.toString());
             }
         }
-
-        @Override
-        public Observable<Row> execute() {
-            return QueryBuilderImpl.this.query(query.toString(), parameters.toArray(new Object[parameters.size()]));
-        }
     }
 
     private class SelectQuery implements SelectBuilder {
@@ -250,35 +248,40 @@ public SelectQuery(Iterable<String> columns) {
         }
 
         @Override
-        public WhereBuilder<Observable<Row>> from(String table) {
+        public SelectWhereBuilder<Observable<Row>> from(String table) {
             query.append(SqlSyntax.SQL_FROM);
             query.append(table);
             return new SelectWhereClause(query);
         }
 
         @Override
-        public WhereBuilder<Observable<Row>> from(Outline<?> outline) {
+        public SelectWhereBuilder<Observable<Row>> from(Outline<?> outline) {
             return from(outline.pluralName());
         }
     }
 
     @Override
-    public WhereBuilder<UpdateQueryExecution> deleteFrom(String table) {
+    public WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> deleteFrom(
+            String table) {
         return new UpdateWhereClause(new StringBuilder(SqlSyntax.SQL_DELETE_FROM).append(table));
     }
 
     @Override
-    public WhereBuilder<UpdateQueryExecution> deleteFrom(Outline<?> outline) {
+    public WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> deleteFrom(
+            Outline<?> outline) {
         return deleteFrom(outline.pluralName());
     }
 
     @Override
-    public WhereBuilder<UpdateQueryExecution> deleteFromNamed(String table) {
-        return new UpdateWhereClause(new StringBuilder(SqlSyntax.SQL_DELETE).append(table).append(SqlSyntax.SQL_FROM).append(table));
+    public WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> deleteFromNamed(
+            String table) {
+        return new UpdateWhereClause(new StringBuilder(SqlSyntax.SQL_DELETE).append(table).append(SqlSyntax.SQL_FROM)
+                .append(table));
     }
 
     @Override
-    public WhereBuilder<UpdateQueryExecution> deleteFromNamed(Outline<?> outline) {
+    public WhereBuilder<UpdateQueryExecution, ? extends LimitBuilder<? extends UpdateQueryExecution>> deleteFromNamed(
+            Outline<?> outline) {
         return deleteFromNamed(outline.pluralName());
     }
 

diff --git a/core/src/main/java/foundation/stack/datamill/db/impl/SqlSyntax.java b/core/src/main/java/foundation/stack/datamill/db/impl/SqlSyntax.java
@@ -13,6 +13,7 @@ public interface SqlSyntax {
     String SQL_INSERT_INTO = "INSERT INTO ";
     String SQL_LEFT_JOIN = " LEFT JOIN ";
     String SQL_LESS_THAN = " < ";
+    String SQL_LIMIT = " LIMIT ";
     String SQL_NULL = "NULL";
     String SQL_ON = " ON ";
     String SQL_ON_DUPLICATE_KEY_UPDATE = " ON DUPLICATE KEY UPDATE ";

diff --git a/core/src/main/java/foundation/stack/datamill/db/impl/WhereBuilderImpl.java b/core/src/main/java/foundation/stack/datamill/db/impl/WhereBuilderImpl.java
@@ -13,7 +13,8 @@
 /**
  * @author Ravi Chodavarapu (rchodava@gmail.com)
  */
-abstract class WhereBuilderImpl<R> implements WhereBuilder<R>, ConditionBuilder, ConjunctionBuilder, JoinBuilder<R> {
+abstract class WhereBuilderImpl<R> implements SelectWhereBuilder<R>, ConditionBuilder, ConjunctionBuilder,
+        JoinBuilder<R>, SelectLimitBuilder<R> {
     protected final StringBuilder query;
     protected final List<Object> parameters;
 
@@ -60,6 +61,11 @@ protected <T> void addInClause(String column, Collection<T> values) {
         }
     }
 
+    @Override
+    public R all() {
+        return execute();
+    }
+
     @Override
     public TerminalCondition and(
             Func1<ConditionBuilder, TerminalCondition> left,
@@ -117,6 +123,8 @@ public <T> ConjunctionBuilder eq(String table, String column, T value) {
         return eq(SqlSyntax.qualifiedName(table, column), value);
     }
 
+    protected abstract R execute();
+
     @Override
     public <T> ConjunctionBuilder gt(String column, T value) {
         return addBinaryClause(SqlSyntax.SQL_GREATER_THAN, column, value);
@@ -164,44 +172,54 @@ public <T> ConjunctionBuilder in(String column, Collection<T> values) {
     }
 
     @Override
-    public <T> ConjunctionBuilder lt(String column, T value) {
-        return addBinaryClause(SqlSyntax.SQL_LESS_THAN, column, value);
+    public JoinBuilder<R> leftJoin(String table) {
+        query.append(SqlSyntax.SQL_LEFT_JOIN);
+        query.append(table);
+
+        return this;
     }
 
     @Override
-    public <T> ConjunctionBuilder lt(Member member, T value) {
-        return lt(member.outline().pluralName(), member.name(), value);
+    public R limit(int count) {
+        query.append(SqlSyntax.SQL_LIMIT);
+        query.append(count);
+
+        return execute();
     }
 
     @Override
-    public <T> ConjunctionBuilder lt(String table, String column, T value) {
-        return lt(SqlSyntax.qualifiedName(table, column), value);
-    }
+    public R limit(int offset, int count) {
+        query.append(SqlSyntax.SQL_LIMIT);
+        query.append(offset);
+        query.append(SqlSyntax.COMMA);
+        query.append(' ');
+        query.append(count);
 
-    protected abstract R execute();
+        return execute();
+    }
 
     @Override
-    public R where(Func1<ConditionBuilder, TerminalCondition> conditionBuilder) {
-        query.append(SqlSyntax.SQL_WHERE);
-        conditionBuilder.call(this);
-        return execute();
+    public JoinBuilder<R> leftJoin(Outline<?> outline) {
+        return leftJoin(outline.pluralName());
     }
 
     @Override
-    public JoinBuilder<R> leftJoin(String table) {
-        query.append(SqlSyntax.SQL_LEFT_JOIN);
-        query.append(table);
+    public <T> ConjunctionBuilder lt(String column, T value) {
+        return addBinaryClause(SqlSyntax.SQL_LESS_THAN, column, value);
+    }
 
-        return this;
+    @Override
+    public <T> ConjunctionBuilder lt(Member member, T value) {
+        return lt(member.outline().pluralName(), member.name(), value);
     }
 
     @Override
-    public JoinBuilder<R> leftJoin(Outline<?> outline) {
-        return leftJoin(outline.pluralName());
+    public <T> ConjunctionBuilder lt(String table, String column, T value) {
+        return lt(SqlSyntax.qualifiedName(table, column), value);
     }
 
     @Override
-    public WhereBuilder<R> onEq(String column1, String column2) {
+    public SelectWhereBuilder<R> onEq(String column1, String column2) {
         query.append(SqlSyntax.SQL_ON);
         query.append(column1);
         query.append(SqlSyntax.SQL_EQ);
@@ -211,18 +229,26 @@ public WhereBuilder<R> onEq(String column1, String column2) {
     }
 
     @Override
-    public WhereBuilder<R> onEq(String table1, String column1, String table2, String column2) {
+    public SelectWhereBuilder<R> onEq(String table1, String column1, String table2, String column2) {
         return onEq(SqlSyntax.qualifiedName(table1, column1), SqlSyntax.qualifiedName(table2, column2));
     }
 
     @Override
-    public WhereBuilder<R> onEq(Member member1, Member member2) {
+    public SelectWhereBuilder<R> onEq(Member member1, Member member2) {
         return onEq(member1.outline().pluralName(), member1.name(),
                 member2.outline().pluralName(), member2.name());
     }
 
     @Override
-    public WhereBuilder<R> onEq(String table1, String column1, Member member2) {
+    public SelectWhereBuilder<R> onEq(String table1, String column1, Member member2) {
         return onEq(table1, column1, member2.outline().pluralName(), member2.name());
     }
+
+    @Override
+    public SelectLimitBuilder<R> where(Func1<ConditionBuilder, TerminalCondition> conditionBuilder) {
+        query.append(SqlSyntax.SQL_WHERE);
+        conditionBuilder.call(this);
+
+        return this;
+    }
 }