@scx-js/scx-data 0.2.0 → 0.2.2

package/query/QueryLike.js

@@ -16,12 +16,7 @@ class QueryLike extends Query {
         return this;
     }
 
-    groupBy(...groupByClauses) {
-        this.query().groupBy(...groupByClauses);
-        return this;
-    }
-
-    orderBy(...orderByClauses) {
+    orderBys(...orderByClauses) {
         this.query().orderBy(...orderByClauses);
         return this;
     }
@@ -81,23 +76,18 @@ class QueryLike extends Query {
         return this;
     }
 
-    addGroupBy(...groupByClauses) {
-        this.query().addGroupBy(groupByClauses);
-        return this;
-    }
-
-    addOrderBy(...orderByClauses) {
-        this.query().addOrderBy(orderByClauses);
+    orderBy(...orderByClauses) {
+        this.query().orderBy(orderByClauses);
         return this;
     }
 
-    removeGroupByIf(filter) {
-        this.query().removeGroupByIf(filter);
+    asc(selector, ...controls) {
+        this.query().asc(selector,...controls);
         return this;
     }
 
-    removeOrderByIf(filter) {
-        this.query().removeOrderByIf(filter);
+    desc(selector, ...controls) {
+        this.query().desc(selector,...controls);
         return this;
     }
 

package/query/SkipIfInfo.js

@@ -0,0 +1,42 @@
+import {SKIP_IF_BLANK_STRING, SKIP_IF_EMPTY_LIST, SKIP_IF_EMPTY_STRING, SKIP_IF_NULL} from "./BuildControl.js";
+
+class SkipIfInfo {
+    skipIfNull;
+    skipIfEmptyList;
+    skipIfEmptyString;
+    skipIfBlankString;
+
+    constructor(skipIfNull, skipIfEmptyList, skipIfEmptyString, skipIfBlankString) {
+        this.skipIfNull = skipIfNull;
+        this.skipIfEmptyList = skipIfEmptyList;
+        this.skipIfEmptyString = skipIfEmptyString;
+        this.skipIfBlankString = skipIfBlankString;
+    }
+
+}
+
+function ofSkipIfInfo(...controls) {
+    let skipIfNull = false;
+    let skipIfEmptyList = false;
+    let skipIfEmptyString = false;
+    let skipIfBlankString = false;
+    for (let control of controls) {
+        if (control === SKIP_IF_NULL) {
+            skipIfNull = true;
+        } else if (control === SKIP_IF_EMPTY_LIST) {
+            skipIfEmptyList = true;
+        } else if (control === SKIP_IF_EMPTY_STRING) {
+            skipIfEmptyString = true;
+        } else if (control === SKIP_IF_BLANK_STRING) {
+            skipIfBlankString = true;
+        }
+    }
+
+    return new SkipIfInfo(skipIfNull, skipIfEmptyList, skipIfEmptyString, skipIfBlankString);
+
+}
+
+export {
+    SkipIfInfo,
+    ofSkipIfInfo,
+};

package/query/WhereClause.js

@@ -3,31 +3,21 @@ import {QueryImpl} from "./QueryImpl.js";
 
 class WhereClause extends QueryLike {
 
-    #whereClause;
+    #expression;
     #params;
 
-    constructor(whereClause, params) {
+    constructor(expression, params) {
         super();
-        this.#whereClause = whereClause;
+        this.#expression = expression;
         this.#params = params;
     }
 
-    /**
-     * 拼接
-     *
-     * @param other a
-     * @return WhereClause
-     */
-    concat(other) {
-        return new WhereClause(this.#whereClause.concat(other.#whereClause), this.#params.concat(other.params));
-    }
-
     isEmpty() {
-        return (this.#whereClause == null || this.#whereClause.isEmpty()) && (this.#params == null || this.#params.length === 0);
+        return (this.#expression == null || this.#expression.isEmpty()) && (this.#params == null || this.#params.length === 0);
     }
 
-    whereClause() {
-        return this.#whereClause;
+    expression() {
+        return this.#expression;
     }
 
     params() {

package/query/serializer/QuerySerializer.js

@@ -1,27 +1,125 @@
-import {WhereSerializer} from "./WhereSerializer.js";
-import {GroupBySerializer} from "./GroupBySerializer.js";
-import {OrderBySerializer} from "./OrderBySerializer.js";
+import {WhereClause} from "../WhereClause.js";
+import {And} from "../And.js";
+import {Or} from "../Or.js";
+import {Not} from "../Not.js";
+import {Condition} from "../Condition.js";
 
 class QuerySerializer {
 
-    #whereSerializer;
-    #groupBySerializer;
-    #orderBySerializer;
+    toJson(query) {
+        return JSON.stringify(this.serialize(query), null, 2);
+    }
 
-    constructor() {
-        this.#whereSerializer = new WhereSerializer();
-        this.#groupBySerializer = new GroupBySerializer();
-        this.#orderBySerializer = new OrderBySerializer();
+    serialize(query) {
+        return this.serializeQuery(query);
     }
 
     serializeQuery(query) {
         return {
             "@type": "Query",
-            "where": this.#whereSerializer.serialize(query.getWhere()),
-            "groupBy": this.#groupBySerializer.serialize(query.getGroupBy()),
-            "orderBy": this.#orderBySerializer.serialize(query.getOrderBy()),
-            "offset": query.getOffset(),
-            "limit": query.getLimit(),
+            where: this.serializeWhere(query.getWhere?.()),
+            orderBys: this.serializeOrderBys(...(query.getOrderBys?.() ?? [])),
+            offset: query.getOffset?.(),
+            limit: query.getLimit?.(),
+        };
+    }
+
+    serializeWhere(obj) {
+        if (!obj) {
+            return null;
+        }
+
+        if (obj instanceof WhereClause) {
+            return this.serializeWhereClause(obj);
+        }
+        if (obj instanceof And) {
+            return this.serializeAnd(obj);
+        }
+        if (obj instanceof Or) {
+            return this.serializeOr(obj);
+        }
+
+        if (obj instanceof Not) {
+            return this.serializeNot(obj);
+        }
+
+        if (obj instanceof Condition) {
+            return this.serializeCondition(obj);
+        }
+        
+        throw new Error(`Unknown Where type: ${obj?.type}`);
+
+    }
+
+    serializeWhereClause(w) {
+        return {
+            "@type": "WhereClause",
+            expression: w.expression(),
+            params: w.params(),
+        };
+    }
+
+    serializeAnd(a) {
+        return {
+            "@type": "And",
+            clauses: this.serializeWhereAll(a.clauses),
+        };
+    }
+
+    serializeOr(o) {
+        return {
+            "@type": "Or",
+            clauses: this.serializeWhereAll(o.clauses),
+        };
+    }
+
+    serializeNot(n) {
+        return {
+            "@type": "Not",
+            clause: this.serializeWhere(n.clause),
+        };
+    }
+
+    serializeCondition(w) {
+        return {
+            "@type": "Condition",
+            selector: w.selector(),
+            conditionType: w.conditionType(),
+            value1: w.value1(),
+            value2: w.value2(),
+            useExpression: w.useExpression(),
+            useExpressionValue: w.useExpressionValue(),
+            skipIfInfo: this.serializeSkipIfInfo(w.skipIfInfo()),
+        };
+    }
+
+    serializeWhereAll(objs) {
+        return objs.map(obj => this.serializeWhere(obj));
+    }
+
+    serializeOrderBys(...objs) {
+        return objs.map(obj => this.serializeOrderBy(obj));
+    }
+
+    serializeOrderBy(orderBy) {
+        return {
+            "@type": "OrderBy",
+            selector: orderBy.selector(),
+            orderByType: orderBy.orderByType(),
+            useExpression: orderBy.useExpression(),
+        };
+    }
+
+    serializeSkipIfInfo(info) {
+        if (!info) {
+            return null;
+        }
+        return {
+            "@type": "SkipIfInfo",
+            skipIfNull: info.skipIfNull,
+            skipIfEmptyList: info.skipIfEmptyList,
+            skipIfEmptyString: info.skipIfEmptyString,
+            skipIfBlankString: info.skipIfBlankString,
         };
     }
 

package/query/GroupBy.js

@@ -1,36 +0,0 @@
-import {isBlank} from "@scx-js/scx-common";
-import {QueryImpl} from "./QueryImpl.js";
-import {QueryLike} from "./QueryLike.js";
-import {ofInfo} from "./QueryOption.js";
-
-class GroupBy extends QueryLike {
-
-    #name;
-    #info;
-
-    constructor(name, ...options) {
-        super();
-        if (isBlank(name)) {
-            throw new Error("GroupBy 参数错误 : 名称 不能为空 !!!");
-        }
-        this.#name = name;
-        this.#info = ofInfo(...options);
-    }
-
-    name() {
-        return this.#name;
-    }
-
-    info() {
-        return this.#info;
-    }
-
-    toQuery() {
-        return new QueryImpl().groupBy(this);
-    }
-
-}
-
-export {
-    GroupBy,
-};

package/query/QueryOption.js

@@ -1,74 +0,0 @@
-class QueryOption {
-
-    #value;
-
-    constructor(value) {
-        this.#value = value;
-    }
-
-
-}
-
-const REPLACE = new QueryOption("REPLACE");
-const SKIP_IF_NULL = new QueryOption("SKIP_IF_NULL");
-const SKIP_IF_EMPTY_LIST = new QueryOption("SKIP_IF_EMPTY_LIST");
-const USE_ORIGINAL_NAME = new QueryOption("USE_ORIGINAL_NAME");
-const USE_JSON_EXTRACT = new QueryOption("USE_JSON_EXTRACT");
-const USE_ORIGINAL_VALUE = new QueryOption("USE_ORIGINAL_VALUE");
-
-function ofInfo(...queryOptions) {
-    let replace = false;
-    let skipIfNull = false;
-    let skipIfEmptyList = false;
-    let useOriginalName = false;
-    let useJsonExtract = false;
-    let useOriginalValue = false;
-    for (let option of queryOptions) {
-        if (option === REPLACE) {
-            replace = true;
-        } else if (option === SKIP_IF_NULL) {
-            skipIfNull = true;
-        } else if (option === SKIP_IF_EMPTY_LIST) {
-            skipIfEmptyList = true;
-        } else if (option === USE_ORIGINAL_NAME) {
-            useOriginalName = true;
-        } else if (option === USE_JSON_EXTRACT) {
-            useJsonExtract = true;
-        } else if (option === USE_ORIGINAL_VALUE) {
-            useOriginalValue = true;
-        }
-    }
-    return new Info(replace, skipIfNull, skipIfEmptyList, useOriginalName, useJsonExtract, useOriginalValue);
-}
-
-class Info {
-    replace;
-    skipIfNull;
-    skipIfEmptyList;
-    useOriginalName;
-    useJsonExtract;
-    useOriginalValue;
-
-
-    constructor(replace, skipIfNull, skipIfEmptyList, useOriginalName, useJsonExtract, useOriginalValue) {
-        this.replace = replace;
-        this.skipIfNull = skipIfNull;
-        this.skipIfEmptyList = skipIfEmptyList;
-        this.useOriginalName = useOriginalName;
-        this.useJsonExtract = useJsonExtract;
-        this.useOriginalValue = useOriginalValue;
-    }
-
-}
-
-export {
-    QueryOption,
-    REPLACE,
-    SKIP_IF_NULL,
-    SKIP_IF_EMPTY_LIST,
-    USE_ORIGINAL_NAME,
-    USE_JSON_EXTRACT,
-    USE_ORIGINAL_VALUE,
-    Info,
-    ofInfo,
-};

package/query/Where.js

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

package/query/serializer/GroupBySerializer.js

@@ -1,50 +0,0 @@
-import {Query} from "../Query.js";
-import {isArray} from "@scx-js/scx-common";
-import {GroupBy} from "../GroupBy.js";
-
-class GroupBySerializer {
-
-    serialize(obj) {
-        if (obj instanceof String) {
-            return this.serializeString(obj);
-        }
-        if (obj instanceof GroupBy) {
-            return this.serializeGroupBy(obj);
-        }
-        if (obj instanceof Query) {
-            return this.serializeQuery(obj.getWhere());
-        }
-        if (isArray(obj)) {
-            return this.serializeAll(obj);
-        }
-        return obj;
-    }
-
-    serializeString(str) {
-        return str;
-    }
-
-    serializeGroupBy(w) {
-        return {
-            "@type": "GroupBy",
-            "name": w.name(),
-            "info": w.info(),
-        };
-    }
-
-    serializeQuery(w) {
-        return this.serializeAll(w.getGroupBy());
-    }
-
-
-    serializeAll(objs) {
-        const arr = [];
-        for (let i = 0; i < objs.length; i = i + 1) {
-            arr[i] = this.serialize(objs[i]);
-        }
-        return arr;
-    }
-
-}
-
-export {GroupBySerializer};

package/query/serializer/OrderBySerializer.js

@@ -1,54 +0,0 @@
-import {Query} from "../Query.js";
-import {isArray} from "@scx-js/scx-common";
-import {OrderBy} from "../OrderBy.js";
-
-class OrderBySerializer {
-
-    serialize(obj) {
-        if (obj instanceof String) {
-            return this.serializeString(obj);
-        }
-        if (obj instanceof OrderBy) {
-            return this.serializeOrderBy(obj);
-        }
-        if (obj instanceof Query) {
-            return this.serializeQuery(obj.getWhere());
-        }
-        if (isArray(obj)) {
-            return this.serializeAll(obj);
-        }
-        return obj;
-    }
-
-    serializeString(str) {
-        return str;
-    }
-
-    serializeOrderBy(w) {
-        return {
-            "@type": "OrderBy",
-            "name": w.name(),
-            "orderByType": w.orderByType(),
-            "info": w.info(),
-        };
-    }
-
-    serializeQuery(w) {
-        return this.serializeAll(w.getOrderBy());
-    }
-
-
-    serializeAll(objs) {
-        const arr = [];
-        for (let i = 0; i < objs.length; i = i + 1) {
-            arr[i] = this.serialize(objs[i]);
-        }
-        return arr;
-    }
-
-
-}
-
-export {
-    OrderBySerializer,
-};

package/query/serializer/WhereSerializer.js

@@ -1,100 +0,0 @@
-import {Where} from "../Where.js";
-import {isArray} from "@scx-js/scx-common";
-import {Query} from "../Query.js";
-import {WhereClause} from "../WhereClause.js";
-import {And} from "../And.js";
-import {Or} from "../Or.js";
-import {Not} from "../Not.js";
-
-class WhereSerializer {
-
-    serialize(obj) {
-        if (obj instanceof String) {
-            return this.serializeString(obj);
-        }
-        if (obj instanceof WhereClause) {
-            return this.serializeWhereClause(obj);
-        }
-        if (obj instanceof And) {
-            return this.serializeAnd(obj);
-        }
-        if (obj instanceof Or) {
-            return this.serializeOr(obj);
-        }
-        if (obj instanceof Not) {
-            return this.serializeNot(obj);
-        }
-        if (obj instanceof Where) {
-            return this.serializeWhere(obj);
-        }
-        if (obj instanceof Query) {
-            return this.serializeQuery(obj.getWhere());
-        }
-        if (isArray(obj)) {
-            return this.serializeAll(obj);
-        }
-        return obj;
-    }
-
-    serializeString(str) {
-        return str;
-    }
-
-    serializeWhereClause(w) {
-        return {
-            "@type": "WhereClause",
-            "whereClause": w.whereClause(),
-            "params": w.params(),
-        };
-    }
-
-    serializeAnd(l) {
-        return {
-            "@type": "And",
-            "clauses": this.serializeAll(l.clauses()),
-        };
-    }
-
-    serializeOr(l) {
-        return {
-            "@type": "Or",
-            "clauses": this.serializeAll(l.clauses()),
-        };
-    }
-
-    serializeNot(l) {
-        return {
-            "@type": "Not",
-            "clauses": this.serialize(l.clause()),
-        };
-    }
-
-    serializeWhere(w) {
-        return {
-            "@type": "Where",
-            "name": w.name(),
-            "whereType": w.whereType(),
-            "value1": w.value1(),
-            "value2": w.value2(),
-            "info": w.info(),
-        };
-    }
-
-    serializeQuery(w) {
-        return this.serializeAll(w.getWhere());
-    }
-
-
-    serializeAll(objs) {
-        const arr = [];
-        for (let i = 0; i < objs.length; i = i + 1) {
-            arr[i] = this.serialize(objs[i]);
-        }
-        return arr;
-    }
-
-}
-
-export {
-    WhereSerializer,
-};