@scx-js/scx-data 0.2.1 → 0.2.2

package/query/Condition.js

@@ -0,0 +1,74 @@
+import {QueryLike} from "./QueryLike.js";
+import {isBlank} from "@scx-js/scx-common";
+import {QueryImpl} from "./QueryImpl.js";
+
+class Condition extends QueryLike {
+
+    #selector;
+    #conditionType;
+    #value1;
+    #value2;
+    #useExpression;
+    #useExpressionValue;
+    #skipIfInfo;
+
+    constructor(selector, conditionType, value1, value2, useExpression, useExpressionValue, skipIfInfo) {
+        super();
+        //名称不能为空
+        if (isBlank(selector)) {
+            throw new Error("Where 参数错误 : 名称 不能为空 !!!");
+        }
+        //类型也不能为空
+        if (conditionType == null) {
+            throw new Error("Where 参数错误 : whereType 不能为空 !!!");
+        }
+        this.#selector = selector;
+        this.#conditionType = conditionType;
+        this.#value1 = value1;
+        this.#value2 = value2;
+        this.#useExpression = useExpression;
+        this.#useExpressionValue = useExpressionValue;
+        this.#skipIfInfo = skipIfInfo;
+    }
+
+    selector() {
+        return this.#selector;
+    }
+
+    conditionType() {
+        return this.#conditionType;
+    }
+
+    value1() {
+        return this.#value1;
+    }
+
+    value2() {
+        return this.#value2;
+    }
+
+    useExpression() {
+        return this.#useExpression;
+    }
+
+    useExpressionValue() {
+        return this.#useExpressionValue;
+    }
+
+    skipIfInfo() {
+        return this.#skipIfInfo;
+    }
+
+    isEmpty() {
+    
+    }
+
+    toQuery() {
+        return new QueryImpl().where(this);
+    }
+
+}
+
+export {
+    Condition,
+};

package/query/{WhereType.js → ConditionType.js}

@@ -68,14 +68,6 @@ const BETWEEN = "BETWEEN";
  */
 const NOT_BETWEEN = "NOT_BETWEEN";
 
-/**
- * json 包含 一般用于 数组判断
- */
-const JSON_CONTAINS = "JSON_CONTAINS";
-
-
-const JSON_OVERLAPS = "JSON_OVERLAPS";
-
 
 export {
     EQ,
@@ -92,6 +84,4 @@ export {
     NOT_IN,
     BETWEEN,
     NOT_BETWEEN,
-    JSON_CONTAINS,
-    JSON_OVERLAPS,
 };

package/query/Junction.js

@@ -5,8 +5,6 @@ import {
     GT,
     GTE,
     IN,
-    JSON_CONTAINS,
-    JSON_OVERLAPS,
     LIKE,
     LIKE_REGEX,
     LT,
@@ -16,10 +14,11 @@ import {
     NOT_IN,
     NOT_LIKE,
     NOT_LIKE_REGEX,
-} from "./WhereType.js";
-import {Where} from "./Where.js";
-import {QueryImpl} from "./QueryImpl.js";
-import {Not} from "./Not.js";
+} from "./ConditionType.js";
+import {Condition} from "./Condition.js";
+// import {QueryImpl} from "./QueryImpl.js";
+// import {Not} from "./Not.js";
+// import {WhereClause} from "./WhereClause.js";
 
 class Junction extends QueryLike {
 
@@ -54,67 +53,67 @@ class Junction extends QueryLike {
     }
 
     eq(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, EQ, value, null, ...options));
+        return this.add(new Condition(fieldName, EQ, value, null, ...options));
     }
 
     ne(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, NE, value, null, ...options));
+        return this.add(new Condition(fieldName, NE, value, null, ...options));
     }
 
     lt(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, LT, value, null, ...options));
+        return this.add(new Condition(fieldName, LT, value, null, ...options));
     }
 
     lte(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, LTE, value, null, ...options));
+        return this.add(new Condition(fieldName, LTE, value, null, ...options));
     }
 
     gt(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, GT, value, null, ...options));
+        return this.add(new Condition(fieldName, GT, value, null, ...options));
     }
 
     gte(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, GTE, value, null, ...options));
+        return this.add(new Condition(fieldName, GTE, value, null, ...options));
     }
 
     like(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, LIKE, value, null, ...options));
+        return this.add(new Condition(fieldName, LIKE, value, null, ...options));
     }
 
     notLike(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, NOT_LIKE, value, null, ...options));
+        return this.add(new Condition(fieldName, NOT_LIKE, value, null, ...options));
     }
 
     likeRegex(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, LIKE_REGEX, value, null, ...options));
+        return this.add(new Condition(fieldName, LIKE_REGEX, value, null, ...options));
     }
 
     notLikeRegex(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, NOT_LIKE_REGEX, value, null, ...options));
+        return this.add(new Condition(fieldName, NOT_LIKE_REGEX, value, null, ...options));
     }
 
     in(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, IN, value, null, ...options));
+        return this.add(new Condition(fieldName, IN, value, null, ...options));
     }
 
     notIn(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, NOT_IN, value, null, ...options));
+        return this.add(new Condition(fieldName, NOT_IN, value, null, ...options));
     }
 
     between(fieldName, value1, value2, ...options) {
-        return this.add(new Where(fieldName, BETWEEN, value1, value2, ...options));
+        return this.add(new Condition(fieldName, BETWEEN, value1, value2, ...options));
     }
 
     notBetween(fieldName, value1, value2, ...options) {
-        return this.add(new Where(fieldName, NOT_BETWEEN, value1, value2, ...options));
+        return this.add(new Condition(fieldName, NOT_BETWEEN, value1, value2, ...options));
     }
 
     jsonContains(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, JSON_CONTAINS, value, null, ...options));
+        return this.add(new Condition(fieldName, JSON_CONTAINS, value, null, ...options));
     }
 
     jsonOverlaps(fieldName, value, ...options) {
-        return this.add(new Where(fieldName, JSON_OVERLAPS, value, null, ...options));
+        return this.add(new Condition(fieldName, JSON_OVERLAPS, value, null, ...options));
     }
 
     and(...clauses) {
@@ -129,6 +128,10 @@ class Junction extends QueryLike {
         return this.add(new Not(clause));
     }
 
+    whereClause(expression, ...params) {
+        return this.add(new WhereClause(expression, params));
+    }
+
     toQuery() {
         return new QueryImpl().where(this);
     }

package/query/OrderBy.js

@@ -1,15 +1,14 @@
 import {isBlank} from "@scx-js/scx-common";
 import {QueryImpl} from "./QueryImpl.js";
-import {ofInfo} from "./QueryOption.js";
 import {QueryLike} from "./QueryLike.js";
 
 class OrderBy extends QueryLike {
 
-    #name;
+    #selector;
     #orderByType;
-    #info;
+    #useExpression;
 
-    constructor(name, orderByType, ...options) {
+    constructor(name, orderByType, useExpression) {
         super();
         if (isBlank(name)) {
             throw new Error("OrderBy 参数错误 : 名称 不能为空 !!!");
@@ -17,22 +16,22 @@ class OrderBy extends QueryLike {
         if (orderByType == null) {
             throw new Error("OrderBy 参数错误 : orderByType 不能为空 !!!");
         }
-        this.#name = name;
+        this.#selector = name;
         this.#orderByType = orderByType;
-        this.#info = ofInfo(...options);
+        this.#useExpression = useExpression;
     }
 
 
-    name() {
-        return this.#name;
+    selector() {
+        return this.#selector;
     }
 
     orderByType() {
         return this.#orderByType;
     }
 
-    info() {
-        return this.#info;
+    useExpression() {
+        return this.#useExpression;
     }
 
     toQuery() {

package/query/Query.js

@@ -4,29 +4,22 @@ class Query {
         return this;
     }
 
-    groupBy(...groupByClauses) {
+    orderBys(...orderBys) {
         return this;
     }
 
-    orderBy(...orderByClauses) {
+    offset(offset) {
         return this;
     }
 
-    offset(limitOffset) {
-        return this;
-    }
-
-    limit(numberOfRows) {
+    limit(limit) {
         return this;
     }
 
     getWhere() {
     }
 
-    getGroupBy() {
-    }
-
-    getOrderBy() {
+    getOrderBys() {
     }
 
     getOffset() {
@@ -39,11 +32,7 @@ class Query {
         return this;
     }
 
-    clearGroupBy() {
-        return this;
-    }
-
-    clearOrderBy() {
+    clearOrderBys() {
         return this;
     }
 
@@ -55,19 +44,15 @@ class Query {
         return this;
     }
 
-    addGroupBy(...groupByClauses) {
-        return this;
-    }
-
-    addOrderBy(...orderByClauses) {
+    orderBy(...orderBys) {
         return this;
     }
 
-    removeGroupByIf(filter) {
+    asc(selector, ...controls) {
         return this;
     }
 
-    removeOrderByIf(filter) {
+    desc(selector, ...controls) {
         return this;
     }
 

package/query/QueryBuilder.js

@@ -5,8 +5,6 @@ import {
     GT,
     GTE,
     IN,
-    JSON_CONTAINS,
-    JSON_OVERLAPS,
     LIKE,
     LIKE_REGEX,
     LT,
@@ -16,14 +14,16 @@ import {
     NOT_IN,
     NOT_LIKE,
     NOT_LIKE_REGEX,
-} from "./WhereType.js";
-import {Where} from "./Where.js";
+} from "./ConditionType.js";
+import {Condition} from "./Condition.js";
 import {QueryImpl} from "./QueryImpl.js";
 import {OrderBy} from "./OrderBy.js";
 import {ASC, DESC} from "./OrderByType.js";
 import {Not} from "./Not.js";
 import {And} from "./And.js";
 import {Or} from "./Or.js";
+import {checkUseExpression, checkUseExpressionValue} from "./BuildControl.js";
+import {ofSkipIfInfo} from "./SkipIfInfo.js";
 
 function query(oldQuery) {
     return new QueryImpl(oldQuery);
@@ -33,20 +33,16 @@ function where(whereClauses) {
     return new QueryImpl().where(whereClauses);
 }
 
-function groupBy(...groupByClauses) {
-    return new QueryImpl().groupBy(...groupByClauses);
+function orderBys(...orderBys) {
+    return new QueryImpl().orderBys(...orderBys);
 }
 
-function orderBy(...orderByClauses) {
-    return new QueryImpl().orderBy(...orderByClauses);
+function offset(offset) {
+    return new QueryImpl().offset(offset);
 }
 
-function offset(limitOffset) {
-    return new QueryImpl().offset(limitOffset);
-}
-
-function limit(numberOfRows) {
-    return new QueryImpl().limit(numberOfRows);
+function limit(limit) {
+    return new QueryImpl().limit(limit);
 }
 
 function and(...clauses) {
@@ -61,87 +57,97 @@ function not(clause) {
     return new Not(clause);
 }
 
+function condition(fieldName, conditionType, value, ...controls) {
+    let useExpression = checkUseExpression(...controls);
+    let useExpressionValue = checkUseExpressionValue(...controls);
+    let skipIfInfo = ofSkipIfInfo(...controls);
+    return new Condition(fieldName, conditionType, value, null, useExpression, useExpressionValue, skipIfInfo);
+}
+
+function condition2(fieldName, conditionType, value1, value2, ...controls) {
+    let useExpression = checkUseExpression(...controls);
+    let useExpressionValue = checkUseExpressionValue(...controls);
+    let skipIfInfo = ofSkipIfInfo(...controls);
+    return new Condition(fieldName, conditionType, value1, value2, useExpression, useExpressionValue, skipIfInfo);
+}
+
+function orderBy(selector, orderByType, ...controls) {
+    let useExpression = checkUseExpression(controls);
+    return new OrderBy(selector, orderByType, useExpression);
+}
+
+function whereClause(expression, ...params) {
+    return new WhereClause(expression, params);
+}
+
 function asc(name, ...options) {
-    return new OrderBy(name, ASC, ...options);
+    return orderBy(name, ASC, ...options);
 }
 
 function desc(name, ...options) {
-    return new OrderBy(name, DESC, ...options);
+    return orderBy(name, DESC, ...options);
 }
 
 function eq(fieldName, value, ...options) {
-    return new Where(fieldName, EQ, value, null, ...options);
+    return condition(fieldName, EQ, value, ...options);
 }
 
 function ne(fieldName, value, ...options) {
-    return new Where(fieldName, NE, value, null, ...options);
+    return condition(fieldName, NE, value, ...options);
 }
 
 function lt(fieldName, value, ...options) {
-    return new Where(fieldName, LT, value, null, ...options);
+    return condition(fieldName, LT, value, ...options);
 }
 
 function lte(fieldName, value, ...options) {
-    return new Where(fieldName, LTE, value, null, ...options);
+    return condition(fieldName, LTE, value, ...options);
 }
 
 function gt(fieldName, value, ...options) {
-    return new Where(fieldName, GT, value, null, ...options);
+    return condition(fieldName, GT, value, ...options);
 }
 
 function gte(fieldName, value, ...options) {
-    return new Where(fieldName, GTE, value, null, ...options);
+    return condition(fieldName, GTE, value, ...options);
 }
 
 function like(fieldName, value, ...options) {
-    return new Where(fieldName, LIKE, value, null, ...options);
+    return condition(fieldName, LIKE, value, ...options);
 }
 
 function notLike(fieldName, value, ...options) {
-    return new Where(fieldName, NOT_LIKE, value, null, ...options);
+    return condition(fieldName, NOT_LIKE, value, ...options);
 }
 
 function likeRegex(fieldName, value, ...options) {
-    return new Where(fieldName, LIKE_REGEX, value, null, ...options);
+    return condition(fieldName, LIKE_REGEX, value, ...options);
 }
 
 function notLikeRegex(fieldName, value, ...options) {
-    return new Where(fieldName, NOT_LIKE_REGEX, value, null, ...options);
+    return condition(fieldName, NOT_LIKE_REGEX, value, ...options);
 }
 
 function in_(fieldName, value, ...options) {
-    return new Where(fieldName, IN, value, null, ...options);
+    return condition(fieldName, IN, value, ...options);
 }
 
 function notIn(fieldName, value, ...options) {
-    return new Where(fieldName, NOT_IN, value, null, ...options);
+    return condition(fieldName, NOT_IN, value, ...options);
 }
 
 function between(fieldName, value1, value2, ...options) {
-    return new Where(fieldName, BETWEEN, value1, value2, ...options);
+    return condition2(fieldName, BETWEEN, value1, value2, ...options);
 }
 
 function notBetween(fieldName, value1, value2, ...options) {
-    return new Where(fieldName, NOT_BETWEEN, value1, value2, ...options);
-}
-
-function jsonContains(fieldName, value, ...options) {
-    return new Where(fieldName, JSON_CONTAINS, value, null, ...options);
-}
-
-function jsonOverlaps(fieldName, value, ...options) {
-    return new Where(fieldName, JSON_OVERLAPS, value, null, ...options);
-}
-
-function whereClause(whereClause, params) {
-    return new WhereClause(whereClause, params);
+    return condition2(fieldName, NOT_BETWEEN, value1, value2, ...options);
 }
 
 
 export {
     query,
     where,
-    groupBy,
     orderBy,
     offset,
     limit,
@@ -164,6 +170,5 @@ export {
     notIn,
     between,
     notBetween,
-    jsonContains,
     whereClause,
 };

package/query/QueryImpl.js

@@ -1,23 +1,22 @@
 import {Query} from "./Query.js";
-import {removeIf} from "@scx-js/scx-common";
+import {checkUseExpression} from "./BuildControl.js";
+import {OrderBy} from "./OrderBy.js";
+import {ASC, DESC} from "./OrderByType.js";
 
 class QueryImpl extends Query {
 
     #where;
-    #groupBy;
-    #orderBy;
+    #orderBys;
     #offset;
     #limit;
 
-
     /**
      * 创建 Query 对象
      */
     constructor(old) {
         super();
         this.#where = null;
-        this.#groupBy = [];
-        this.#orderBy = [];
+        this.#orderBys = [];
         this.#offset = null;
         this.#limit = null;
     }
@@ -27,27 +26,26 @@ class QueryImpl extends Query {
         return this;
     }
 
-    groupBy(...groupByClauses) {
-        this.clearGroupBy();
-        this.addGroupBy(...groupByClauses);
-        return this;
-    }
 
-
-    orderBy(...orderByClauses) {
-        this.clearOrderBy();
-        this.addOrderBy(...orderByClauses);
+    orderBys(...orderBys) {
+        this.#orderBys = orderBys;
         return this;
     }
 
 
-    offset(limitOffset) {
-        this.#offset = limitOffset;
+    offset(offset) {
+        if (offset < 0) {
+            throw new Error("Limit 参数错误 : offset (偏移量) 不能小于 0 !!!");
+        }
+        this.#offset = offset;
         return this;
     }
 
-    limit(numberOfRows) {
-        this.#limit = numberOfRows;
+    limit(limit) {
+        if (limit < 0) {
+            throw new Error("Limit 参数错误 : limit (行长度) 不能小于 0 !!!");
+        }
+        this.#limit = limit;
         return this;
     }
 
@@ -55,12 +53,8 @@ class QueryImpl extends Query {
         return this.#where;
     }
 
-    getGroupBy() {
-        return this.#groupBy;
-    }
-
-    getOrderBy() {
-        return this.#orderBy;
+    getOrderBys() {
+        return this.#orderBys;
     }
 
     getOffset() {
@@ -76,13 +70,8 @@ class QueryImpl extends Query {
         return this;
     }
 
-    clearGroupBy() {
-        this.#groupBy = [];
-        return this;
-    }
-
-    clearOrderBy() {
-        this.#orderBy = [];
+    clearOrderBys() {
+        this.#orderBys = [];
         return this;
     }
 
@@ -96,46 +85,24 @@ class QueryImpl extends Query {
         return this;
     }
 
-    addGroupBy(...groupByClauses) {
-        for (let groupByClause of groupByClauses) {
-            if (groupByClause == null) {
-                continue;
-            }
-            if (Array.isArray(groupByClause)) {
-                this.addGroupBy(...groupByClause);
-                continue;
-            }
-            this.#groupBy.push(groupByClause);
-        }
+    orderBy(...orderBys) {
+        this.#orderBys.push(orderBys);
         return this;
     }
 
-    addOrderBy(...orderByClauses) {
-        for (let orderByClause of orderByClauses) {
-            if (orderByClause == null) {
-                continue;
-            }
-            if (Array.isArray(orderByClause)) {
-                this.addOrderBy(...orderByClause);
-                continue;
-            }
-            this.#orderBy.push(orderByClause);
-        }
-        return this;
-    }
 
-    removeWhereIf(filter) {
-        removeIf(this.#where, filter);
+    asc(selector, ...controls) {
+        let useExpression = checkUseExpression(controls);
+        let o= new OrderBy(selector, ASC, useExpression);
+        this.orderBy(o);
         return this;
     }
 
-    removeGroupByIf(filter) {
-        removeIf(this.#groupBy, filter);
-        return this;
-    }
 
-    removeOrderByIf(filter) {
-        removeIf(this.#orderBy, filter);
+    desc(selector, ...controls) {
+        let useExpression = checkUseExpression(controls);
+        let o= new OrderBy(selector, DESC, useExpression);
+        this.orderBy(o);
         return this;
     }