@scx-js/scx-data 0.0.1

package/query/QueryImpl.js

@@ -0,0 +1,143 @@
+import {Query} from "./Query.js";
+
+class QueryImpl extends Query {
+
+    #where;
+    #groupBy;
+    #orderBy;
+    #offset;
+    #limit;
+
+
+    /**
+     * 创建 Query 对象
+     */
+    constructor(old) {
+        super();
+        this.#where = [];
+        this.#groupBy = [];
+        this.#orderBy = [];
+        this.#offset = null;
+        this.#limit = null;
+    }
+
+    where(...whereClauses) {
+        this.clearWhere();
+        this.#addWhere(...whereClauses);
+        return this;
+    }
+
+    groupBy(...groupByClauses) {
+        this.clearGroupBy();
+        this.#addGroupBy(...groupByClauses);
+        return this;
+    }
+
+
+    orderBy(...orderByClauses) {
+        this.clearOrderBy();
+        this.#addOrderBy(...orderByClauses);
+        return this;
+    }
+
+
+    offset(limitOffset) {
+        this.#offset = limitOffset;
+        return this;
+    }
+
+    limit(numberOfRows) {
+        this.#limit = numberOfRows;
+        return this;
+    }
+
+    getWhere() {
+        return this.#where;
+    }
+
+    getGroupBy() {
+        return this.#groupBy;
+    }
+
+    getOrderBy() {
+        return this.#orderBy;
+    }
+
+    getOffset() {
+        return this.#offset;
+    }
+
+    getLimit() {
+        return this.#limit;
+    }
+
+    clearWhere() {
+        this.#where = [];
+        return this;
+    }
+
+    clearGroupBy() {
+        this.#groupBy = [];
+        return this;
+    }
+
+    clearOrderBy() {
+        this.#orderBy = [];
+        return this;
+    }
+
+    clearOffset() {
+        this.#offset = null;
+        return this;
+    }
+
+    clearLimit() {
+        this.#limit = null;
+        return this;
+    }
+
+    #addWhere(...whereClauses) {
+        for (let whereClause of whereClauses) {
+            if (whereClause == null) {
+                continue;
+            }
+            if (Array.isArray(whereClause)) {
+                this.#addWhere(...whereClause);
+                continue;
+            }
+            this.#where.push(whereClause);
+        }
+        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);
+        }
+        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;
+    }
+
+}
+
+export {QueryImpl};

package/query/QueryLike.js

@@ -0,0 +1,89 @@
+import {Query} from "./Query.js";
+
+class QueryLike extends Query {
+
+    #query;
+
+    query() {
+        if (this.#query == null) {
+            this.#query = this.toQuery();
+        }
+        return this.#query;
+    }
+
+    where(...whereClauses) {
+        this.query().where(...whereClauses);
+        return this;
+    }
+
+    groupBy(...groupByClauses) {
+        this.query().groupBy(...groupByClauses);
+        return this;
+    }
+
+    orderBy(...orderByClauses) {
+        this.query().orderBy(...orderByClauses);
+        return this;
+    }
+
+    offset(limitOffset) {
+        this.query().offset(limitOffset);
+        return this;
+    }
+
+    limit(numberOfRows) {
+        this.query().limit(numberOfRows);
+        return this;
+    }
+
+    getWhere() {
+        return this.query().getWhere();
+    }
+
+    getGroupBy() {
+        return this.query().getGroupBy();
+    }
+
+    getOrderBy() {
+        return this.query().getOrderBy();
+    }
+
+    getOffset() {
+        return this.query().getOffset();
+    }
+
+    getLimit() {
+        return this.query().getLimit();
+    }
+
+    clearWhere() {
+        this.query().clearWhere();
+        return this;
+    }
+
+    clearGroupBy() {
+        this.query().clearGroupBy();
+        return this;
+    }
+
+    clearOrderBy() {
+        this.query().clearOrderBy();
+        return this;
+    }
+
+    clearOffset() {
+        this.query().clearOffset();
+        return this;
+    }
+
+    clearLimit() {
+        this.query().clearLimit();
+        return this;
+    }
+
+    toQuery() {
+    }
+
+}
+
+export {QueryLike};

package/query/QueryOption.js

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,59 @@
+import {QueryLike} from "./QueryLike.js";
+import {isBlank} from "../../scx-common/index.js";
+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/WhereClause.js

@@ -0,0 +1,43 @@
+import {QueryLike} from "./QueryLike.js";
+import {QueryImpl} from "./QueryImpl.js";
+
+class WhereClause extends QueryLike {
+
+    #whereClause;
+    #params;
+
+    constructor(whereClause, params) {
+        super();
+        this.#whereClause = whereClause;
+        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);
+    }
+
+    whereClause() {
+        return this.#whereClause;
+    }
+
+    params() {
+        return this.#params;
+    }
+
+    toQuery() {
+        return new QueryImpl().where(this);
+    }
+
+}
+
+export {WhereClause};

package/query/WhereType.js

@@ -0,0 +1,109 @@
+/**
+ * 为空
+ */
+const IS_NULL = "IS_NULL";
+
+/**
+ * 不为空
+ */
+const IS_NOT_NULL = "IS_NOT_NULL";
+
+/**
+ * 等于
+ */
+const EQUAL = "EQUAL";
+
+/**
+ * 不等于
+ */
+const NOT_EQUAL = "NOT_EQUAL";
+
+/**
+ * 小于
+ */
+const LESS_THAN = "LESS_THAN";
+
+/**
+ * 小于等于
+ */
+const LESS_THAN_OR_EQUAL = "LESS_THAN";
+
+/**
+ * 大于
+ */
+const GREATER_THAN = "GREATER_THAN";
+
+/**
+ * 大于等于
+ */
+const GREATER_THAN_OR_EQUAL = "GREATER_THAN";
+
+/**
+ * Like
+ */
+const LIKE = "LIKE";
+
+/**
+ * Not Like
+ */
+const NOT_LIKE = "NOT_LIKE";
+
+/**
+ * Like 正则表达式
+ */
+const LIKE_REGEX = "LIKE_REGEX";
+
+/**
+ * Like 正则表达式
+ */
+const NOT_LIKE_REGEX = "NOT_LIKE_REGEX";
+
+/**
+ * IN
+ */
+const IN = "IN";
+
+/**
+ * NOT IN
+ */
+const NOT_IN = "NOT_IN";
+
+/**
+ * 在之间
+ */
+const BETWEEN = "BETWEEN";
+
+/**
+ * 不在之间
+ */
+const NOT_BETWEEN = "NOT_BETWEEN";
+
+/**
+ * json 包含 一般用于 数组判断
+ */
+const JSON_CONTAINS = "JSON_CONTAINS";
+
+
+const JSON_OVERLAPS = "JSON_OVERLAPS";
+
+
+export {
+    IS_NULL,
+    IS_NOT_NULL,
+    EQUAL,
+    NOT_EQUAL,
+    LESS_THAN,
+    LESS_THAN_OR_EQUAL,
+    GREATER_THAN,
+    GREATER_THAN_OR_EQUAL,
+    LIKE,
+    NOT_LIKE,
+    LIKE_REGEX,
+    NOT_LIKE_REGEX,
+    IN,
+    NOT_IN,
+    BETWEEN,
+    NOT_BETWEEN,
+    JSON_CONTAINS,
+    JSON_OVERLAPS,
+};

package/query/serializer/GroupBySerializer.js

@@ -0,0 +1,50 @@
+import {Query} from "../Query.js";
+import {isArray} from "../../../scx-common/index.js";
+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

@@ -0,0 +1,54 @@
+import {Query} from "../Query.js";
+import {isArray} from "../../../scx-common/index.js";
+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/QuerySerializer.js

@@ -0,0 +1,35 @@
+import {WhereSerializer} from "./WhereSerializer.js";
+import {GroupBySerializer} from "./GroupBySerializer.js";
+import {OrderBySerializer} from "./OrderBySerializer.js";
+
+class QuerySerializer {
+
+    #whereSerializer;
+    #groupBySerializer;
+    #orderBySerializer;
+
+    constructor() {
+        this.#whereSerializer = new WhereSerializer();
+        this.#groupBySerializer = new GroupBySerializer();
+        this.#orderBySerializer = new OrderBySerializer();
+    }
+
+    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(),
+        };
+    }
+
+}
+
+const QUERY_SERIALIZER = new QuerySerializer();
+
+export {
+    QuerySerializer,
+    QUERY_SERIALIZER,
+};