@asla/yoursql 0.3.0 → 0.4.0

package/dist/mod.d.ts

@@ -5,4 +5,5 @@ export * from "./select/select.ts";
 export * from "./select/selectable.ts";
 export * from "./select/TableQuery.ts";
 export * from "./util.ts";
+export * from "./your_table/mod.ts";
 //# sourceMappingURL=mod.d.ts.map

package/dist/mod.js

@@ -54,8 +54,170 @@ function getObjectListKeys(objectList, keepUndefinedKey) {
     }
     return Array.from(keys);
 }
+/** @public */
+function genWhere(where, type = "AND") {
+    return genWhereHaving(where, "WHERE", type);
+}
+/** @public */
+function genHaving(having, type = "AND") {
+    return genWhereHaving(having, "HAVING", type);
+}
+/**
+ * @public
+ * ```ts
+ * genSelect({c1: true, c2: "count(*)", c3: "column"})  //  "c1,count(*) AS c2,column as c3"
+ * genSelect(["c1", "count(*) AS c2", "column as c3"])  //  "c1,count(*) AS c2,column as c3"
+ * ```
+ */
+function genSelect(columns) {
+    let sql = "";
+    if (columns instanceof Array) {
+        if (columns.length)
+            sql += columns[0];
+        else
+            throw new Error("没有选择任何列");
+        for (let i = 1; i < columns.length; i++)
+            sql += "," + columns[i];
+    }
+    else {
+        const keys = Object.keys(columns);
+        if (keys.length === 0)
+            throw new Error("没有选择任何列");
+        let k = keys[0];
+        let v = columns[k];
+        if (typeof v === "string")
+            sql += v + " AS " + k;
+        else
+            sql += k;
+        for (let i = 1; i < keys.length; i++) {
+            k = keys[i];
+            v = columns[k];
+            sql += ",";
+            if (typeof v === "string")
+                sql += v + " AS " + k;
+            else
+                sql += k;
+        }
+    }
+    return sql;
+}
+/** @public */
+function genOderBy(orderBy) {
+    if (typeof orderBy === "function")
+        orderBy = orderBy();
+    let sql = "";
+    if (typeof orderBy === "string")
+        sql += "\nORDER BY " + orderBy;
+    else if (orderBy instanceof Array) {
+        if (orderBy.length)
+            sql += "\nORDER BY " + orderBy.join(",");
+    }
+    else {
+        let keys = Object.keys(orderBy);
+        if (keys.length)
+            sql += "\nORDER BY " + keys[0] + " " + orderBy[keys[0]];
+        for (let i = 1; i < keys.length; i++) {
+            sql += "," + orderBy[keys[i]] + " " + orderBy[keys[i]];
+        }
+    }
+    return sql;
+}
+function genWhereHaving(where, statement, type = "AND") {
+    if (typeof where === "function")
+        where = where();
+    type = " " + type + " ";
+    let sql = "";
+    if (typeof where === "string")
+        sql += "\n" + statement + " " + where;
+    else {
+        if (where.length)
+            sql += "\n" + statement + " " + +where[0];
+        for (let i = 1; i < where.length; i++)
+            sql += type + where[i];
+    }
+    return sql;
+}
+
+var _SqlQueryStatement_sql;
+/**
+ * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
+ * @example
+ * ```ts
+ * declare const item: SqlSelectable<any>
+ * await query(`select * from ${item.toSelect()}`)
+ *
+ * ```
+ * @public
+ */
+class SqlSelectable {
+    constructor(columns) {
+        // Reflect.set(this, SQL_SELECTABLE, undefined);
+        let readonlyColumns;
+        if (typeof columns[Symbol.iterator] === "function") {
+            let iterable = columns;
+            readonlyColumns = [];
+            let iter = iterable[Symbol.iterator]();
+            let i = 0;
+            let item = iter.next();
+            while (!item.done) {
+                readonlyColumns[i++] = item.value;
+                item = iter.next();
+            }
+            // readonlyColumns.length = i;
+        }
+        else {
+            let arrayLike = columns;
+            readonlyColumns = new Array(arrayLike.length);
+            // readonlyColumns.length = arrayLike.length;
+            for (let i = 0; i < arrayLike.length; i++) {
+                readonlyColumns[i] = arrayLike[i];
+            }
+        }
+        this.columns = readonlyColumns;
+    }
+}
+/**
+ * 数据库表
+ * @public
+ */
+class DbTable extends SqlSelectable {
+    constructor(name, columns) {
+        if (!(columns instanceof Array))
+            columns = Object.keys(columns);
+        super(columns);
+        this.name = name;
+    }
+    toSelect() {
+        return this.name;
+    }
+    toString() {
+        return this.name;
+    }
+}
+/**
+ * SELECT 以及 UPDATE、DELETE、INSERT INTO 带结果的 SQL 语句
+ * @public
+ */
+class SqlQueryStatement extends SqlSelectable {
+    constructor(sql, columns) {
+        if (sql instanceof SqlQueryStatement) {
+            columns = sql.columns;
+            sql = __classPrivateFieldGet(sql, _SqlQueryStatement_sql, "f");
+        }
+        super(columns);
+        _SqlQueryStatement_sql.set(this, void 0);
+        __classPrivateFieldSet(this, _SqlQueryStatement_sql, sql, "f");
+    }
+    toString() {
+        return __classPrivateFieldGet(this, _SqlQueryStatement_sql, "f");
+    }
+    toSelect() {
+        return "(" + this.toString() + ")";
+    }
+}
+_SqlQueryStatement_sql = new WeakMap();
 
-var _SqlRaw_value;
+var _SqlRaw_value, _YourValuesAs_asName, _YourValuesAs_valuesStr, _YourValuesAs_sql;
 /**
  * SQL 原始字符对象
  * @public
@@ -217,7 +379,70 @@ class SqlValuesCreator {
     toValues(values) {
         return values.map((v) => this.toSqlStr(v)).join(",");
     }
+    createValues(asName, values, valuesTypes) {
+        if (values.length === 0)
+            throw new Error("values 不能为空");
+        const insertKeys = Object.keys(valuesTypes);
+        const defaultValues = [];
+        const valuesStr = new Array(values.length);
+        {
+            const column0 = new Array(insertKeys.length);
+            let columnName;
+            let item;
+            let type;
+            let value;
+            for (let i = 0; i < insertKeys.length; i++) {
+                columnName = insertKeys[i];
+                item = valuesTypes[columnName];
+                if (typeof item === "string") {
+                    type = item;
+                    defaultValues[i] = "NULL";
+                }
+                else {
+                    type = item.sqlType;
+                    defaultValues[i] = item.sqlDefault ?? "NULL";
+                }
+                value = values[0][columnName];
+                if (value === undefined)
+                    column0[i] = defaultValues[i] + "::" + type;
+                else
+                    column0[i] = this.toSqlStr(value) + "::" + type;
+            }
+            valuesStr[0] = "(" + column0.join(",") + ")";
+        }
+        let items = new Array(insertKeys.length);
+        let value;
+        for (let i = 1; i < values.length; i++) {
+            for (let j = 0; j < insertKeys.length; j++) {
+                value = values[i][insertKeys[j]];
+                if (value === undefined)
+                    items[j] = defaultValues[j];
+                else
+                    items[j] = this.toSqlStr(value);
+            }
+            valuesStr[i] = "(" + items.join(",") + ")";
+        }
+        return new YourValuesAs(insertKeys, asName, valuesStr.join(",\n"));
+    }
+}
+class YourValuesAs extends SqlSelectable {
+    constructor(columns, asName, valuesStr) {
+        super(columns);
+        _YourValuesAs_asName.set(this, void 0);
+        _YourValuesAs_valuesStr.set(this, void 0);
+        _YourValuesAs_sql.set(this, void 0);
+        __classPrivateFieldSet(this, _YourValuesAs_asName, asName, "f");
+        __classPrivateFieldSet(this, _YourValuesAs_valuesStr, valuesStr, "f");
+        __classPrivateFieldSet(this, _YourValuesAs_sql, `(VALUES\n${__classPrivateFieldGet(this, _YourValuesAs_valuesStr, "f")})\nAS ${__classPrivateFieldGet(this, _YourValuesAs_asName, "f")}(${this.columns.join(",")})`, "f");
+    }
+    toSelect() {
+        return __classPrivateFieldGet(this, _YourValuesAs_sql, "f");
+    }
+    toString() {
+        return __classPrivateFieldGet(this, _YourValuesAs_sql, "f");
+    }
 }
+_YourValuesAs_asName = new WeakMap(), _YourValuesAs_valuesStr = new WeakMap(), _YourValuesAs_sql = new WeakMap();
 function toKeyType(object, keys_types) {
     let type = {};
     let keys;
@@ -259,107 +484,98 @@ const pgSqlTransformer = new Map([
     [Date, (value) => SqlValuesCreator.string(value.toISOString())],
 ]);
 
-/**
- * 可选择项。可以是 table、查询结果等，它能被 select 语句选择
- * @example
- * ```ts
- * declare const item: SqlSelectable<any>
- * await query(`select * from ${item.toSelect()}`)
- *
- * ```
- * @public
- */
-class SqlSelectable {
-    constructor(columns) {
-        // Reflect.set(this, SQL_SELECTABLE, undefined);
-        let readonlyColumns;
-        if (typeof columns[Symbol.iterator] === "function") {
-            let iterable = columns;
-            readonlyColumns = [];
-            let iter = iterable[Symbol.iterator]();
-            let i = 0;
-            let item = iter.next();
-            while (!item.done) {
-                readonlyColumns[i++] = item.value;
-                item = iter.next();
-            }
-            // readonlyColumns.length = i;
-        }
-        else {
-            let arrayLike = columns;
-            readonlyColumns = new Array(arrayLike.length);
-            // readonlyColumns.length = arrayLike.length;
-            for (let i = 0; i < arrayLike.length; i++) {
-                readonlyColumns[i] = arrayLike[i];
-            }
-        }
-        this.columns = readonlyColumns;
+var _SelectImpl_instances, _a, _SelectImpl_join;
+class FinalSelectImpl extends SqlQueryStatement {
+    constructor(statement) {
+        super(statement);
     }
-}
-/**
- * 数据库表
- * @public
- */
-class DbTable extends SqlSelectable {
-    constructor(name, columns) {
-        if (!(columns instanceof Array))
-            columns = Object.keys(columns);
-        super(columns);
-        this.name = name;
+    filter(option) {
+        let { orderBy } = option;
+        let sql = this.toString();
+        if (orderBy)
+            sql += genOderBy(orderBy);
+        if (option.limit)
+            sql += "\nLIMIT " + option.limit;
+        if (option.offset)
+            sql += "\nOFFSET " + option.offset;
+        return new SqlQueryStatement(sql, Array.from(this.columns));
     }
-    toSelect() {
-        return this.name;
+}
+/** @public */
+function createSelect(selectable, as) {
+    return new SelectImpl("FROM " + fromAs(selectable, as));
+}
+function fromAs(selectable, as) {
+    let sql = typeof selectable === "string" ? selectable : selectable.toSelect();
+    if (as)
+        sql += " AS " + as;
+    return sql;
+}
+class SelectImpl {
+    constructor(str) {
+        _SelectImpl_instances.add(this);
+        this.str = str;
     }
     toString() {
-        return this.name;
+        return this.str;
     }
-}
-/**
- * SELECT 以及 UPDATE、DELETE、INSERT INTO 带结果的 SQL 语句
- * @public
- */
-class SqlQueryStatement extends SqlSelectable {
-    constructor(sql, columns) {
-        super(columns);
-        this.sql = sql;
+    fullJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "FULL JOIN", selectable, as, on);
     }
-    toString() {
-        return this.sql;
+    innerJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "INNER JOIN", selectable, as, on);
     }
-    toSelect() {
-        return "(" + this.toString() + ")";
+    leftJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "LEFT JOIN", selectable, as, on);
     }
-}
-
-function genOderBy(orderBy, orderNullRule) {
-    let select = [];
-    let v;
-    for (const key of Object.keys(orderBy)) {
-        v = orderBy[key];
-        switch (v) {
-            case "ASC":
-                break;
-            case "DESC":
-                break;
-            default:
-                throw new Error("orderBy 只能是 ASE 或 DESC. 当前值：" + String(v));
-        }
-        select.push(key + " " + v);
+    rightJoin(selectable, as, on) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "RIGHT JOIN", selectable, as, on);
     }
-    let sql = "\nORDER BY " + select.join(", ");
-    if (orderNullRule) {
-        switch (orderNullRule) {
-            case "FIRST":
-                break;
-            case "LAST":
-                break;
-            default:
-                throw new Error("orderNullRule 只能是 FIRST 或 LAST. 当前值：" + String(orderNullRule));
+    naturalJoin(selectable, as) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "NATURAL JOIN", selectable, as);
+    }
+    crossJoin(selectable, as) {
+        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "CROSS JOIN", selectable, as);
+    }
+    from(selectable, as) {
+        return new _a(this.str + "," + fromAs(selectable, as));
+    }
+    select(columnsIn) {
+        let sql = "SELECT ";
+        let columns = [];
+        if (typeof columnsIn === "string")
+            sql += columnsIn;
+        else {
+            sql += genSelect(columnsIn);
+            if (columnsIn instanceof Array) ;
+            else
+                columns = Object.keys(columnsIn);
         }
-        sql += "NULLS " + orderNullRule;
+        sql += "\n" + this.str;
+        return new FinalSelectImpl(new SqlQueryStatement(sql, columns));
+    }
+    groupBy(columns) {
+        let sql = this.str;
+        if (typeof columns === "string")
+            sql += " GROUP BY " + columns;
+        else
+            sql += " GROUP BY " + columns.join(",");
+        return new _a(sql);
+    }
+    having(param) {
+        return new _a(this.str + genWhere(param));
+    }
+    where(param) {
+        return new _a(this.str + genWhere(param));
     }
-    return sql;
 }
+_a = SelectImpl, _SelectImpl_instances = new WeakSet(), _SelectImpl_join = function _SelectImpl_join(type, selectable, as, on) {
+    let sql = this.str + "\n" + type + " " + fromAs(selectable, as);
+    if (on)
+        sql += " ON " + on;
+    return new _a(sql);
+};
+
 function selectColumnsOrTable(columns) {
     let sqlSelect;
     let select;
@@ -387,236 +603,15 @@ function selectColumnsOrTable(columns) {
         throw new Error("选择列为空");
     return { columns: select, sqlColumns: sqlSelect.join(", ") };
 }
-/**
- * @param select  选择的行
- * @param tableColumns 全部行
- * @param push 要讲选择的行加入到集合中。
- */
-function genNewColumns(select, tableColumns, 
-/** newName -> oldName */
-push = new Map()) {
-    if (select === "*") {
-        for (const key of tableColumns) {
-            if (push.has(key))
-                throw new ColumnRepeatError(key);
-            push.set(key, null);
-        }
-    }
-    else {
-        genSelectAsColumns(select, push);
-    }
-    return push;
-}
-function genSelectAsColumns(select, 
-/** newName -> oldName */
-push = new Map()) {
-    if (select instanceof Array) {
-        for (const key of select) {
-            if (push.has(key))
-                throw new ColumnRepeatError(key);
-            push.set(key, null);
-        }
-    }
-    else {
-        let finalName;
-        for (const oldName of Object.keys(select)) {
-            if (typeof select[oldName] === "string")
-                finalName = select[oldName];
-            else if (select[oldName])
-                finalName = oldName;
-            else
-                continue;
-            if (push.has(finalName))
-                throw new ColumnRepeatError(finalName);
-            push.set(finalName, oldName);
-        }
-    }
-    return push;
-}
-class ColumnRepeatError extends Error {
-    constructor(columnName) {
-        super("Column name '" + columnName + "' repeated");
-    }
-}
-
-var _SelectImpl_instances, _a, _SelectImpl_joinOn, _SelectImpl_join;
-/** @public */
-const createSelect = function createSelect(tb, columns, option) {
-    let select = createSelectMap(tb, columns, option).selects;
-    return new SelectImpl(select);
-};
-function* mergeColumns(a, b) {
-    for (const { columns } of a)
-        yield* columns.keys();
-    yield* b;
-}
-class SelectImpl extends SqlSelectable {
-    constructor(tableList, addedColumns) {
-        super(addedColumns ? mergeColumns(tableList.values(), addedColumns.keys()) : tableList.keys());
-        _SelectImpl_instances.add(this);
-        this.tableList = tableList;
-        this.addedColumns = addedColumns;
-    }
-    toSelect() {
-        return "(" + this.toString() + ")";
-    }
-    toString() {
-        let tables = [];
-        let join = "";
-        let selectColumns = [];
-        const size = this.tableList.size;
-        for (const [tableAs, { columns, from, on, type }] of this.tableList) {
-            let tableStr = tableAs === from ? from : from + " AS " + tableAs;
-            if (type) {
-                join += "\n" + type + " " + tableStr;
-                if (on)
-                    join += " ON " + on;
-            }
-            else {
-                tables.push(tableStr);
-            }
-            if (size === 1 && tableAs === from) {
-                for (const [column, oldName] of columns) {
-                    if (!oldName || oldName == column)
-                        selectColumns.push(column);
-                    else
-                        selectColumns.push(oldName + " AS " + column);
-                }
-            }
-            else {
-                for (const [column, oldName] of columns) {
-                    if (!oldName || oldName === column)
-                        selectColumns.push(tableAs + "." + column);
-                    else
-                        selectColumns.push(tableAs + "." + oldName + " AS " + column);
-                }
-            }
-        }
-        if (this.addedColumns) {
-            for (const [asName, columnStr] of this.addedColumns) {
-                if (asName === columnStr)
-                    selectColumns.push(asName);
-                else
-                    selectColumns.push(columnStr + " AS " + asName);
-            }
-        }
-        if (selectColumns.length === 0)
-            throw new Error("Columns 为空");
-        let sql = `SELECT ${selectColumns.join(", ")}\nFROM ${tables.join(", ")}` + join;
-        return sql;
-    }
-    fullJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "FULL JOIN", tb, columns, option);
-    }
-    innerJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "INNER JOIN", tb, columns, option);
-    }
-    leftJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "LEFT JOIN", tb, columns, option);
-    }
-    rightJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_joinOn).call(this, "RIGHT JOIN", tb, columns, option);
-    }
-    naturalJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "NATURAL JOIN", tb, columns, option);
-    }
-    crossJoin(tb, columns, option) {
-        return __classPrivateFieldGet(this, _SelectImpl_instances, "m", _SelectImpl_join).call(this, "CROSS JOIN", tb, columns, option);
-    }
-    select(tb, columns, option) {
-        let select = createSelectMap(tb, columns, option, this.tableList).selects;
-        const obj = new _a(select, new Map(this.addedColumns));
-        return obj;
-    }
-    addColumns(add) {
-        let addedColumns = this.addedColumns ? new Map(this.addedColumns) : new Map();
-        for (const [asNewName, columnStr] of Object.entries(add)) {
-            if (addedColumns.has(asNewName))
-                throw new Error(`The column ${asNewName} already exists`);
-            addedColumns.set(asNewName, columnStr);
-        }
-        return new _a(this.tableList, addedColumns);
-    }
-    toQuery(option = {}) {
-        const { where, orderNullRule } = option;
-        let sql = this.toString();
-        if (where)
-            sql += "\nWHERE " + where;
-        const orderBy = option.orderBy;
-        if (orderBy)
-            sql += genOderBy(orderBy, orderNullRule);
-        if (option.limit)
-            sql += "\nLIMIT " + option.limit;
-        if (option.offset)
-            sql += "\nOFFSET " + option.offset;
-        return new SqlQueryStatement(sql, Array.from(this.columns));
-    }
-}
-_a = SelectImpl, _SelectImpl_instances = new WeakSet(), _SelectImpl_joinOn = function _SelectImpl_joinOn(type, tb, columns, option) {
-    let { selects, tbInfo } = createSelectMap(tb, columns, option, this.tableList);
-    tbInfo.type = type;
-    tbInfo.on = option.on;
-    const next = new _a(selects, new Map(this.addedColumns));
-    Object.defineProperty(next, "select", { value: undefined, configurable: false, enumerable: false });
-    return next;
-}, _SelectImpl_join = function _SelectImpl_join(type, tb, columns, option) {
-    let { selects, tbInfo } = createSelectMap(tb, columns, option, this.tableList);
-    tbInfo.type = type;
-    const next = new _a(selects, new Map(this.addedColumns));
-    Object.defineProperty(next, "select", { value: undefined, configurable: false, enumerable: false });
-    return next;
-};
-function createSelectMap(tb, columns, option = {}, selects) {
-    let select = new Map(selects);
-    let tableAs;
-    let tbInfo;
-    if (typeof tb === "string") {
-        throw new Error("tb 应是 SqlSelectable 类型");
-        // if (typeof columns !== "object") throw new Error("缺少 option.columns");
-        // const newColumns = genSelectAsColumns(columns);
-        // tableAs = option.tableAs ?? tb;
-        // tbInfo = { table: tb, columns: newColumns };
-    }
-    else {
-        const from = tb.toSelect();
-        if (tb instanceof DbTable) {
-            tableAs = option.tableAs ?? from;
-        }
-        else {
-            tableAs = option.tableAs ?? "t" + select.size;
-        }
-        if (columns) {
-            const newColumns = genNewColumns(columns, tb.columns);
-            tbInfo = { from, columns: newColumns };
-        }
-        else
-            tbInfo = { from, columns: new Map() };
-    }
-    if (select.has(tableAs))
-        throw new TableRepeatError(tableAs);
-    select.set(tableAs, tbInfo);
-    return { selects: select, tbInfo: tbInfo };
-}
-class TableRepeatError extends Error {
-    constructor(tableName) {
-        super("Table name '" + tableName + "' repeated");
-    }
-}
-// interface SqlFrom<T extends object> {
-//   from<A extends object>(table: SqlSelectable<A>): SqlFrom<T & A>;
-// }
-// declare function from<T extends SqlSelectable<any>[]>(...table: T): Select<MergeSelectable<T>>;
-// type MergeSelectable<T extends any[]> = T extends [SqlSelectable<infer P>, ...infer Q] ? P & MergeSelectable<Q> : {};
 
 /** @public */
 class DbTableQuery extends DbTable {
     constructor(name, columns, statement) {
         super(name, columns);
-        this.name = name;
         this.statement = statement;
     }
-    select(columns, option) {
-        return createSelect(this, columns, option);
+    fromAs(as) {
+        return createSelect(this, as);
     }
     insert(values, option) {
         let insertCol;
@@ -703,8 +698,176 @@ function genRetuningSql(sql, returns, tableColumns) {
     sql += "\nRETURNING " + columnsStr;
     return new SqlQueryStatement(sql, columns);
 }
-function genWhere(where) {
-    return "\nWHERE " + where;
+
+/**
+ * 表格列的信息
+ * @public
+ */
+class ColumnMeta {
+    constructor(type, 
+    /** 数据库原始数据类型 */
+    sqlType, 
+    /** 是否非空 */
+    notNull = false, 
+    /** 是否是数组类型 */
+    isArray = false, 
+    /** 数据库原始默认值 */
+    sqlDefault) {
+        this.type = type;
+        this.sqlType = sqlType;
+        this.notNull = notNull;
+        this.isArray = isArray;
+        this.sqlDefault = sqlDefault;
+    }
+    /** 校验 value 的类型 */
+    checkValue(value) {
+        if (typeof this.type === "function")
+            return value instanceof this.type;
+        return this.type.is(value);
+    }
+}
+/**
+ * 数据库类型到JS类型的映射
+ * @public
+ */
+class YourTypeMap {
+    static create(rawTypeMap) {
+        return new this(rawTypeMap);
+    }
+    constructor(typeMap = {}) {
+        this.typeMap = typeMap;
+    }
+    genColumn(type, notNull, defaultValue) {
+        const constructor = Reflect.get(this.typeMap, type);
+        const column = new ColumnMeta(constructor, type, notNull, false, defaultValue);
+        return column;
+    }
+    genArrColumn(type, notNull, defaultValue) {
+        const constructor = Reflect.get(this.typeMap, type);
+        const column = new ColumnMeta(constructor, type + "[]", notNull, true, defaultValue);
+        return column;
+    }
+}
+function baseType(v) {
+    return typeof v === this.name;
+}
+/**
+ * 自定义数据类型
+ * @public
+ */
+class CustomDbType {
+    constructor(is, name) {
+        this.is = is;
+        this.name = name;
+    }
+}
+CustomDbType.bigint = new CustomDbType(baseType, "bigint");
+CustomDbType.number = new CustomDbType(baseType, "number");
+CustomDbType.string = new CustomDbType(baseType, "string");
+CustomDbType.boolean = new CustomDbType(baseType, "boolean");
+
+/** @public */
+class TypeChecker {
+    constructor(map) {
+        this.map = map;
+    }
+    check(value) {
+        const map = this.map;
+        let v;
+        for (const [k, expect] of map) {
+            v = value[k];
+            let err;
+            if (v === null) {
+                if (expect.notNull)
+                    throw new Error(`${k} 不能为空`);
+                continue;
+            }
+            else if (v === undefined) {
+                if (expect.sqlDefault === undefined && expect.notNull)
+                    throw new Error(`${k} 不能为 undefined`);
+                continue;
+            }
+            else if (expect.isArray) {
+                if (v instanceof Array)
+                    err = this.checkArray(v, expect.type);
+                else
+                    err = getErrStr(`Array<${expect.type.name}>`, typeof v);
+            }
+            else {
+                err = this.checkItem(v, expect.type);
+            }
+            if (err)
+                throw new Error(`Key ${k} error: ${err}`);
+        }
+        return value;
+    }
+    checkList(value) {
+        let i = 0;
+        try {
+            for (let i = 0; i < value.length; i++) {
+                this.check(value[i]);
+            }
+            return value;
+        }
+        catch (error) {
+            throw new Error(`Item ${i}, ${error.message}`);
+        }
+    }
+    checkArray(v, expect) {
+        let err;
+        for (let i = 0; i < v.length; i++) {
+            err = this.checkItem(v[i], expect);
+            if (err)
+                return `Item[${i}] ${err}`;
+        }
+    }
+    checkItem(v, expect) {
+        if (expect instanceof CustomDbType) {
+            if (expect.is(v))
+                return;
+        }
+        else {
+            if (v instanceof expect)
+                return;
+        }
+        let actName = typeof v;
+        if (actName === "object") {
+            if (v === null)
+                actName = "null";
+            else
+                actName = v.constructor?.name ?? "object";
+        }
+        return getErrStr(expect.name, typeof v);
+    }
+}
+function getErrStr(expect, actual) {
+    return `Expect ${expect}, Actual ${actual}`;
+}
+
+/**
+ * 完整数据库表数据
+ * @public
+ */
+class YourTable extends DbTableQuery {
+    constructor(name, define, sqlValue) {
+        super(name, Object.keys(define), sqlValue);
+        this.define = define;
+    }
+    getColumnMeta(name) {
+        return Reflect.get(this.define, name);
+    }
+    createTypeChecker(keys) {
+        let map = new Map();
+        let defined = this.define;
+        let k;
+        for (let i = 0; i < keys.length; i++) {
+            k = keys[i];
+            if (defined[k] === undefined)
+                throw new Error(`key ${k} 未定义`);
+            map.set(k, defined[k]);
+        }
+        return new TypeChecker(map);
+    }
 }
 
-export { DbTable, DbTableQuery, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, createSelect, getObjectListKeys, pgSqlTransformer };
+export { ColumnMeta, CustomDbType, DbTable, DbTableQuery, SqlQueryStatement, SqlRaw, SqlSelectable, SqlValuesCreator, TypeChecker, YourTable, YourTypeMap, createSelect, genHaving, genOderBy, genSelect, genWhere, getObjectListKeys, pgSqlTransformer };

package/dist/select/TableQuery.d.ts

@@ -1,18 +1,13 @@
 import { SqlValuesCreator, SqlRaw } from "../sql_value/sql_value.ts";
-import { ColumnsSelected, ColumnsSelectAs, SelectColumns, UpdateRowValue, TableType } from "./type.ts";
-import { Select, SelectTableOption } from "./select.ts";
+import { ColumnsSelected, SelectColumns, UpdateRowValue, TableType } from "./type.ts";
+import { JoinSelect } from "./select.ts";
 import { DbTable, SqlQueryStatement } from "./selectable.ts";
+import { WhereParam } from "../util.ts";
 /** @public */
 export declare class DbTableQuery<T extends TableType = Record<string, any>, C extends TableType = Partial<T>> extends DbTable<T> {
-    readonly name: string;
     private statement;
     constructor(name: string, columns: readonly string[], statement: SqlValuesCreator);
-    /** 选择全部列 */
-    select(columns?: undefined, option?: SelectTableOption): Select<{}>;
-    /** 选择全部列 */
-    select(columns: "*", option?: SelectTableOption): Select<T>;
-    /** 选择表中的列并重命名 */
-    select<R extends ColumnsSelectAs<T>>(columns: R, option?: SelectTableOption): Select<SelectColumns<T, R>>;
+    fromAs(as?: string): JoinSelect;
     insert(values: C[] | SqlQueryStatement<C>, option?: InsertOption<T>): string;
     insertWithResult<R extends ColumnsSelected<T>>(values: C[] | SqlQueryStatement<C>, returns: R, option?: InsertOption<T>): SqlQueryStatement<SelectColumns<T, R>>;
     update(values: UpdateRowValue<T>, option?: UpdateOption): string;
@@ -26,14 +21,14 @@ export interface InsertOption<T extends object> {
     updateValues?: {
         [key in keyof T]?: undefined | SqlRaw | T[key];
     };
-    where?: string;
+    where?: WhereParam;
 }
 /** @public */
 export interface UpdateOption {
-    where?: string;
+    where?: WhereParam;
 }
 /** @public */
 export interface DeleteOption {
-    where?: string;
+    where?: WhereParam;
 }
 //# sourceMappingURL=TableQuery.d.ts.map

package/dist/select/_statement.d.ts

@@ -1,15 +1,6 @@
-import { ColumnsSelectAs, ColumnsSelected, RowsOrder } from "./type.ts";
-export declare function genOderBy(orderBy: RowsOrder<any>, orderNullRule?: "FIRST" | "LAST"): string;
+import { ColumnsSelectAs } from "./type.ts";
 export declare function selectColumnsOrTable(columns: ColumnsSelectAs<any> | string[]): {
     columns: string[];
     sqlColumns: string;
 };
-/**
- * @param select  选择的行
- * @param tableColumns 全部行
- * @param push 要讲选择的行加入到集合中。
- */
-export declare function genNewColumns(select: ColumnsSelected<any>, tableColumns: Iterable<string | number | symbol>, 
-/** newName -> oldName */
-push?: Map<string, string | null>): Map<string, string | null>;
 //# sourceMappingURL=_statement.d.ts.map

package/dist/select/select.d.ts

@@ -1,55 +1,44 @@
-import { SqlSelectable, InferQueryResult, SqlQueryStatement } from "./selectable.ts";
-import type { ColumnsSelected, RowsOrder, SelectColumns, TableType } from "./type.ts";
-interface AddTableFn<T extends TableType> {
-    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>>(tb: Q, columns?: undefined, option?: SelectTableOption): Select<T>;
-    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>, C extends ColumnsSelected<A>>(tb: Q, columns: C, option?: SelectTableOption): Select<T & SelectColumns<A, C>>;
-}
-interface JoinTableFn<T extends TableType, ExtraOption extends object = {}> {
-    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>>(tb: Q, columns: undefined, option: ExtraOption & SelectTableOption): JoinSelect<T>;
-    <Q extends SqlSelectable<any>, A extends InferQueryResult<Q>, C extends ColumnsSelected<A>>(tb: Q, columns: C, option: ExtraOption & SelectTableOption): JoinSelect<T & SelectColumns<A, C>>;
-}
+import { SqlSelectable, SqlQueryStatement } from "./selectable.ts";
+import { OrderByParam, WhereParam } from "../util.ts";
+import type { TableType } from "./type.ts";
 /** @public */
 export interface SelectFilterOption<T extends object> {
-    orderBy?: RowsOrder<T>;
-    orderNullRule?: "FIRST" | "LAST";
-    where?: string;
+    orderBy?: string | OrderByParam<T> | (() => string | OrderByParam<T>);
     offset?: number;
     limit?: number;
 }
 /** @public */
 export interface FinalSelect<T extends TableType> extends SqlSelectable<T> {
-    toQuery(option?: SelectFilterOption<T>): SqlQueryStatement<T>;
+    filter(option: SelectFilterOption<T>): SqlQueryStatement<T>;
 }
 /** @public */
-export interface JoinSelect<T extends TableType> extends FinalSelect<T> {
-    addColumns<A extends TableType>(add: {
-        [key in keyof A]: string;
-    }): FinalSelect<T & A>;
-    crossJoin: JoinTableFn<T>;
-    naturalJoin: JoinTableFn<T>;
-    innerJoin: JoinTableFn<T, {
-        on: string;
-    }>;
-    leftJoin: JoinTableFn<T, {
-        on: string;
-    }>;
-    rightJoin: JoinTableFn<T, {
-        on: string;
-    }>;
-    fullJoin: JoinTableFn<T, {
-        on: string;
-    }>;
-}
+export type LastSelect = {
+    select<T extends TableType = TableType>(columns: "*" | string[] | {
+        [key in keyof T]: string | boolean;
+    }): FinalSelect<T>;
+};
 /** @public */
-export interface Select<T extends TableType> extends JoinSelect<T> {
-    /** 选择表 */
-    select: AddTableFn<T>;
-}
+export type AfterGroup = LastSelect & {
+    having(param: WhereParam | (() => WhereParam)): LastSelect;
+};
+/** @public */
+export type AfterWhere = AfterGroup & {
+    groupBy(columns: string | string[]): AfterGroup;
+};
 /** @public */
-export declare const createSelect: AddTableFn<{}>;
+export type AfterJoin = AfterWhere & {
+    where(param: WhereParam | (() => WhereParam)): AfterWhere;
+};
 /** @public */
-export interface SelectTableOption {
-    tableAs?: string;
+export interface JoinSelect extends AfterJoin {
+    from(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
+    crossJoin(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
+    naturalJoin(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
+    innerJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
+    leftJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
+    rightJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
+    fullJoin(selectable: SqlSelectable<any> | string, as: string | undefined, on: string): JoinSelect;
 }
-export {};
+/** @public */
+export declare function createSelect(selectable: SqlSelectable<any> | string, as?: string): JoinSelect;
 //# sourceMappingURL=select.d.ts.map

package/dist/select/selectable.d.ts

@@ -23,7 +23,7 @@ export declare abstract class SqlSelectable<T extends TableType> {
     /** 获取 SQL 语句 */
     abstract toString(): string;
     /** 保留以推断类型 */
-    private [SQL_SELECTABLE];
+    protected [SQL_SELECTABLE]: T;
 }
 /**
  * 数据库表
@@ -40,8 +40,9 @@ export declare class DbTable<T extends TableType> extends SqlSelectable<T> {
  * @public
  */
 export declare class SqlQueryStatement<T extends TableType = TableType> extends SqlSelectable<T> {
-    private sql;
+    #private;
     constructor(sql: string, columns: readonly string[]);
+    constructor(sql: SqlQueryStatement);
     toString(): string;
     toSelect(): string;
 }

package/dist/select/type.d.ts

@@ -14,13 +14,6 @@ export type PickColumn<T extends {
 } & {
     [key in Pa]?: T[key];
 };
-/**
- * 定义行的排序
- * @public
- */
-export type RowsOrder<T extends object> = {
-    [key in keyof T]?: OrderValue;
-};
 /** @public */
 export type UpdateRowValue<T extends object> = {
     [key in keyof T]?: T[key] | SqlRaw;

package/dist/sql_value/sql_value.d.ts

@@ -1,3 +1,4 @@
+import { SqlSelectable } from "../select/selectable.ts";
 declare const SQL_RAW: unique symbol;
 /**
  * SQL 原始字符对象
@@ -8,7 +9,7 @@ export declare class SqlRaw<T = any> {
     constructor(value: string);
     toString(): string;
     /** 保留以推断类型 */
-    private [SQL_RAW];
+    protected [SQL_RAW]: T;
 }
 /** @public */
 export type JsObjectMapSql = Map<new (...args: any[]) => any, SqlValueEncoder>;
@@ -65,6 +66,22 @@ export declare class SqlValuesCreator {
      * @example 返回示例： " 'abc', '6', 'now()' "
      */
     toValues(values: readonly any[]): string;
+    /**
+     * @public 创建 VALUES AS  语句
+     * @example
+     * ```ts
+     *  sqlValue.createValues(
+     *    "customName",
+     *    [{age:8, name:"hhh"}, {age:9, name:"row2"}],
+     *    {age:"INT", name:"TEXT"}
+     *  )
+     * // (VALUES (8:INT,'hhh':TEXT),(9,'row2')) AS customName(age, name)
+     * ```
+     */
+    createValues<T extends {}>(asName: string, values: T[], valuesTypes: Record<string, string | {
+        sqlType: string;
+        sqlDefault?: string;
+    }>): SqlSelectable<T>;
 }
 export {};
 //# sourceMappingURL=sql_value.d.ts.map

package/dist/util.d.ts

@@ -1,6 +1,27 @@
+import { OrderValue } from "./select/type.ts";
 /**
  * @public
  * @param keepUndefinedKey - 是否保留值为 undefined 的 key
  */
 export declare function getObjectListKeys(objectList: any[], keepUndefinedKey?: boolean): string[];
+/** @public */
+export type WhereParam = string | string[];
+/** @public */
+export declare function genWhere(where: WhereParam | (() => WhereParam), type?: "AND" | "OR"): string;
+/** @public */
+export declare function genHaving(having: WhereParam | (() => WhereParam), type?: "AND" | "OR"): string;
+/**
+ * @public
+ * ```ts
+ * genSelect({c1: true, c2: "count(*)", c3: "column"})  //  "c1,count(*) AS c2,column as c3"
+ * genSelect(["c1", "count(*) AS c2", "column as c3"])  //  "c1,count(*) AS c2,column as c3"
+ * ```
+ */
+export declare function genSelect(columns: string[] | Record<string, string | boolean>): string;
+/** @public */
+export type OrderByParam<T extends {} = {}> = string | string[] | ({
+    [key in keyof T]: OrderValue;
+} & Record<string, OrderValue>);
+/** @public */
+export declare function genOderBy<T extends {} = {}>(orderBy: OrderByParam<T> | (() => OrderByParam<T>)): string;
 //# sourceMappingURL=util.d.ts.map

package/dist/your_table/checker.d.ts

@@ -0,0 +1,13 @@
+import { ColumnMeta } from "./infer_db_type.ts";
+/** @public */
+export declare class TypeChecker<T> {
+    private map;
+    constructor(map: Map<string, ColumnMeta<any>>);
+    check(value: {
+        [key: string]: any;
+    }): T;
+    checkList(value: any[]): T[];
+    private checkArray;
+    private checkItem;
+}
+//# sourceMappingURL=checker.d.ts.map

package/dist/your_table/infer_db_type.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 表格列的信息
+ * @public
+ */
+export declare class ColumnMeta<T> {
+    readonly type: CustomDbType<T> | (new (...args: any[]) => T);
+    /** 数据库原始数据类型 */
+    readonly sqlType: string;
+    /** 是否非空 */
+    readonly notNull: boolean;
+    /** 是否是数组类型 */
+    readonly isArray: boolean;
+    /** 数据库原始默认值 */
+    readonly sqlDefault?: string | undefined;
+    constructor(type: CustomDbType<T> | (new (...args: any[]) => T), 
+    /** 数据库原始数据类型 */
+    sqlType: string, 
+    /** 是否非空 */
+    notNull?: boolean, 
+    /** 是否是数组类型 */
+    isArray?: boolean, 
+    /** 数据库原始默认值 */
+    sqlDefault?: string | undefined);
+    /** 校验 value 的类型 */
+    checkValue(value: any): boolean;
+}
+/**
+ * 数据库类型到JS类型的映射
+ * @public
+ */
+export declare class YourTypeMap<M extends TypeMapDefined> {
+    private readonly typeMap;
+    static create<T extends TypeMapDefined>(rawTypeMap?: T): YourTypeMap<{
+        [key in keyof T]: InferTypeMapDefined<T[key]>;
+    }>;
+    constructor(typeMap?: M);
+    genColumn<T extends keyof M>(type: T, noNull: true, defaultValue?: string): ColumnMeta<M[T]>;
+    genColumn<T extends keyof M>(type: T, noNull?: boolean, defaultValue?: string): ColumnMeta<M[T] | null>;
+    genColumn<T>(type: keyof M, noNull: true, defaultValue?: string): ColumnMeta<T>;
+    genColumn<T>(type: keyof M, noNull?: boolean, defaultValue?: string): ColumnMeta<T | null>;
+    genArrColumn<T extends keyof M>(type: T, noNull: true, defaultValue?: string): ColumnMeta<M[T][]>;
+    genArrColumn<T extends keyof M>(type: T, noNull?: boolean, defaultValue?: string): ColumnMeta<M[T][] | null>;
+    genArrColumn<T>(type: keyof M, notNull: true, defaultValue?: string): ColumnMeta<T[]>;
+    genArrColumn<T>(type: keyof M, notNull?: boolean, defaultValue?: string): ColumnMeta<T[] | null>;
+}
+type Constructor<T = any> = new (...args: any[]) => T;
+/**
+ * 自定义数据类型
+ * @public
+ */
+export declare class CustomDbType<T> {
+    readonly is: (this: CustomDbType<T>, value: any) => boolean;
+    readonly name: string;
+    static readonly bigint: CustomDbType<bigint>;
+    static readonly number: CustomDbType<number>;
+    static readonly string: CustomDbType<string>;
+    static readonly boolean: CustomDbType<boolean>;
+    constructor(is: (this: CustomDbType<T>, value: any) => boolean, name: string);
+}
+type TypeMapDefined = {
+    [key: string]: Constructor | CustomDbType<any>;
+};
+type InferTypeMapDefined<T> = T extends Constructor<infer P> ? TRaw<P> : T extends CustomDbType<infer Q> ? Q : never;
+type TRaw<T> = T extends Number ? number : T extends BigInt ? bigint : T extends String ? string : T extends Boolean ? boolean : T;
+/** @public */
+export type TableDefined = {
+    [key: string]: ColumnMeta<any>;
+};
+/** @public */
+export type InferTableDefined<T extends TableDefined> = {
+    [key in keyof T]: T[key] extends ColumnMeta<infer P> ? P : unknown;
+};
+export {};
+//# sourceMappingURL=infer_db_type.d.ts.map

package/dist/your_table/mod.d.ts

@@ -0,0 +1,4 @@
+export * from "./checker.ts";
+export * from "./infer_db_type.ts";
+export * from "./table.ts";
+//# sourceMappingURL=mod.d.ts.map

package/dist/your_table/table.d.ts

@@ -0,0 +1,16 @@
+import { DbTableQuery } from "../select/TableQuery.ts";
+import type { TableType } from "../select/type.ts";
+import type { SqlValuesCreator } from "../sql_value/sql_value.ts";
+import type { ColumnMeta, TableDefined } from "./infer_db_type.ts";
+import { TypeChecker } from "./checker.ts";
+/**
+ * 完整数据库表数据
+ * @public
+ */
+export declare class YourTable<T extends TableType = TableType, C extends TableType = T> extends DbTableQuery<T, C> {
+    private define;
+    constructor(name: string, define: TableDefined, sqlValue: SqlValuesCreator);
+    getColumnMeta(name: keyof T): ColumnMeta<unknown>;
+    createTypeChecker<T>(keys: readonly string[]): TypeChecker<T>;
+}
+//# sourceMappingURL=table.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asla/yoursql",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "",
   "type": "module",
   "types": "./dist/mod.d.ts",
@@ -10,6 +10,7 @@
     "build": "pnpm rollup -c  build/rollup.config.js && pnpm run ci:check-api -l",
     "test": "vitest",
     "type:check": "tsc",
+    "publish-check": "deno publish --dry-run --allow-dirty",
     "ci:check-api": "api-extractor run -c api-extractor.jsonc -v"
   },
   "devDependencies": {