imodel 0.0.0 → 0.1.0

package/index.mjs

@@ -0,0 +1,5072 @@
+/*!
+ * imodel v0.1.0
+ * (c) 2019-2025 undefined
+ * @license undefined
+ */
+
+let isDevelopment = false;
+/**
+ *
+ * @param {boolean} [d]
+ */
+function setDevelopment(d) {
+  isDevelopment = Boolean(d);
+}
+
+const deleted = Symbol();
+const undeleted = Symbol();
+const withDeleted = Symbol();
+/** @typedef {typeof deleted} deleted  */
+/** @typedef {typeof undeleted} undeleted  */
+/** @typedef {typeof withDeleted} withDeleted  */
+/** @typedef {deleted | undeleted | withDeleted} FindRange */
+
+/** @import { FindRange } from './FindRange.mjs' */
+/** @import { TableDefine, Queryable } from './types' */
+/** @type {Set<FindRange | undefined>} */
+const virtualDeletionSet = new Set([undeleted, withDeleted]);
+/**
+ *
+ * @param {TableDefine} model
+ * @returns
+ */
+function canPseudo(model) {
+  if (!model.pseudo) {
+    return false;
+  }
+  if (!(model.pseudo in model.fields)) {
+    return false;
+  }
+  return true;
+}
+/**
+ *
+ * @param {Queryable} model
+ * @returns
+ */
+function isPseudo(model) {
+  if (!canPseudo(model)) {
+    return false;
+  }
+  return !virtualDeletionSet.has(model.options.range);
+}
+
+const now = Symbol();
+const increment$1 = Symbol();
+const decrement$1 = Symbol();
+const multiply$1 = Symbol();
+const divide$1 = Symbol();
+
+var values = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    decrement: decrement$1,
+    divide: divide$1,
+    increment: increment$1,
+    multiply: multiply$1,
+    now: now
+});
+
+/** @import { Fields, FieldType } from './types' */
+/**
+ *
+ * @param {Fields} fields
+ * @returns {Fields<keyof FieldType>}
+ */
+function toBaseFields(fields) {
+  /** @type {Fields<keyof FieldType>} */
+  const allFields = {};
+  for (const [k, v] of Object.entries(fields)) {
+    const {
+      type
+    } = v;
+    if (typeof type === 'string') {
+      // @ts-ignore
+      allFields[k] = v;
+      continue;
+    }
+    if (!type.table) {
+      allFields[k] = {
+        ...v,
+        type: 'object',
+        primary: false
+      };
+    }
+  }
+  return allFields;
+}
+
+/** @import { Options, Queryable } from '../types' */
+/**
+ *
+ * @param {Queryable} model
+ * @returns {Options}
+ */
+function getOptions(model) {
+  const options = {
+    ...model.options
+  };
+  if (!model.pseudo) {
+    return options;
+  }
+  if (!(model.pseudo in model.fields)) {
+    return options;
+  }
+  if (options.range === undeleted) {
+    options.where = [...options.where, {
+      field: model.pseudo,
+      operator: '<>',
+      value: 0
+    }];
+  } else if (options.range !== withDeleted) {
+    options.where = [...options.where, {
+      field: model.pseudo,
+      operator: '=',
+      value: 0
+    }];
+  }
+  return options;
+}
+
+/** @typedef {SetValue.Increment | SetValue.Decrement | SetValue.Multiply | SetValue.Divide | string | number | bigint | boolean | null | typeof now} SetValue */
+/** @typedef {{[values.increment]: number | bigint}} SetValue.Increment */
+/** @typedef {{[values.decrement]: number | bigint}} SetValue.Decrement */
+/** @typedef {{[values.multiply]: number | bigint}} SetValue.Multiply */
+/** @typedef {{[values.divide]: number | bigint}} SetValue.Divide */
+/**
+ * @param {number | bigint} value
+ * @returns {SetValue.Increment}
+ */
+function increment(value) {
+  return {
+    [increment$1]: value
+  };
+}
+/**
+ * @param {number | bigint} value
+ * @returns {SetValue.Decrement}
+ */
+function decrement(value) {
+  return {
+    [decrement$1]: value
+  };
+}
+/**
+ * @param {number | bigint} value
+ * @returns {SetValue.Multiply}
+ */
+function multiply(value) {
+  return {
+    [multiply$1]: value
+  };
+}
+/**
+ * @param {number | bigint} value
+ * @returns {SetValue.Divide}
+ */
+function divide(value) {
+  return {
+    [divide$1]: value
+  };
+}
+
+/** @import { SetValue } from '../../set.mjs' */
+/** @import { Fields } from '../../types' */
+/**
+ *
+ * @param {Fields} fields
+ * @param {Record<string, SetValue> | null | undefined} [update]
+ * @returns {Record<string, SetValue>}
+ */
+function getSetNewValue(fields, update) {
+  const data = {
+    ...update
+  };
+  for (const [name, field] of Object.entries(fields)) {
+    if (!field.primary && field.timestampUpdating) {
+      data[name] = now;
+    }
+  }
+  return Object.fromEntries(Object.entries(data).filter(([k, v]) => {
+    const field = k in fields && fields[k];
+    if (!field) {
+      return;
+    }
+    if (field.immutable || field.serial && field.type === 'id') {
+      return;
+    }
+    return true;
+  }));
+}
+
+/** @import { Fields } from '../../types' */
+/**
+ *
+ * @param {Record<string, any>} data
+ * @param {Fields} fields
+ * @returns {Record<string, any>}
+ */
+function getInsertValue(data, fields) {
+  const insertValue = {};
+  for (const [k, field] of Object.entries(fields)) {
+    if (field.timestampCreating) {
+      insertValue[k] = now;
+      continue;
+    }
+    const val = data[k];
+    if (val !== undefined) {
+      insertValue[k] = val;
+      continue;
+    }
+    const def = field.default;
+    if (def === undefined) {
+      continue;
+    }
+    if (typeof def === 'function') {
+      insertValue[k] = def(data);
+      continue;
+    }
+    insertValue[k] = def;
+  }
+  return insertValue;
+}
+
+/** @import { ColumnOptions } from '../../types' */
+/**
+ * @template {ColumnOptions} T
+ * @param {T} v
+ * @returns {T}
+ */
+function timestampDef(v) {
+  const isTime = v.timestampCreating || v.timestampUpdating;
+  if (!isTime) {
+    return v;
+  }
+  return {
+    ...v,
+    default: now
+  };
+}
+
+/** @import { FieldDefine, Fields, FieldType, TableDefine } from '../../types' */
+/**
+ *
+ * @param {Fields} fields
+ * @returns {[Fields<keyof FieldType>, [string, FieldDefine<TableDefine>][]]}
+ */
+function separateFields(fields) {
+  /** @type {Fields<keyof FieldType>} */
+  const base = Object.create(null);
+  /** @type {[string, FieldDefine<TableDefine>][]} */
+  const sub = [];
+  for (const [k, v] of Object.entries(fields)) {
+    const {
+      type
+    } = v;
+    if (typeof type === 'string') {
+      // @ts-ignore
+      base[k] = v;
+    } else if (!type.table) {
+      base[k] = {
+        ...v,
+        type: 'object',
+        primary: false
+      };
+    } else {
+      // @ts-ignore
+      sub.push([k, v]);
+    }
+  }
+  return [base, sub];
+}
+
+/**
+ *
+ * @param {*} item
+ * @param {[string, string][]} mapList
+ * @returns
+ */
+function createFilter(item, mapList) {
+  /** @type {[string, any][]} */
+  const values = mapList.map(([k, v]) => [k, item[v]]);
+  return sub => {
+    for (const [k, v] of values) {
+      if (sub[k] !== v) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+
+/** @import { Environment, FieldDefine, Fields, GetName, IConnection, TableDefine } from '../types' */
+/**
+ *
+ * @param {any} p
+ * @param {Fields} fields
+ * @returns
+ */
+function getOtherValues(p, fields) {
+  const s = {};
+  for (const k of Reflect.ownKeys(p)) {
+    if (k in fields) {
+      continue;
+    }
+    s[k] = p[k];
+  }
+  return s;
+}
+/**
+ *
+ * @param {any} value
+ * @param {any} others
+ * @returns
+ */
+function defaultMap(value, others) {
+  return {
+    ...value,
+    ...others
+  };
+}
+/**
+ *
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {Environment} env
+ * @param {[string, FieldDefine<TableDefine>][]} fields
+ * @param {Record<string, any>[]} newList
+ * @param {Record<string, any>[]} list
+ * @returns {Promise<Record<string, any>[]>}
+ */
+async function createSub(conn, getName, env, fields, newList, list) {
+  // TODO: 可创建字段过滤
+  if (!list.length) {
+    return list;
+  }
+  /** @type {[Record<string, any>, Record<string, any>][]} */
+  const allList = list.map((v, i) => [v, newList[i]]);
+  /** @type {PromiseLike<any>[]} */
+  const promises = [];
+  for (const [key, {
+    type,
+    array,
+    constraints
+  }] of fields) {
+    const {
+      fields
+    } = type;
+    const constraintEntries = Object.entries(constraints || {});
+    const noField = constraintEntries.find(([k, v]) => v.noField)?.[0];
+    /** @type {Record<string, any>} */
+    const commonValue = {};
+    /** @type {[string, string][]} */
+    const commonKeys = [];
+    for (const [k, {
+      field,
+      value: val
+    }] of constraintEntries) {
+      if (field) {
+        commonKeys.push([k, field]);
+      } else if (val !== undefined) {
+        commonValue[k] = val;
+      }
+    }
+    /** @type {Record<string, any>[][]} */
+    const allFieldValues = [];
+    for (const [main, records] of allList) {
+      const record = records?.[key];
+      // eslint-disable-next-line no-nested-ternary
+      const newList = Array.isArray(record) ? array ? record : [record[0]] : [record];
+      const values = newList.filter(v => v && typeof v === 'object');
+      if (!values.length) {
+        continue;
+      }
+      const commonValues = {
+        ...Object.fromEntries(commonKeys.map(([k, v]) => [k, main[v]])),
+        ...commonValue
+      };
+      const list = values.map(value => ({
+        ...value,
+        ...commonValues
+      }));
+      allFieldValues.push(noField ? list.map((v, i) => ({
+        ...v,
+        [noField]: i + 1
+      })) : list);
+    }
+    /** @type {Record<string, any>[]} */
+    const fieldValues = allFieldValues.flat();
+    if (!fieldValues.length) {
+      if (array) {
+        for (const [value] of allList) {
+          value[key] = [];
+        }
+        continue;
+      }
+      for (const [value] of allList) {
+        value[key] = null;
+      }
+      continue;
+    }
+    const [baseFields, tableFields] = separateFields(fields);
+    const insertKeys = Object.entries(baseFields).filter(([, o]) => !o.serial || o.type !== 'id').map(v => v[0]);
+    const insertValues = fieldValues.map(d => getInsertValue(d, fields));
+    const {
+      table
+    } = type;
+    const result = table && typeof table === 'object' ? table.insert(env, conn, '', baseFields, insertValues, insertKeys) : conn.insert(env, getName(table), baseFields, insertValues, insertKeys);
+    promises.push(result.then(r => createSub(conn, getName, env, tableFields, fieldValues, r)));
+    promises.push(array ? result.then(values => {
+      for (const [value] of allList) {
+        value[key] = values.filter(createFilter(value, commonKeys));
+      }
+    }) : result.then(values => {
+      for (const [value] of allList) {
+        value[key] = values.find(createFilter(value, commonKeys)) || null;
+      }
+    }));
+  }
+  return Promise.all(promises).then(() => list);
+}
+// TODO: 嵌套
+/**
+ *
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {Environment} env
+ * @param {TableDefine} model
+ * @param {any} p
+ * @param {(a,b) => object} mapDo
+ * @returns {Promise<any>}
+ */
+async function create(conn, getName, env, model, p, mapDo = defaultMap) {
+  const {
+    table,
+    fields
+  } = model;
+  const isArray = Array.isArray(p);
+  const param = Object.create(null);
+  /** @type {any[]} */
+  const records = [];
+  for (const item of isArray ? p : [p]) {
+    const data = {
+      ...param
+    };
+    for (let k of Object.getOwnPropertyNames(item)) {
+      if (k in data) {
+        continue;
+      }
+      data[k] = item[k];
+    }
+    records.push(data);
+  }
+  const [baseFields, tableFields] = separateFields(fields);
+  const insertValues = records.map(d => getInsertValue(d, baseFields));
+  let insertKeys = [];
+  if (!insertKeys.length && !isArray) {
+    insertKeys = Object.entries(insertValues[0]).filter(([k, v]) => v !== undefined && k in baseFields).map(([k]) => k);
+  }
+  if (!insertKeys.length) {
+    insertKeys = Object.entries(baseFields).filter(([, o]) => !o.serial || o.type !== 'id').map(([k]) => k);
+  }
+  const list = table && typeof table === 'object' ? await table.insert(env, conn, '', baseFields, insertValues, insertKeys) : await conn.insert(env, getName(table), baseFields, insertValues, insertKeys);
+  await createSub(conn, getName, env, tableFields, records, list);
+  const value = list.map((v, i) => mapDo(v, getOtherValues(records[i], fields)));
+  return isArray ? value : value[0];
+}
+
+/** @import { Fields } from './types' */
+/**
+ *
+ * @param {Fields} fields
+ * @returns {string[]}
+ */
+function getPrimaryKeys(fields) {
+  const list = Object.entries(fields);
+  const primaryKeys = list.filter(([v, o]) => typeof o.type === 'string' && o.primary);
+  if (primaryKeys.length) {
+    return primaryKeys.map(([k]) => k);
+  }
+  const idKeys = list.filter(([v, o]) => o.serial && o.type === 'id');
+  if (idKeys.length) {
+    return idKeys.map(([k]) => k);
+  }
+  return [list[0][0]];
+}
+
+/** @import { Constraint, Fields, FieldType } from '../../types' */
+/**
+ * @param {Fields<keyof FieldType>} fields
+ * @param {Fields<keyof FieldType>} parentFields
+ * @param {Record<string, string | Constraint> | undefined} constraints
+ * @returns {[string, string][]?}
+ */
+function getMapList(fields, parentFields, constraints) {
+  if (!constraints) {
+    return null;
+  }
+  /** @type {[string, string][]} */
+  const where = [];
+  for (const [k, v] of Object.entries(constraints)) {
+    if (!(k in fields)) {
+      continue;
+    }
+    const field = typeof v === 'string' ? v : v.field;
+    if (typeof field !== 'string') {
+      continue;
+    }
+    if (!(field in parentFields)) {
+      continue;
+    }
+    where.push([k, field]);
+  }
+  if (!where.length) {
+    return null;
+  }
+  return where;
+}
+
+/** @import { Constraint, Fields, FieldType } from '../../types' */
+/**
+ *
+ * @param {Record<string, Constraint> | undefined} value
+ * @param {Fields<keyof FieldType>} fields
+ * @returns {[string, unknown][]}
+ */
+function getValueEntries(value, fields) {
+  if (!value) {
+    return [];
+  }
+  /** @type {[string, unknown][]} */
+  const where = [];
+  for (const [k, v] of Object.entries(value)) {
+    if (!(k in fields)) {
+      continue;
+    }
+    if (!v || typeof v !== 'object') {
+      continue;
+    }
+    const {
+      value
+    } = v;
+    if (value === undefined) {
+      continue;
+    }
+    where.push([k, value]);
+  }
+  return where;
+}
+
+/** @import { WhereValue } from '../../Where.mjs' */
+/**
+ *
+ * @param {Record<string, string>[]} list
+ * @param {[string, string][]} map
+ * @returns {WhereValue}
+ */
+function subList2where(list, map) {
+  const valueKeys = map.map(([, v]) => v);
+  return {
+    field: map.map(([k]) => k),
+    value: list.map(d => valueKeys.map(v => d[v]))
+  };
+}
+
+/** @import { WhereValue } from '../../Where.mjs' */
+/**
+ *
+ * @param {[string, unknown][]} value
+ * @returns {WhereValue[]}
+ */
+function valueEntries2where(value) {
+  return value.map(([k, v]) => ({
+    field: k,
+    operator: '=',
+    value: v
+  }));
+}
+
+/** @import { Environment, FieldDefine, Fields, FieldType, GetName, IConnection, MatchArg, Queryable, TableDefine } from '../types' */
+/**
+ *
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {any[]} list
+ * @param {[string, FieldDefine<TableDefine>][]} fields
+ * @param {Fields<keyof FieldType>} baseFields
+ * @param {Environment} env
+ * @param {boolean} [hasResult]
+ * @returns
+ */
+async function deleteSub(conn, getName, list, fields, baseFields, env, hasResult) {
+  if (!list.length) {
+    return list;
+  }
+  /** @type {any[]} */
+  const promises = [];
+  for (const [key, {
+    type,
+    array,
+    constraints
+  }] of fields) {
+    const constraintEntries = Object.entries(constraints || {});
+    const {
+      fields
+    } = type;
+    const [subfields, tableFields] = separateFields(fields);
+    const mapList = getMapList(subfields, baseFields, constraints);
+    if (!mapList) {
+      continue;
+    }
+    const value = getValueEntries(constraints, subfields);
+    const where = [subList2where(list, mapList), ...valueEntries2where(value)];
+    const {
+      table
+    } = type;
+    /** @type {MatchArg} */
+    const argv = {
+      table: typeof table === 'string' ? getName(table) : '',
+      fields: subfields,
+      where
+    };
+    if (!tableFields.length && !hasResult) {
+      const result = table && typeof table === 'object' ? table.delete(env, conn, argv) : conn.delete(env, argv);
+      promises.push(result);
+      continue;
+    }
+    const result = table && typeof table === 'object' ? table.deleteReturn(env, conn, argv, Object.keys(subfields)) : conn.deleteReturn(env, argv, Object.keys(subfields));
+    promises.push(result.then(l => deleteSub(conn, getName, l, tableFields, subfields, env, hasResult)));
+    constraintEntries.find(([k, v]) => v.noField)?.[0];
+    promises.push(array ? result.then(subList => {
+      for (const item of list) {
+        // TODO: 排序
+        item[key] = subList.filter(createFilter(item, mapList));
+      }
+    }) : result.then(subList => {
+      for (const item of list) {
+        item[key] = subList.find(createFilter(item, mapList)) || null;
+      }
+    }));
+  }
+  await Promise.all(promises);
+  return list;
+}
+// TODO: 嵌套
+/**
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {Queryable} queryable
+ * @param {Environment} env
+ * @returns {Promise<number>}
+ */
+async function deleteMany(conn, getName, queryable, env) {
+  const {
+    table,
+    fields
+  } = queryable;
+  const {
+    where
+  } = queryable.options;
+  const [baseFields, tableFields] = separateFields(fields);
+  if (!tableFields.length) {
+    return table && typeof table === 'object' ? table.delete(env, conn, {
+      table: '',
+      fields: baseFields,
+      where
+    }) : conn.delete(env, {
+      table: getName(table),
+      fields: baseFields,
+      where
+    });
+  }
+  const list = table && typeof table === 'object' ? await table.deleteReturn(env, conn, {
+    table: '',
+    fields: baseFields,
+    where
+  }, Object.keys(baseFields)) : await conn.deleteReturn(env, {
+    table: getName(table),
+    fields: baseFields,
+    where
+  }, Object.keys(baseFields));
+  if (!list) {
+    return 0;
+  }
+  await deleteSub(conn, getName, list, tableFields, baseFields, env);
+  return list.length;
+}
+
+/* eslint-disable no-labels */
+/** @import { Constraint, Environment, FieldDefine, GetName, IConnection, TableDefine } from '../types' */
+/** @import { WhereValue } from '../Where.mjs' */
+/**
+ *
+ * @param {Record<string, any>[]} newList
+ * @param {Record<string, any>[]} oldList
+ * @param {Iterable<string>} keys
+ * @param {Record<string, any>[]} notFound
+ * @param {Record<string, any>[]} found
+ */
+function classify(newList, oldList, keys, notFound, found) {
+  newValue: for (const n of newList) {
+    oldValue: for (let i = 0; i < oldList.length; i++) {
+      const old = oldList[i];
+      for (const k of keys) {
+        if (n[k] === undefined) {
+          continue;
+        }
+        if (old[k] !== n[k]) {
+          continue oldValue;
+        }
+      }
+      oldList.splice(i, 1);
+      found.push([n, old]);
+      continue newValue;
+    }
+    notFound.push(n);
+  }
+}
+/**
+ *
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {Environment} env
+ * @param {[Record<string, any>, Record<string, any>, Record<string, any>][]} updatedOldNewList
+ * @param {string} key
+ * @param {TableDefine} type
+ * @param {boolean} array
+ * @param {Record<string, Constraint>?} [constraints]
+ * @returns
+ */
+async function updateItem(conn, getName, env, updatedOldNewList, key, type, array, constraints) {
+  /** @type {any[]} */
+  const promises = [];
+  const constraintEntries = Object.entries(constraints || {});
+  const noField = constraintEntries.find(([k, v]) => v.noField)?.[0];
+  /** @type {Record<string, any>} */
+  const commonValue = {};
+  /** @type {[string, string][]} */
+  const commonMapKeys = [];
+  for (const [k, {
+    field,
+    value: val
+  }] of constraintEntries) {
+    if (field) {
+      commonMapKeys.push([k, field]);
+    } else if (val !== undefined) {
+      commonValue[k] = val;
+    }
+  }
+  /** @type {Record<string, any>[][]} */
+  const oldListValues = [];
+  /** @type {Record<string, any>[][]} */
+  const newListValues = [];
+  let has = false;
+  for (const [main, oldData, newData] of updatedOldNewList) {
+    const oldRecords = oldData?.[key];
+    const newRecords = newData?.[key];
+    // eslint-disable-next-line no-nested-ternary
+    const oldList = Array.isArray(oldRecords) ? array ? oldRecords : [oldRecords[0]] : [oldRecords];
+    if (newRecords || !array && newRecords === null) {
+      has = true;
+    }
+    // eslint-disable-next-line no-nested-ternary
+    const newList = Array.isArray(newRecords) ? array ? newRecords : [newRecords[0]] : [newRecords];
+    const oldValues = oldList.filter(v => v && typeof v === 'object');
+    const newValues = newList.filter(v => v && typeof v === 'object');
+    if (!oldValues.length && !newValues.values) {
+      continue;
+    }
+    const commonValues = {
+      ...Object.fromEntries(commonMapKeys.map(([k, v]) => [k, main[v]])),
+      ...commonValue
+    };
+    if (oldValues) {
+      const list = oldValues.map(value => ({
+        ...value,
+        ...commonValues
+      }));
+      oldListValues.push(noField ? list.map((v, i) => ({
+        ...v,
+        [noField]: i + 1
+      })) : list);
+    }
+    if (newValues) {
+      const list = newValues.map(value => ({
+        ...value,
+        ...commonValues
+      }));
+      newListValues.push(noField ? list.map((v, i) => ({
+        ...v,
+        [noField]: i + 1
+      })) : list);
+    }
+  }
+  if (!has) {
+    return;
+  }
+  const oldList = oldListValues.flat();
+  const newList = newListValues.flat();
+  const {
+    fields
+  } = type;
+  /** @type {Record<string, any>} */
+  const commonKeys = {};
+  for (const [k, v] of Object.entries(constraints || {})) {
+    const {
+      field,
+      value
+    } = v;
+    if (field || value !== undefined) {
+      commonKeys[k] = 1;
+    }
+  }
+  const [baseFields, tableFields] = separateFields(fields);
+  const primaryKeys = getPrimaryKeys(baseFields);
+  // 分离出新建、修改、删除
+  // TODO: 优化分离逻辑
+  const needDelete = oldList;
+  /** @type {[Record<string, any>, Record<string, any>][]} */
+  const eq = [];
+  /** @type {Record<string, any>[]} */
+  const needCreate = [];
+  /** @type {[Record<string, any>, Record<string, any>][]} */
+  const needUpdate = [];
+  /** @type {Record<string, any>[]} */
+  const unmatched = [];
+  const aKeys = Object.keys(baseFields).filter(v => !(v in commonKeys));
+  classify(newList, needDelete, aKeys, unmatched, eq);
+  const pKeys = primaryKeys.filter(v => !(v in commonKeys));
+  classify(unmatched, needDelete, pKeys, needCreate, needUpdate);
+  const tTable = type.table;
+  const table = tTable && typeof tTable === 'object' ? tTable : getName(tTable);
+  if (needDelete.length) {
+    // 批量删除
+    /** @type {WhereValue[]} */
+    const where = primaryKeys.filter(v => v in commonKeys).map(k => ({
+      field: k,
+      operator: '=',
+      value: commonKeys[k] ?? null
+    }));
+    if (pKeys.length === 1) {
+      const [key] = pKeys;
+      where.push({
+        field: key,
+        operator: 'in',
+        value: needDelete.map(v => v[key] ?? null)
+      });
+    } else if (pKeys.length) {
+      where.push({
+        field: pKeys,
+        operator: 'in',
+        value: needDelete.map(v => pKeys.map(k => v[k] ?? null))
+      });
+    }
+    const promise = typeof table === 'string' ? conn.deleteReturn(env, {
+      table,
+      fields: baseFields,
+      where
+    }, Object.keys(baseFields)) : table.deleteReturn(env, conn, {
+      table: '',
+      fields: baseFields,
+      where
+    }, Object.keys(baseFields));
+    promises.push(promise.then(list => deleteSub(conn, getName, list, tableFields, baseFields, env)));
+  }
+  /** @type {typeof updatedOldNewList} */
+  const list = eq.map(([n, o]) => [{
+    ...n
+  }, o, n]);
+  /** @type {any[]} */
+  const listPromises = [list.map(v => v[0])];
+  /** @type {(typeof updatedOldNewList | PromiseLike<typeof updatedOldNewList>)[]} */
+  const subPromises = [list];
+  // 批量修改
+  if (needUpdate.length) {
+    const keys = new Set(needUpdate.map(v => Object.keys(v[0])).flat());
+    const update = getSetNewValue(baseFields);
+    for (const k of Object.keys(update)) {
+      keys.delete(k);
+    }
+    const setKeys = Object.entries(baseFields).filter(([, v]) => typeof v.type === 'string' && !v.primary && !v.immutable).map(v => v[0]).filter(v => keys.has(v));
+    /** @type {WhereValue[]} */
+    const where = Object.entries(commonKeys).filter(([k]) => primaryKeys.includes(k)).map(([k, v]) => ({
+      field: k,
+      operator: '=',
+      value: v
+    }));
+    for (const [value, old] of needUpdate) {
+      for (const key of setKeys) {
+        if (value[key] !== undefined) {
+          continue;
+        }
+        value[key] = old[key];
+      }
+    }
+    const list = typeof table === 'string' ? conn.updateManyReturn(env, table, baseFields, update, pKeys, setKeys, needUpdate.map(v => v[0]), where, Object.keys(baseFields)) : table.updateManyReturn(env, conn, '', baseFields, update, pKeys, setKeys, needUpdate.map(v => v[0]), where, Object.keys(baseFields));
+    listPromises.push(list);
+    subPromises.push(list.then(u => u.map((u, i) => [u, ...needUpdate[i]])));
+  }
+  // 批量新建
+  if (needCreate.length) {
+    const key = Object.entries(baseFields);
+    const list = typeof table === 'string' ? conn.insert(env, table, baseFields, needCreate.map(d => getInsertValue(d, baseFields)), key.filter(([, o]) => !o.serial || o.type !== 'id').map(v => v[0])) : table.insert(env, conn, '', baseFields, needCreate.map(d => getInsertValue(d, baseFields)), key.filter(([, o]) => !o.serial || o.type !== 'id').map(v => v[0]));
+    listPromises.push(list);
+    promises.push(list.then(list => createSub(conn, getName, env, tableFields, needCreate, list)));
+  }
+  promises.push(Promise.all(subPromises).then(
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  v => updateSub(conn, getName, tableFields, v.flat(), env)));
+  const allList = Promise.all(listPromises).then(v => v.flat());
+  promises.push(array ? allList.then(async values => {
+    for (const [value] of updatedOldNewList) {
+      let data = values.filter(createFilter(value, commonMapKeys));
+      if (noField) {
+        data = data.sort(({
+          [noField]: a
+        }, {
+          [noField]: b
+        }) => a - b);
+      }
+      value[key] = data;
+    }
+  }) : allList.then(async values => {
+    for (const [value] of updatedOldNewList) {
+      value[key] = values.find(createFilter(value, commonMapKeys)) || null;
+    }
+  }));
+  await Promise.all(promises);
+}
+/**
+ *
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {[string, FieldDefine<TableDefine>][]} fields
+ * @param {[Record<string, any>, Record<string, any>, Record<string, any>][]} list
+ * @param {Environment} env
+ * @returns
+ */
+async function updateSub(conn, getName, fields, list, env) {
+  if (!list.length) {
+    return;
+  }
+  /** @type {any[]} */
+  const promises = [];
+  for (const [key, {
+    type,
+    array,
+    immutable,
+    constraints
+  }] of fields) {
+    if (immutable) {
+      continue;
+    }
+    promises.push(updateItem(conn, getName, env, list, key, type, array, constraints));
+  }
+  await Promise.all(promises);
+}
+/**
+ *
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {TableDefine} model
+ * @param {Record<string, any>} data
+ * @param {Record<string, any>} newData
+ * @param {Environment} env
+ * @returns
+ */
+async function updateData (conn, getName, model, data, newData, env) {
+  const keys = Object.keys(newData);
+  if (!keys.length) {
+    return false;
+  }
+  const {
+    table,
+    fields
+  } = model;
+  const savedData = data;
+  const has = keys.filter(v => v in fields && (typeof fields[v]?.type === 'string' || !fields[v]?.type.table)).length;
+  /** @type {WhereValue[]} */
+  const where = getPrimaryKeys(fields).map(k => ({
+    field: k,
+    operator: '=',
+    value: savedData[k]
+  }));
+  const [baseFields, tableFields] = separateFields(fields);
+  let list = [];
+  if (!has) {
+    list = [data];
+  } else if (table && typeof table === 'object') {
+    list = await table.updateReturn(env, conn, {
+      table: '',
+      fields: baseFields,
+      where
+    }, getSetNewValue(fields, newData), Object.keys(baseFields));
+  } else {
+    list = await conn.updateReturn(env, {
+      table: getName(table),
+      fields: baseFields,
+      where
+    }, getSetNewValue(fields, newData), Object.keys(baseFields));
+  }
+  const oldList = [data];
+  const newList = [newData];
+  /** @type {[Record<string, any>, Record<string, any>, Record<string, any>][]} */
+  const updatedOldNewList = list.map((v, k) => [v, oldList[k], newList[k]]);
+  await updateSub(conn, getName, tableFields, updatedOldNewList, env);
+  return list[0];
+}
+
+/** @import { SetValue } from '../../set.mjs' */
+/** @import { Fields } from '../../types' */
+/**
+ *
+ * @param {Fields} fields
+ * @param {Record<string, SetValue>} update
+ * @returns
+ */
+function setDeleteTimestamp(fields, update) {
+  for (const [name, field] of Object.entries(fields)) {
+    if (!field.primary && field.timestampDeleting) {
+      update[name] = now;
+    }
+  }
+  return update;
+}
+
+/** @import { WhereValue } from '../Where.mjs' */
+/** @import { SetValue } from '../set.mjs' */
+/** @import { Environment, IConnection, GetName, TableDefine } from '../types' */
+/**
+ *
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {TableDefine} tableDef
+ * @param {any} data
+ * @param {Record<string, SetValue>} update
+ * @param {Environment} env
+ * @returns
+ */
+async function pseudoDestroy (conn, getName, tableDef, data, update, env) {
+  const {
+    table,
+    fields
+  } = tableDef;
+  const baseFields = toBaseFields(fields);
+  /** @type {WhereValue[]} */
+  const where = getPrimaryKeys(fields).map(k => ({
+    field: k,
+    operator: '=',
+    value: data[k]
+  }));
+  const pseudo = tableDef.pseudo || '';
+  where.push({
+    field: pseudo,
+    operator: '=',
+    value: 0
+  });
+  const value = {
+    ...update
+  };
+  const pseudoValue = Number(new Date());
+  value[pseudo] = pseudoValue;
+  setDeleteTimestamp(fields, value);
+  const [dataUpdated] = table && typeof table === 'object' ? await table.updateReturn(env, conn, {
+    table: '',
+    fields: baseFields,
+    where
+  }, value, Object.keys(baseFields)) : await conn.updateReturn(env, {
+    table: getName(table),
+    fields: baseFields,
+    where
+  }, value, Object.keys(baseFields));
+  if (!dataUpdated) {
+    return null;
+  }
+  return dataUpdated;
+}
+
+/** @import { WhereValue } from '../Where.mjs' */
+/** @import { IConnection, TableDefine, Environment, GetName } from '../types' */
+/**
+ *
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {TableDefine} tableDef
+ * @param {any} data
+ * @param {Environment} env
+ * @returns
+ */
+async function completelyDelete (conn, getName, tableDef, data, env) {
+  const {
+    table,
+    fields
+  } = tableDef;
+  const [baseFields, tableFields] = separateFields(fields);
+  /** @type {WhereValue[]} */
+  const where = getPrimaryKeys(fields).map(k => ({
+    field: k,
+    operator: '=',
+    value: data[k]
+  }));
+  const list = table && typeof table === 'object' ? await table.deleteReturn(env, conn, {
+    table: '',
+    fields: baseFields,
+    where
+  }, Object.keys(baseFields)) : await conn.deleteReturn(env, {
+    table: getName(table),
+    fields: baseFields,
+    where
+  }, Object.keys(baseFields));
+  const [deleted] = await deleteSub(conn, getName, list, tableFields, baseFields, env, true);
+  return deleted || null;
+}
+
+const Destroy = Symbol();
+const PseudoDestroy = Symbol();
+const Save = Symbol();
+const Create = Symbol();
+const Build = Symbol();
+
+/** @import { Fields, FieldType, Select } from '../types' */
+/**
+ * @param {Fields<keyof FieldType>} fields
+ * @param {Record<string, Select>?} [select]
+ * @returns {[string, Select][]}
+ */
+function toSelect(fields, select) {
+  const list = select ? Object.entries(select) : [];
+  return list.length ? list : Object.keys(fields).map(k => [k, {
+    field: k
+  }]);
+}
+
+/** @import { Fields, FieldType } from '../../types' */
+/**
+ *
+ * @param {Fields<keyof FieldType>} fields
+ * @param {string} [noField]
+ * @returns {[string, boolean][]}
+ */
+function getDefaultSort(fields, noField) {
+  /** @type {[string, boolean, number][]} */
+  const sorted = Object.entries(fields).map(([f, d]) => [f, (d.sort || 0) < 0, Math.abs(d.sort || 0)]);
+  /** @type {[string, boolean][]} */
+  const sort = sorted.filter(v => v[2]).sort(([,, a], [,, b]) => a - b).map(([a, b]) => [a, b]);
+  if (noField) {
+    sort.unshift([noField, false]);
+  }
+  return sort;
+}
+
+/** @import { Environment, FieldDefine, Fields, FieldType, GetName, IConnection, TableDefine } from '../types' */
+/**
+ *
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {any[]} list
+ * @param {[string, FieldDefine<TableDefine>][]} fields
+ * @param {Fields<keyof FieldType>} baseFields
+ * @param {Environment} env
+ * @returns {Promise<any[]>}
+ */
+async function findSub(conn, getName, list, fields, baseFields, env) {
+  if (!list.length) {
+    return list;
+  }
+  /** @type {PromiseLike<any>[]} */
+  const promises = [];
+  for (const [key, {
+    type,
+    array,
+    constraints
+  }] of fields) {
+    const constraintEntries = Object.entries(constraints || {});
+    const noField = constraintEntries.find(([k, v]) => v.noField)?.[0];
+    const {
+      fields
+    } = type;
+    const [subfields, tableFields] = separateFields(fields);
+    const mapList = getMapList(subfields, baseFields, constraints);
+    if (!mapList) {
+      continue;
+    }
+    const value = getValueEntries(constraints, subfields);
+    const where = [subList2where(list, mapList), ...valueEntries2where(value)];
+    const {
+      table
+    } = type;
+    /** @type {PromiseLike<object[] | object>} */
+    const result = table && typeof table === 'object' ? table.select(env, conn, {
+      table: '',
+      fields: subfields,
+      where,
+      sort: getDefaultSort(subfields, noField),
+      select: toSelect(subfields)
+    }) : conn.select(env, {
+      table: getName(table),
+      fields: subfields,
+      where,
+      sort: getDefaultSort(subfields, noField),
+      select: toSelect(subfields)
+    });
+    promises.push(result.then(list => findSub(conn, getName, list, tableFields, subfields, env)));
+    promises.push(array ? result.then(subList => {
+      for (const item of list) {
+        item[key] = subList.filter(createFilter(item, mapList));
+      }
+    }) : result.then(subList => {
+      for (const item of list) {
+        item[key] = subList.find(createFilter(item, mapList)) || null;
+      }
+    }));
+  }
+  return Promise.all(promises).then(() => list);
+}
+/**
+ *
+ * @template {TableDefine} T
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {T} p
+ * @param {Environment} env
+ * @returns {Promise<any>}
+ */
+async function find(conn, getName, p, env) {
+  const {
+    table,
+    fields
+  } = p;
+  // @ts-ignore
+  const {
+    where,
+    sort,
+    offset,
+    limit,
+    alias
+  } = getOptions(p);
+  const [baseFields, tableFields] = separateFields(fields);
+  const list = table && typeof table === 'object' ? await table.select(env, conn, {
+    table: '',
+    fields: baseFields,
+    alias,
+    where,
+    offset,
+    limit,
+    sort: sort?.length ? sort : getDefaultSort(baseFields),
+    select: toSelect(baseFields)
+  }) : await conn.select(env, {
+    table: getName(table),
+    fields: baseFields,
+    alias,
+    where,
+    offset,
+    limit,
+    sort: sort?.length ? sort : getDefaultSort(baseFields),
+    select: toSelect(baseFields)
+  });
+  if (!list.length) {
+    return [];
+  }
+  await findSub(conn, getName, list, tableFields, baseFields, env);
+  if (typeof p[Build] !== 'function') {
+    return list;
+  }
+  /** @type {(data: any, saved: boolean, env: any) => any} */
+  const R = p[Build].bind(p);
+  return list.map(it => R(it, true, env));
+}
+
+/** @import { Environment, TableDefine, IConnection, GetName } from '../types' */
+/**
+ *
+ * @template {TableDefine} T
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {T} p
+ * @param {Environment} env
+ * @returns {Promise<any>}
+ */
+async function first(conn, getName, p, env) {
+  const {
+    table,
+    fields
+  } = p;
+  // @ts-ignore
+  const {
+    where,
+    sort,
+    alias
+  } = getOptions(p);
+  const [baseFields, tableFields] = separateFields(fields);
+  const list = table && typeof table === 'object' ? await table.select(env, conn, {
+    table: '',
+    fields: baseFields,
+    alias,
+    where,
+    limit: 1,
+    sort: sort?.length ? sort : getDefaultSort(baseFields),
+    select: toSelect(baseFields)
+  }) : await conn.select(env, {
+    table: getName(table),
+    fields: baseFields,
+    alias,
+    where,
+    limit: 1,
+    sort: sort?.length ? sort : getDefaultSort(baseFields),
+    select: toSelect(baseFields)
+  });
+  const [item] = await findSub(conn, getName, list, tableFields, baseFields, env);
+  if (!item) {
+    return null;
+  }
+  if (typeof p[Build] !== 'function') {
+    return item;
+  }
+  return p[Build](item, true, env);
+}
+
+/** @import { Environment, GetName, IConnection, Queryable } from '../types' */
+/**
+ * @param {IConnection} conn
+ * @param {GetName} getName
+ * @param {Queryable} queryable
+ * @param {Record<string, any> | boolean | undefined} update
+ * @param {Environment} env
+ */
+async function pseudoDeleteMany(conn, getName, queryable, update, env) {
+  const {
+    table,
+    fields
+  } = queryable;
+  const {
+    where
+  } = getOptions(queryable);
+  const value = typeof update !== 'object' ? {} : {
+    ...update
+  };
+  const pseudoValue = Number(new Date());
+  const pseudo = queryable.pseudo || '';
+  value[pseudo] = pseudoValue;
+  setDeleteTimestamp(fields, value);
+  const baseFields = toBaseFields(fields);
+  const list = table && typeof table === 'object' ? await table.updateReturn(env, conn, {
+    table: '',
+    fields: baseFields,
+    where
+  }, value, Object.keys(baseFields)) : await conn.updateReturn(env, {
+    table: getName(table),
+    fields: baseFields,
+    where
+  }, value, Object.keys(baseFields));
+  return list.length;
+}
+
+/* eslint-disable max-lines */
+/* eslint-disable max-len */
+/** @import { WhereValue } from '../Where.mjs' */
+/** @import { SetValue } from '../set.mjs' */
+/** @import { Environment, IConnection } from '../types' */
+/** @import { Fields, FieldType, FieldValue, IndexOptions, MainFieldType, TableDefine } from '../types/table' */
+/** @import { Queryable } from '../types/options' */
+/** @import { Column, ColumnOptions } from '../types/column' */
+/** @import { GetName, TableType } from '../types/connection' */
+/**
+ *
+ * @param {Record<string, any> | null | undefined} update
+ * @param {Fields} fields
+ * @param {boolean} [skip]
+ * @returns {Record<string, SetValue>}
+ */
+function getSetValue$1(update, fields, skip) {
+  /** @type {Record<string, SetValue>} */
+  const data = {
+    ...update
+  };
+  for (const [name, field] of Object.entries(fields)) {
+    if (!field.primary && field.timestampUpdating) {
+      data[name] = now;
+    }
+  }
+  return Object.fromEntries(Object.entries(data).filter(([k, v]) => {
+    const field = k in fields && fields[k];
+    if (!field) {
+      return;
+    }
+    if (!skip && field.immutable || field.serial && field.type === 'id') {
+      return;
+    }
+    return true;
+  }));
+}
+/**
+ *
+ * @param {Fields<keyof FieldType>} fields
+ * @param {Record<string, any>} update
+ * @param {string[]} pKeys
+ * @param {string[]} setKeys
+ * @returns {[string[], string[]]}
+ */
+function getKeys(fields, update, pKeys, setKeys) {
+  const allFields = Object.keys(fields);
+  const mainKeys = new Set(pKeys);
+  const whereFields = allFields.filter(f => mainKeys.has(f));
+  const updateFields = Object.keys(update);
+  const noSetFields = new Set([...whereFields, ...updateFields]);
+  const setKeySet = new Set(setKeys);
+  const setFields = allFields.filter(f => setKeySet.has(f) && !noSetFields.has(f));
+  return [whereFields, setFields];
+}
+/**
+ *
+ * @param {AbortSignal} signal
+ * @returns
+ */
+function signal2promise(signal) {
+  return new Promise((_, r) => {
+    if (signal.aborted) {
+      r(signal.reason);
+      return;
+    }
+    signal.addEventListener('abort', () => r(signal.reason), {
+      once: true
+    });
+  });
+}
+/** @type {GetName} */
+const defGetName = s => s || '';
+/**
+ * @template {{}} [E={}]
+ */
+class Connection {
+  /** @type {Environment<E>} */
+  #env;
+  /** @type {() => Promise<IConnection<E>>} */
+  #getConnection;
+  /** @type {E?} */
+  #baseTransaction;
+  /** @type {Record<string, string>?} */
+  #names;
+  #getName = defGetName;
+  /**
+   *
+   * @param {PromiseLike<IConnection<E>> | IConnection<E>} connection
+   * @param {E?} [transaction]
+   * @param {Record<string, string>?} [names]
+   */
+  constructor(connection, transaction = null, names = null) {
+    this.#baseTransaction = transaction;
+    this.#getConnection = async () => connection;
+    let getName = defGetName;
+    if (names) {
+      this.#names = names;
+      const allNames = Object.assign(Object.create(null), names);
+      getName = n => allNames[n || ''] || n;
+    } else {
+      this.#names = null;
+    }
+    this.#getName = getName;
+    this.#env = {
+      isDevelopment,
+      values,
+      transaction,
+      getName,
+      names: names && {
+        ...names
+      }
+    };
+  }
+  /**
+   *
+   * @param {object} [options]
+   * @param {Record<string, string>?} [options.names]
+   * @returns {Connection<E>}
+   */
+  clone({
+    names
+  } = {}) {
+    // eslint-disable-next-line no-nested-ternary
+    const newNames = this.#names ? names ? {
+      ...this.#names,
+      ...names
+    } : this.#names : names;
+    return new Connection(this.#getConnection(), this.#baseTransaction, newNames);
+  }
+  /** @return {Promise<string>} */
+  async dbType() {
+    const conn = await this.#getConnection();
+    return conn.dbType;
+  }
+  /** @return {Promise<string>} */
+  async dbVersion() {
+    const conn = await this.#getConnection();
+    return conn.dbVersion(this.#env);
+  }
+  /**
+   *
+   * @param {...any} values
+   * @returns {Promise<any[]>}
+   */
+  async query(...values) {
+    const conn = await this.#getConnection();
+    return conn.query(this.#env, ...values);
+  }
+  /**
+   *
+   * @param {...any} values
+   * @returns {Promise<number>}
+   */
+  async exec(...values) {
+    const conn = await this.#getConnection();
+    return conn.exec(this.#env, ...values);
+  }
+  /**
+   *
+   * @param {string} table
+   * @returns {Promise<TableType?>}
+   */
+  async type(table) {
+    const conn = await this.#getConnection();
+    return conn.type(this.#env, this.#getName(table));
+  }
+  /**
+   * @template T
+   * @overload
+   * @param {Build<T>} build
+   * @param {object} data
+   * @param {object | boolean} [saved]
+   * @returns {T}
+   */
+  /**
+   * @template {Fields} T
+   * @overload
+   * @param {TableDefine<T>} table
+   * @param {object} data
+   * @param {object | boolean} [saved]
+   * @returns {FieldValue<T>}
+   */
+  /**
+   * @param {Build | TableDefine} p
+   * @param {object} data
+   * @param {object | boolean} [saved]
+   * @returns {any}
+   */
+  build(p, data, saved) {
+    if (typeof p[Build] === 'function') {
+      return p[Build](data, saved || false, this.#env);
+    }
+    if (typeof saved === 'boolean') {
+      return {
+        ...data
+      };
+    }
+    return {
+      ...data,
+      ...saved
+    };
+  }
+  /**
+   * @template {TableDefine} T
+   * @overload
+   * @param {T} model
+   * @param {object[]} list
+   * @returns {Promise<object[]>}
+   */
+  /**
+   * @template {TableDefine} T
+   * @overload
+   * @param {T} model
+   * @param {object} value
+   * @returns {Promise<T extends Build<infer R> ? R : object>}
+   */
+  /**
+   * @template {TableDefine} T
+   * @overload
+   * @param {T} model
+   * @param {object | object[]} value
+   * @returns {Promise<object[] | (T extends Build<infer R> ? R : object)>}
+   */
+  /**
+   * @template {TableDefine} T
+   * @param {T} model
+   * @param {object | object[]} p
+   * @returns {Promise<object[] | (T extends Build<infer R> ? R : object)>}
+   */
+  async create(model, p) {
+    if (Array.isArray(p) || typeof model[Create] !== 'function') {
+      const modelBuild = model[Build];
+      const md = typeof modelBuild === 'function' ? modelBuild.bind(model) : undefined;
+      const conn = await this.#getConnection();
+      return create(conn, this.#getName, this.#env, model, p, md);
+    }
+    // @ts-ignore
+    const m = /** @type {Create} */model;
+    return m[Create](this, p, async data => {
+      const conn = await this.#getConnection();
+      return create(conn, this.#getName, this.#env, model, data);
+    }, model);
+  }
+  /**
+   *
+   * @template {TableDefine} T
+   * @param {T} sql
+   * @returns {Promise<T extends Build<infer R > ? R[] : T extends TableDefine<infer F> ? FieldValue<F>[] : never>}
+   */
+  async find(sql) {
+    const conn = await this.#getConnection();
+    return find(conn, this.#getName, sql, this.#env);
+  }
+  /**
+   *
+   * @template {TableDefine} T
+   * @param {T} sql
+   * @returns {Promise<T extends Build<infer R > ? R : T extends TableDefine<infer F> ? FieldValue<F> : never>}
+   */
+  async first(sql) {
+    const conn = await this.#getConnection();
+    return first(conn, this.#getName, sql, this.#env);
+  }
+  /**
+   * @template T
+   * @param {TableDefine} model
+   * @param {T} data
+   * @returns {Promise<(T extends Save ? T : object)?>}
+   */
+  async save(model, data) {
+    if (typeof data[Save] !== 'function') {
+      const conn = await this.#getConnection();
+      return create(conn, this.#getName, this.#env, model, data);
+    }
+    const r = /** @type {Save}*/data;
+    // @ts-ignore
+    return r[Save](this, async (doc, newData) => {
+      const conn = await this.#getConnection();
+      if (newData) {
+        return updateData(conn, this.#getName, model, doc, newData, this.#env);
+      }
+      return create(conn, this.#getName, this.#env, model, doc);
+    }, model);
+  }
+  /**
+   *
+   * @template T
+   * @param {TableDefine} tableDef
+   * @param {T} data
+   * @returns {Promise<(T extends Destroy ? T : object)?>}
+   */
+  async completelyDestroy(tableDef, data) {
+    if (typeof data[Destroy] !== 'function') {
+      const conn = await this.#getConnection();
+      return completelyDelete(conn, this.#getName, tableDef, data, this.#env);
+    }
+    const r = /** @type {Destroy} */data;
+    // @ts-ignore
+    return r[Destroy](this, async data => {
+      const conn = await this.#getConnection();
+      return completelyDelete(conn, this.#getName, tableDef, data, this.#env);
+    }, tableDef);
+  }
+  /**
+   *
+   * @template {object} T
+   * @param {TableDefine} tableDef
+   * @param {T} data
+  * @param {Record<string, SetValue>} value
+   * @returns {Promise<(T extends PseudoDestroy ? T : object)?>}
+   */
+  async pseudoDestroy(tableDef, data, value) {
+    if (!canPseudo(tableDef)) {
+      return null;
+    }
+    const update = {
+      ...value
+    };
+    if (typeof data[PseudoDestroy] !== 'function') {
+      const conn = await this.#getConnection();
+      return pseudoDestroy(conn, this.#getName, tableDef, data, update, this.#env);
+    }
+    const r = /** @type {PseudoDestroy} */data;
+    // @ts-ignore
+    return r[PseudoDestroy](this, update, async data => {
+      const conn = await this.#getConnection();
+      return pseudoDestroy(conn, this.#getName, tableDef, data, update, this.#env);
+    }, tableDef);
+  }
+  /**
+   * @template {Destroy & PseudoDestroy} T
+   * @overload
+   * @param {TableDefine} table
+   * @param {T} data
+   * @param {Record<string, any> | boolean} [update]
+   * @returns {Promise<T?>}
+   */
+  /**
+   * @template {Destroy & PseudoDestroy} T
+   * @overload
+   * @param {TableDefine} table
+   * @param {T} data
+   * @param {Record<string, any> | boolean} [update]
+   * @returns {Promise<T | object | null>}
+   */
+  /**
+   * @overload
+   * @param {TableDefine} table
+   * @param {any} data
+   * @param {Record<string, any> | boolean} [update]
+   * @returns {Promise<object?>}
+   */
+  /**
+   * @param {TableDefine} tableDef
+   * @param {any} data
+   * @param {Record<string, any> | boolean} [update]
+   * @returns {Promise<object?>}
+   */
+  async destroy(tableDef, data, update) {
+    if (update === false || !canPseudo(tableDef)) {
+      return this.completelyDestroy(tableDef, data);
+    }
+    if (!canPseudo(tableDef)) {
+      return null;
+    }
+    return this.pseudoDestroy(tableDef, data, update !== true && update || {});
+  }
+  /**
+   * @param {Queryable} queryable
+   * @param {Record<string, SetValue> | boolean} [update]
+   * @returns {Promise<number>}
+   */
+  async destroyMany(queryable, update) {
+    const conn = await this.#getConnection();
+    if (update === false || !isPseudo(queryable)) {
+      return deleteMany(conn, this.#getName, queryable, this.#env);
+    }
+    return pseudoDeleteMany(conn, this.#getName, queryable, update, this.#env);
+  }
+  /**
+   * @template {object | object[]} T
+   * @param {TableDefine} tableDefine
+   * @param {T} data
+   * @param {string[]} [keys]
+   * @returns {Promise<T extends object[] ? object[] : object>}
+   */
+  async insert({
+    table,
+    fields
+  }, data, keys) {
+    const baseFields = toBaseFields(fields);
+    const isArray = Array.isArray(data);
+    const insertValues = (isArray ? data : [data]).map(d => getInsertValue(d, fields));
+    if (!insertValues.length) {
+      throw new Error();
+    }
+    let insertKeys = [...new Set(keys || [])].filter(k => k in baseFields);
+    if (!insertKeys.length && !isArray) {
+      insertKeys = Object.entries(insertValues[0]).filter(([k, v]) => v !== undefined && k in baseFields).map(([k]) => k);
+    }
+    if (!insertKeys.length) {
+      insertKeys = Object.entries(baseFields).filter(([, o]) => !o.serial || o.type !== 'id').map(v => v[0]);
+    }
+    const conn = await this.#getConnection();
+    const p = table && typeof table === 'object' ? await table.insert(this.#env, conn, '', baseFields, insertValues, insertKeys) : await conn.insert(this.#env, this.#getName(table), baseFields, insertValues, insertKeys);
+    return isArray ? (/** @type {*}*/p) : p[0];
+  }
+  /**
+   * @param {TableDefine} tableDefine
+   * @param {Record<string, any>} update
+   * @param {WhereValue[]?} [where]
+   * @param {boolean} [skip]
+   * @returns {Promise<number>}
+   */
+  async update({
+    table,
+    fields
+  }, update, where, skip) {
+    const conn = await this.#getConnection();
+    return table && typeof table === 'object' ? table.update(this.#env, conn, {
+      table: '',
+      fields: toBaseFields(fields),
+      where: where || undefined
+    }, getSetValue$1(update, fields, skip)) : conn.update(this.#env, {
+      table: this.#getName(table),
+      fields: toBaseFields(fields),
+      where: where || undefined
+    }, getSetValue$1(update, fields, skip));
+  }
+  /**
+   * @template {Fields<MainFieldType>} T
+   * @param {TableDefine<T>} tableDefine
+   * @param {Record<string, any>} update
+   * @param {string[]?} [returning]
+   * @param {WhereValue[]?} [where]
+   * @param {boolean} [skip]
+   * @returns {Promise<any[]>}
+   */
+  async updateReturn({
+    table,
+    fields
+  }, update, returning, where, skip) {
+    const conn = await this.#getConnection();
+    const baseFields = toBaseFields(fields);
+    return table && typeof table === 'object' ? table.updateReturn(this.#env, conn, {
+      table: '',
+      fields: baseFields,
+      where: where || undefined
+    }, getSetValue$1(update, fields, skip), returning?.length ? returning : Object.keys(baseFields)) : conn.updateReturn(this.#env, {
+      table: this.#getName(table),
+      fields: baseFields,
+      where: where || undefined
+    }, getSetValue$1(update, fields, skip), returning?.length ? returning : Object.keys(baseFields));
+  }
+  /**
+   * @param {TableDefine} tableDefine
+   * @param {string[]} pKeys
+   * @param {string[]} setKeys
+   * @param {Record<string, any>[]} list
+   * @param {boolean} [skip]
+   * @returns {Promise<number>}
+   */
+  async updateMany({
+    table,
+    fields
+  }, pKeys, setKeys, list, skip) {
+    const baseFields = toBaseFields(fields);
+    const update = skip ? {} : getSetNewValue(fields);
+    const [whereFields, setFields] = getKeys(baseFields, update, pKeys, setKeys);
+    const conn = await this.#getConnection();
+    return table && typeof table === 'object' ? table.updateMany(this.#env, conn, '', baseFields, update, whereFields, setFields, list, []) : conn.updateMany(this.#env, this.#getName(table), baseFields, update, whereFields, setFields, list, []);
+  }
+  /**
+   * @template {Fields<MainFieldType>} T
+   * @param {TableDefine<T>} tableDefine
+   * @param {string[]} pKeys
+   * @param {string[]} setKeys
+   * @param {Record<string, any>[]} list
+   * @param {string[]?} [returning]
+   * @param {boolean} [skip]
+   * @returns {Promise<any[]>}
+   */
+  async updateManyReturn({
+    table,
+    fields
+  }, pKeys, setKeys, list, returning, skip) {
+    const baseFields = toBaseFields(fields);
+    const update = skip ? {} : getSetNewValue(fields);
+    const [whereFields, setFields] = getKeys(baseFields, update, pKeys, setKeys);
+    const conn = await this.#getConnection();
+    return table && typeof table === 'object' ? table.updateManyReturn(this.#env, conn, '', baseFields, update, whereFields, setFields, list, [], returning?.length ? returning : Object.keys(baseFields)) : conn.updateManyReturn(this.#env, this.#getName(table), baseFields, update, whereFields, setFields, list, [], returning?.length ? returning : Object.keys(baseFields));
+  }
+  /**
+   * @param {TableDefine} tableDefine
+   * @param {WhereValue[]} [where]
+   * @returns {Promise<number>}
+   */
+  async delete({
+    table,
+    fields
+  }, where) {
+    const conn = await this.#getConnection();
+    return table && typeof table === 'object' ? table.delete(this.#env, conn, {
+      table: '',
+      fields: toBaseFields(fields),
+      where
+    }) : conn.delete(this.#env, {
+      table: this.#getName(table),
+      fields: toBaseFields(fields),
+      where
+    });
+  }
+  /**
+   * @template {Fields<MainFieldType>} T
+   * @param {TableDefine<T>} tableDefine
+   * @param {string[]?} [returning]
+   * @param {WhereValue[]} [where]
+   * @returns {Promise<any[]>}
+   */
+  async deleteReturn({
+    table,
+    fields
+  }, returning, where) {
+    const conn = await this.#getConnection();
+    const baseFields = toBaseFields(fields);
+    return table && typeof table === 'object' ? table.deleteReturn(this.#env, conn, {
+      table: '',
+      fields: baseFields,
+      where
+    }, returning?.length ? returning : Object.keys(baseFields)) : conn.deleteReturn(this.#env, {
+      table: this.#getName(table),
+      fields: baseFields,
+      where
+    }, returning?.length ? returning : Object.keys(baseFields));
+  }
+  /**
+   *
+   * @param {Queryable} queryable
+   * @returns {Promise<number>}
+   */
+  async count(queryable) {
+    const {
+      table,
+      fields
+    } = queryable;
+    const options = getOptions(queryable);
+    const conn = await this.#getConnection();
+    return table && typeof table === 'object' ? table.count(this.#env, conn, {
+      ...options,
+      table: '',
+      fields: toBaseFields(fields)
+    }) : conn.count(this.#env, {
+      ...options,
+      table: this.#getName(table),
+      fields: toBaseFields(fields)
+    });
+  }
+  /**
+   * @param {Queryable} queryable
+   * @returns {Promise<any[]>}
+   */
+  async select(queryable) {
+    const {
+      table
+    } = queryable;
+    const fields = toBaseFields(queryable.fields);
+    const options = getOptions(queryable);
+    const conn = await this.#getConnection();
+    const select = toSelect(fields, options.select);
+    const {
+      sort
+    } = options;
+    return table && typeof table === 'object' ? table.select(this.#env, conn, {
+      ...options,
+      table: '',
+      fields,
+      select,
+      sort: sort?.length ? sort : getDefaultSort(fields)
+    }) : conn.select(this.#env, {
+      ...options,
+      table: this.#getName(table),
+      fields,
+      select,
+      sort: sort?.length ? sort : getDefaultSort(fields)
+    });
+  }
+  /**
+   * @param {string} table
+   * @param {string} column
+   * @param {string} type
+   * @param {ColumnOptions<any>} options
+   * @returns {Promise<number>}
+   */
+  async addColumn(table, column, type, options) {
+    const conn = await this.#getConnection();
+    return conn.addColumn(this.#env, this.#getName(table), column, type, timestampDef(options));
+  }
+  /**
+   * @param {string} table
+   * @param {string} column
+   * @param {string} type
+   * @param {ColumnOptions<any>} options
+   * @returns {Promise<number>}
+   */
+  async changeColumn(table, column, type, options) {
+    const conn = await this.#getConnection();
+    return conn.changeColumn(this.#env, this.#getName(table), column, type, timestampDef(options));
+  }
+  /**
+   * @param {string} table
+   * @param {string} column
+   * @param {boolean} nullable
+   * @returns {Promise<number>}
+   */
+  async changeColumnNull(table, column, nullable) {
+    const conn = await this.#getConnection();
+    return conn.changeColumnNull(this.#env, this.#getName(table), column, nullable);
+  }
+  /**
+   * @param {string} table
+   * @param {string} column
+   * @returns {Promise<number>}
+   */
+  async dropColumn(table, column) {
+    const conn = await this.#getConnection();
+    return conn.dropColumn(this.#env, this.#getName(table), column);
+  }
+  /**
+   * @param {string} table
+   * @param {string} column
+   * @param {string} newName
+   * @returns {Promise<number>}
+   */
+  async renameColumn(table, column, newName) {
+    const conn = await this.#getConnection();
+    return conn.renameColumn(this.#env, this.#getName(table), column, newName);
+  }
+  /**
+   * @param {string} table
+   * @param {string} name
+   * @param {string[]} fields
+   * @param {IndexOptions} [options]
+   * @returns {Promise<number>}
+   */
+  async addIndex(table, name, fields, options = {}) {
+    const conn = await this.#getConnection();
+    return conn.addIndex(this.#env, this.#getName(table), name, fields, options);
+  }
+  /**
+   * @param {string} table
+   * @param {string} name
+   * @returns {Promise<number>}
+   */
+  async dropIndex(table, name) {
+    const conn = await this.#getConnection();
+    return conn.dropIndex(this.#env, this.#getName(table), name);
+  }
+  /**
+   * @param {string} table
+   * @param {Column<any>[]} fields
+   * @returns {Promise<number>}
+   */
+  async createTable(table, fields) {
+    const conn = await this.#getConnection();
+    return conn.createTable(this.#env, this.#getName(table), fields.map(timestampDef));
+  }
+  /**
+   * @param {string} table
+   * @returns {Promise<number>}
+   */
+  async dropTable(table) {
+    const conn = await this.#getConnection();
+    return conn.dropTable(this.#env, this.#getName(table));
+  }
+  /**
+   * @param {string} table
+   * @param {string} newName
+   * @returns {Promise<number>}
+   */
+  async renameTable(table, newName) {
+    const conn = await this.#getConnection();
+    return conn.renameTable(this.#env, this.#getName(table), newName);
+  }
+  /**
+   * @param {string} view
+   * @param {Queryable} queryable
+   * @returns {Promise<number>}
+   */
+  async createView(view, queryable) {
+    const conn = await this.#getConnection();
+    const {
+      table
+    } = queryable;
+    const fields = toBaseFields(queryable.fields);
+    const options = getOptions(queryable);
+    const select = toSelect(fields, options.select);
+    return conn.createView(this.#env, this.#getName(view), {
+      ...options,
+      table: typeof table === 'string' ? table : '',
+      fields,
+      select
+    });
+  }
+  /**
+   * @param {string} view
+   * @returns {Promise<number>}
+   */
+  async dropView(view) {
+    const conn = await this.#getConnection();
+    return conn.dropView(this.#env, this.#getName(view));
+  }
+  /**
+   * @param {string} view
+   * @param {Queryable} queryable
+   * @returns {Promise<number>}
+   */
+  async createMaterializedView(view, queryable) {
+    const conn = await this.#getConnection();
+    const {
+      table
+    } = queryable;
+    const fields = toBaseFields(queryable.fields);
+    const options = getOptions(queryable);
+    const select = toSelect(fields, options.select);
+    return conn.createMaterializedView(this.#env, this.#getName(view), {
+      ...options,
+      table: typeof table === 'string' ? table : '',
+      fields,
+      select
+    });
+  }
+  /**
+   * @param {string} view
+   * @returns {Promise<number>}
+   */
+  async dropMaterializedView(view) {
+    const conn = await this.#getConnection();
+    return conn.dropMaterializedView(this.#env, this.#getName(view));
+  }
+  /** @type {AbortController[]} */
+  #layers = [];
+  /**
+   * @template T
+   * @param {(signal: AbortSignal) => PromiseLike<T> | T} fn
+   * @returns {Promise<T>}
+   */
+  async #transaction(fn) {
+    const layers = this.#layers;
+    /**
+     *
+     * @param {number} k
+     */
+    function end(k) {
+      const list = layers.splice(k, layers.length - k);
+      layers.pop();
+      if (!list.length) {
+        return;
+      }
+      const error = new Error();
+      console.error(error);
+      for (const ac of list) {
+        ac.abort(error);
+      }
+    }
+    const run = async () => {
+      const ac = new AbortController();
+      const k = layers.push(ac);
+      try {
+        return await Promise.race([fn(ac.signal), signal2promise(ac.signal)]);
+      } finally {
+        if (layers[k - 1] === ac) {
+          end(k);
+        }
+        // TODO: 减少一层
+        // TODO: 检测层数
+      }
+    };
+    if (layers.length || this.#baseTransaction) {
+      return run();
+    }
+    // TODO
+    const conn = await this.#getConnection();
+    return conn.transaction(this.#env, async t => {
+      if (layers.length) {
+        throw new Error();
+      }
+      this.#env.transaction = t;
+      try {
+        return await run();
+      } finally {
+        this.#env.transaction = null;
+      }
+    });
+  }
+  abort() {
+    const layers = this.#layers;
+    const list = layers.splice(0, layers.length);
+    if (!list.length) {
+      return true;
+    }
+    const error = new Error();
+    console.error(error);
+    for (const ac of list) {
+      ac.abort(error);
+    }
+    return false;
+  }
+  /**
+   * @template T
+   * @overload
+   * @param {(t: Connection) => PromiseLike<T> | T} fn
+   * @returns {Promise<T>}
+   */
+  /**
+   * @overload
+   * @returns {[Promise<void>, commit: () => Promise<void>, rollback: (e?: any) => Promise<void>]}
+   */
+  /**
+   *
+   * @param {(t: Connection, signal: AbortSignal) => any} [fn]
+   * @returns {any}
+   */
+  transaction(fn) {
+    if (typeof fn === 'function') {
+      return this.#transaction(signal => fn(this, signal));
+    }
+    /** @type {(p: AbortSignal) => void} */
+    let throwAborted = () => {};
+    /** @type {Promise<void>} */
+    const abortedPromise = new Promise((_, r) => {
+      throwAborted = r;
+    });
+    abortedPromise.catch(() => {});
+    /** @type {() => void} */
+    let commit = () => {};
+    /** @type {(e?: any) => void} */
+    let rollback = () => {};
+    /** @type {Promise<void>} */
+    const donePromise = new Promise((r1, r2) => {
+      commit = r1;
+      rollback = r2;
+    });
+    const dbiPromise = this.#transaction(v => {
+      if (v.aborted) {
+        throwAborted(v.reason);
+      } else {
+        v.addEventListener('abort', () => throwAborted(v.reason));
+      }
+      return donePromise;
+    }).then(() => {}, () => {});
+    return [abortedPromise, async () => {
+      commit();
+      return dbiPromise;
+    }, async () => {
+      rollback();
+      return dbiPromise;
+    }];
+  }
+}
+
+/**
+ *
+ * @param {ClassAccessorDecoratorContext} ctx
+ */
+function check(ctx) {
+  if (!ctx || ctx.kind !== 'accessor') {
+    throw new Error('模型属性只能是访问器(accessor)');
+  }
+  if (ctx.static) {
+    throw new Error('模型属性不能是静态属性');
+  }
+  if (ctx.private) {
+    throw new Error('模型属性不能是私有属性');
+  }
+  const {
+    name
+  } = ctx;
+  if (typeof name !== 'string') {
+    throw new Error('模型属性不能是符号');
+  }
+  return name;
+}
+
+/** @import { ClassDecorator } from './index.mjs' */
+const fieldKey = Symbol();
+const propsKey = Symbol();
+const typeKey = Symbol();
+/** @import { Constraint, FieldDefineOption, TableDefine } from '../types' */
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ *
+ * @overload
+ * @param {string} table
+ * @returns {ClassDecorator}
+ */
+/**
+ * @template {Record<string, any>} T
+ * @overload
+ * @param {TableDefine & {new(...a: any): T}} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {true} array
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T[]>}
+ */
+/**
+ * @template {Record<string, any>} T
+ * @overload
+ * @param {TableDefine & {new(...a: any): T}} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {false} [array]
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T>}
+ */
+/**
+ * @template {Record<string, any>} T
+ * @overload
+ * @param {TableDefine & {new(...a: any): T}} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T>}
+ */
+/**
+ * @template {Record<string, any>} T
+ * @template {boolean} [A=boolean]
+ * @overload
+ * @param {TableDefine & {new(...a: any): T}} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {A} array
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<A extends false ? T : A extends true ? T[] : T | T[]>}
+ */
+/**
+ * @template {object} T
+ * @overload
+ * @param {TableDefine} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {true} array
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T[]>}
+ */
+/**
+ * @template {object} T
+ * @overload
+ * @param {TableDefine} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {false} [array]
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T>}
+ */
+/**
+ * @template {object} T
+ * @overload
+ * @param {TableDefine} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<T>}
+ */
+/**
+ * @template {object} T
+ * @template {boolean} [A=boolean]
+ * @overload
+ * @param {TableDefine} type
+ * @param {Record<string, Constraint>} constraints
+ * @param {A} array
+ * @param {FieldDefineOption} [options]
+ * @returns {FieldDecorator<A extends false ? T :A extends true ? T[] : T | T[]>}
+ */
+/**
+ *
+ * @param {TableDefine | string} type
+ * @param {Record<string, Constraint>} [constraints]
+ * @param {*} [p1]
+ * @param {*} [p2]
+ */
+function submodel(type, constraints, p1, p2) {
+  if (typeof type === 'string') {
+    const table = type;
+    /**
+     *
+     * @param {*} ModelClass
+     * @param {ClassDecoratorContext} ctx
+     */
+    return (ModelClass, ctx) => {
+      if (typeof ModelClass !== 'function' || ctx?.kind !== 'class') {
+        throw new Error('模型只能是类(class)');
+      }
+      const {
+        metadata
+      } = ctx;
+      const fields = metadata[fieldKey];
+      if (metadata[typeKey]) {
+        throw new Error('已经被定义');
+      }
+      metadata[typeKey] = 'model';
+      const classField = ModelClass.fields;
+      if (!fields && !classField) {
+        throw new Error('字段未定义');
+      }
+      Object.defineProperty(ModelClass, 'table', {
+        value: table,
+        configurable: true,
+        enumerable: true
+      });
+      if (!fields) {
+        return;
+      }
+      const props = metadata[propsKey] || {};
+      const setFields = Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, {
+        ...v,
+        ...props[k]
+      }]));
+      ctx.addInitializer(function () {
+        if (ModelClass[typeKey]) {
+          throw new Error('已经被定义');
+        }
+        ModelClass[typeKey] = 'model';
+        Object.defineProperty(this, 'fields', {
+          value: {
+            ...classField,
+            ...setFields
+          },
+          enumerable: true,
+          configurable: true
+        });
+      });
+    };
+  }
+  /** @type { {nullable?: boolean; array?: boolean; default?: any; } & FieldDefineOption} */
+  const ctx = typeof p1 === 'object' && p1 || p2 || {};
+  const array = p1 === true;
+  const {
+    array: _array,
+    nullable,
+    default: def,
+    precision,
+    scale,
+    size,
+    unique,
+    index,
+    primary,
+    serial,
+    immutable,
+    text,
+    sort,
+    ...p
+  } = ctx;
+  const define = {
+    ...p,
+    constraints,
+    type: {
+      table: type.table,
+      fields: type.fields,
+      pseudo: type.pseudo,
+      indexes: type.indexes
+    },
+    array,
+    nullable: false,
+    immutable
+  };
+  /**
+   *
+   * @param {*} _
+   * @param {ClassAccessorDecoratorContext} ctx
+   */
+  return (_, ctx) => {
+    const name = check(ctx);
+    const {
+      metadata
+    } = ctx;
+    const fields = metadata[fieldKey];
+    if (fields) {
+      fields[name] = define;
+    } else {
+      metadata[fieldKey] = Object.assign(Object.create(null), {
+        [name]: define
+      });
+    }
+    return {
+      get() {
+        return this.$get(name);
+      },
+      set(value) {
+        return this.$set(name, value);
+      }
+    };
+  };
+}
+
+/** @import { FieldDefineOption, FieldType, ToType } from '../types' */
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array?: false;
+ * 	default?: ToType<T, false, false>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} [options]
+ * @returns {FieldDecorator<ToType<T, false, false>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array: true;
+ * 	default?: ToType<T, true, false>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, false>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {true} array
+ * @param {{
+ * 	nullable?: false;
+ * 	default?: ToType<T, true, false>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, false>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array?: false;
+ * 	default?: ToType<T, false, true>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, false, true>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array: true;
+ * 	default?: ToType<T, true, true>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, true>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {true} array
+ * @param {{
+ * 	nullable: true;
+ * 	default?: ToType<T, true, true>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, true>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} A
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array: A;
+ * 	default?: ToType<T, A, true>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, A, true>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} A
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array: A;
+ * 	default?: ToType<T, A, false>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, A, false>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array?: false;
+ * 	default?: ToType<T, false, N>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, false, N>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array: true;
+ * 	default?: ToType<T, true, N>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, N>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {true} array
+ * @param {{
+ * 	nullable: N;
+ * 	default?: ToType<T, true, N>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, true, N>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @template {boolean} A
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array: A;
+ * 	default?: ToType<T, A, N>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, A, N>>}
+ */
+/**
+ * @template {keyof FieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: boolean;
+ * 	array?: boolean;
+ * 	default?: ToType<T, boolean, boolean>;
+ * 	[k: string]: any;
+ * } & FieldDefineOption} options
+ * @returns {FieldDecorator<ToType<T, boolean, boolean>>}
+ */
+/**
+ *
+ * @param {*} type
+ * @param {*} [p1]
+ * @param {*} [p2]
+ */
+function field$1(type, p1, p2) {
+  if (typeof type !== 'string') {
+    throw new Error('无效的类型');
+  }
+  /** @type { {nullable?: boolean; array?: boolean; default?: any; } & FieldDefineOption} */
+  const ctx = typeof p1 === 'object' && p1 || p2 || {};
+  const array = p1 === true || ctx.array;
+  const {
+    array: _array,
+    nullable,
+    default: def,
+    precision,
+    scale,
+    size,
+    unique,
+    index,
+    primary,
+    serial,
+    immutable,
+    text,
+    sort,
+    ...p
+  } = ctx;
+  const define = {
+    ...p,
+    type,
+    array: Boolean(array),
+    nullable: Boolean(nullable),
+    precision,
+    scale,
+    size,
+    default: def,
+    index,
+    unique: Boolean(unique),
+    primary,
+    serial,
+    immutable,
+    text,
+    sort
+  };
+  /**
+   *
+   * @param {*} _
+   * @param {ClassAccessorDecoratorContext} ctx
+   */
+  return (_, ctx) => {
+    const name = check(ctx);
+    const {
+      metadata
+    } = ctx;
+    const fields = metadata[fieldKey];
+    if (fields) {
+      fields[name] = define;
+    } else {
+      metadata[fieldKey] = Object.assign(Object.create(null), {
+        [name]: define
+      });
+    }
+    return {
+      get() {
+        return this.$get(name);
+      },
+      set(value) {
+        return this.$set(name, value);
+      }
+    };
+  };
+}
+
+/** @import { ToFieldType } from '../types' */
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ * @param {object} [options]
+ * @param {number?} [options.sort]
+ * @returns {FieldDecorator<ToFieldType<'id'>>}
+ */
+function id({
+  sort
+} = {}) {
+  const define = {
+    type: 'id',
+    index: true,
+    unique: true,
+    primary: true,
+    serial: true,
+    immutable: true,
+    sort
+  };
+  /**
+   *
+   * @param {*} _
+   * @param {ClassAccessorDecoratorContext} ctx
+   */
+  return (_, ctx) => {
+    const name = check(ctx);
+    const {
+      metadata
+    } = ctx;
+    const fields = metadata[fieldKey];
+    if (fields) {
+      fields[name] = define;
+    } else {
+      metadata[fieldKey] = Object.assign(Object.create(null), {
+        [name]: define
+      });
+    }
+    return {
+      get() {
+        return this.$get(name);
+      },
+      set(value) {
+        return this.$set(name, value);
+      }
+    };
+  };
+}
+
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ *
+ * @param {ClassAccessorDecoratorContext} ctx
+ * @param {*} precision
+ * @param {'timestampCreating' | 'timestampUpdating' | 'timestampDeleting'} prop
+ */
+function defineTimestamp(ctx, precision, prop) {
+  const name = check(ctx);
+  const {
+    metadata
+  } = ctx;
+  const fields = metadata[fieldKey];
+  const define = {
+    type: 'timestamp',
+    array: false,
+    nullable: true,
+    precision,
+    [prop]: true
+  };
+  if (fields) {
+    fields[name] = define;
+  } else {
+    metadata[fieldKey] = Object.assign(Object.create(null), {
+      [name]: define
+    });
+  }
+  return {
+    get() {
+      return this.$get(name);
+    },
+    set(value) {
+      return this.$set(name, value);
+    }
+  };
+}
+/**
+ * @param {number} [precision]
+ * @returns {FieldDecorator<Date?>}
+ */
+function creating(precision) {
+  return (_, ctx) => defineTimestamp(ctx, precision, 'timestampCreating');
+}
+/**
+ * @param {number} [precision]
+ * @returns {FieldDecorator<Date?>}
+ */
+function updating(precision) {
+  return (_, ctx) => defineTimestamp(ctx, precision, 'timestampUpdating');
+}
+/**
+ * @param {number} [precision]
+ * @returns {FieldDecorator<Date?>}
+ */
+function deleting(precision) {
+  return (_, ctx) => defineTimestamp(ctx, precision, 'timestampDeleting');
+}
+
+/**
+ *
+ * @param {ClassAccessorDecoratorContext} ctx
+ * @param {string} prop
+ * @param {any} value
+ */
+function setProp(ctx, prop, value) {
+  const name = check(ctx);
+  const {
+    metadata
+  } = ctx;
+  /** @type {Record<string, any>} */
+  // @ts-ignore
+  let fields = metadata[propsKey];
+  if (!fields) {
+    fields = Object.create(null);
+    metadata[propsKey] = fields;
+  }
+  const field = fields[name];
+  if (field) {
+    fields[name][prop] = value;
+  } else {
+    fields[name] = {
+      [prop]: value
+    };
+  }
+}
+
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ * @param {string} prop
+ * @param {any} value
+ * @returns {FieldDecorator<any>}
+ */
+function prop(prop, value) {
+  return (_, ctx) => setProp(ctx, prop, value);
+}
+
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ *
+ * @param {number} [primary]
+ * @returns {FieldDecorator<any>}
+ */
+function primary(primary) {
+  return (_, ctx) => setProp(ctx, 'primary', primary || true);
+}
+
+/** @import { FieldDecorator } from './index.mjs' */
+/** @returns {FieldDecorator<any>} */
+function immutable() {
+  return (_, ctx) => setProp(ctx, 'immutable', true);
+}
+
+/** @import { IndexOptions } from '../types' */
+/** @import { ClassDecorator, FieldDecorator } from './index.mjs' */
+/**
+ * 索引信息
+ * @param {string | true} [index]
+ * @param {boolean} [unique]
+ * @returns {FieldDecorator<any>}
+ */
+function indexProp(index, unique) {
+  /**
+   *
+   * @param {ClassAccessorDecoratorContext} ctx
+   */
+  return function (_, ctx) {
+    const name = check(ctx);
+    const {
+      metadata
+    } = ctx;
+    /** @type {Record<string, any>} */
+    // @ts-ignore
+    let fields = metadata[propsKey];
+    if (!fields) {
+      fields = Object.create(null);
+      metadata[propsKey] = fields;
+    }
+    const field = fields[name];
+    if (field) {
+      field.index = index;
+      if (unique) {
+        field.unique = true;
+      }
+    } else {
+      fields[name] = {
+        index,
+        unique
+      };
+    }
+  };
+}
+/**
+ * 索引信息
+ * @param {string[]} fields
+ * @param {IndexOptions} options
+ * @returns {ClassDecorator}
+ */
+function indexClass(fields, options) {
+  return (ModelClass, ctx) => {
+    if (typeof ModelClass !== 'function' || ctx?.kind !== 'class') {
+      throw new Error('指定字段的用法，只能用在类(class)上');
+    }
+    ctx.addInitializer(function () {
+      const r = Reflect.getOwnPropertyDescriptor(this, 'indexes');
+      if (!r) {
+        Reflect.defineProperty(this, 'indexes', {
+          // @ts-ignore
+          value: [...(this.indexes || [])],
+          configurable: true,
+          enumerable: true
+        });
+      }
+      // @ts-ignore
+      this.indexes.push({
+        ...options,
+        fields
+      });
+    });
+  };
+}
+/**
+ * 索引信息
+ * @overload
+ * @param {string[]} fields
+ * @param {IndexOptions} [options]
+ * @returns {ClassDecorator}
+ */
+/**
+ * 索引信息
+ * @overload
+ * @param {string} [name]
+ * @param {boolean} [unique]
+ * @returns {FieldDecorator<any>}
+ */
+/**
+ * 索引信息
+ * @overload
+ * @param {boolean} [unique]
+ * @returns {FieldDecorator<any>}
+ */
+/**
+ * 索引信息
+ * @param {string | boolean | string[]} [a]
+ * @param {boolean | IndexOptions} [b]
+ * @returns {FieldDecorator<any> | ClassDecorator}
+ */
+function index(a, b) {
+  if (Array.isArray(a)) {
+    return indexClass(a, typeof b === 'object' && b || {});
+  }
+  const unique = a === true || b === true;
+  const index = typeof a === 'string' && a || true;
+  return indexProp(index, unique);
+}
+
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ * 默认排序顺序，绝对值表示在排序列表中的顺序，负数表示逆序排序, 0 表示不排序
+ * @param {number} sort
+ * @returns {FieldDecorator<any>}
+ */
+function sort(sort) {
+  return (_, ctx) => setProp(ctx, 'sort', sort);
+}
+
+/** @import { ClassDecorator } from './index.mjs' */
+/**
+ *
+ * @param {string} pseudo
+ * @returns {ClassDecorator}
+ */
+function pseudo(pseudo) {
+  /**
+   *
+   * @param {*} ModelClass
+   * @param {ClassDecoratorContext} ctx
+   */
+  return (ModelClass, ctx) => {
+    if (typeof ModelClass !== 'function' || ctx?.kind !== 'class') {
+      throw new Error('模型只能是类(class)');
+    }
+    ctx.addInitializer(function () {
+      Object.defineProperty(this, 'pseudo', {
+        value: pseudo,
+        configurable: true,
+        enumerable: true
+      });
+    });
+  };
+}
+
+/** @typedef {{toWhereValue(): WhereValue[][]}} WhereLike */
+/** @typedef {WhereLike | Record<string, any> | (WhereLike | Record<string, any>)[]} Wheres */
+/**
+ * @typedef {object} WhereItem
+ * @prop {null} [where]
+ * @prop {null} [or]
+ * @prop {string | {table?: string; field: string} | (string | {table?: string; field: string})[]} field
+ * @prop {any} value
+ * @prop {boolean} [not]
+ * @prop {string?} [operator]
+ */
+/**
+ * @typedef {object} WhereRaw
+ * @prop {null} [field]
+ * @prop {null} [or]
+ * @prop {readonly string[]} where
+ * @prop {readonly any[]} values
+ * @prop {boolean} [not]
+ */
+/**
+ * @typedef {object} WhereOr
+ * @prop {null} [where]
+ * @prop {null} [field]
+ * @prop {WhereValue[][]} or
+ * @prop {boolean} [not]
+ */
+/** @typedef {WhereItem | WhereRaw | WhereOr} WhereValue */
+/**
+ *
+ * @param {*} v
+ * @returns {v is TemplateStringsArray}
+ */
+function isTemplateStringsArray(v) {
+  // @ts-ignore
+  return Array.isArray(v) && Array.isArray(v.raw);
+}
+/**
+ * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+ * @returns {WhereValue[]?}
+ */
+function parse(items) {
+  if (!items.length) {
+    return null;
+  }
+  const [first] = items;
+  if (isTemplateStringsArray(first)) {
+    if (first.raw.length !== items.length) {
+      // TODO: 报错
+      return [{
+        where: first.raw,
+        values: items.slice(1)
+      }];
+    }
+  }
+  if (items.length === 1) {
+    /** @type {WhereValue[][]} */
+    const result = [];
+    const list = /** @type {(WhereLike | Record<string, any>)[]} */items.flat(Infinity);
+    for (const item of list) {
+      if (!item) {
+        continue;
+      }
+      if (typeof item !== 'object') {
+        // TODO: 报错
+        continue;
+      }
+      if (typeof item.toWhereValue === 'function') {
+        const values = item.toWhereValue();
+        if (values.length <= 1) {
+          result.push(values[0] || []);
+        } else {
+          result.push([{
+            or: values
+          }]);
+        }
+        continue;
+      }
+      for (const [k, v] of Object.entries(item)) {
+        result.push([{
+          field: k,
+          value: v,
+          not: false
+        }]);
+      }
+    }
+    return result.flat();
+  }
+  if (items.length === 2) {
+    items.splice(1, 0, '');
+  }
+  if (items.length === 3) {
+    items.push(false);
+  }
+  if (items.length > 4) {
+    // TODO: 报错
+    return null;
+  }
+  const [field, operator, value, not] = items;
+  // @ts-ignore
+  return [{
+    field,
+    operator,
+    value,
+    not: Boolean(not)
+  }];
+}
+/**
+ * @param {WhereValue[]?} [items]
+ * @returns {WhereValue[]?}
+ */
+function toNot(items) {
+  if (!items) {
+    return null;
+  }
+  return items.map(v => ({
+    ...v,
+    not: !v.not
+  }));
+}
+class Where {
+  /**
+   * @overload
+   * @param {Wheres} matches
+   * @returns {WhereValue[]?}
+   */
+  /**
+   * @overload
+   * @param {string | string[]} field
+   * @param {any} value
+   * @returns {WhereValue[]?}
+   */
+  /**
+   * @overload
+   * @param {string | string[]} field
+   * @param {string} operator
+   * @param {any} value
+   * @param {boolean} [not]
+   * @returns {WhereValue[]?}
+   */
+  /**
+   * @overload
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {WhereValue[]?}
+   */
+  /**
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {WhereValue[]?}
+   */
+  static parse(...items) {
+    return parse(items);
+  }
+  /**
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {WhereValue[]?}
+   */
+  static parseParams(items) {
+    return parse(items);
+  }
+  /** @type {WhereValue[]} */
+  #last = [];
+  #values = [this.#last];
+  toWhereValue() {
+    return this.#values.filter(v => v.length);
+  }
+  /**
+   * @param {WhereValue[]?} items
+   * @returns {this}
+   */
+  #and(items) {
+    if (!items) {
+      return this;
+    }
+    this.#last.push(...items);
+    return this;
+  }
+  /**
+   * @param {WhereValue[]?} items
+   * @returns {this}
+   */
+  #or(items) {
+    if (!items) {
+      return this;
+    }
+    const last = [...items];
+    this.#last = last;
+    this.#values.push(last);
+    return this;
+  }
+  /**
+   * @overload
+   * @param {Wheres} matches
+   * @returns {this}
+   */
+  /**
+   *
+   * @overload
+   * @param {TemplateStringsArray} where
+   * @param  {...any} values
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {any} value
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {any[]} value
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {string} operator
+   * @param {any} value
+   * @param {boolean} [not]
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {string} operator
+   * @param {any[]} value
+   * @param {boolean} [not]
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {this}
+   */
+  /**
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {this}
+   */
+  and(...items) {
+    return this.#and(parse(items));
+  }
+  /**
+   * @overload
+   * @param {Wheres} matches
+   * @returns {Where}
+   */
+  /**
+   *
+   * @overload
+   * @param {TemplateStringsArray} where
+   * @param  {...any} values
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {any} value
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {any[]} value
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {string} operator
+   * @param {any} value
+   * @param {boolean} [not]
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {string} operator
+   * @param {any[]} value
+   * @param {boolean} [not]
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {Where}
+   */
+  /**
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {Where}
+   */
+  static and(...items) {
+    return new Where().#and(parse(items));
+  }
+  /**
+   * @overload
+   * @param {Wheres} matches
+   * @returns {this}
+   */
+  /**
+   *
+   * @overload
+   * @param {TemplateStringsArray} where
+   * @param  {...any} values
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {any} value
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {any[]} value
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {string} operator
+   * @param {any} value
+   * @param {boolean} [not]
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {string} operator
+   * @param {any[]} value
+   * @param {boolean} [not]
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {this}
+   */
+  /**
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {this}
+   */
+  or(...items) {
+    return this.#or(parse(items));
+  }
+  /**
+   * @overload
+   * @param {Wheres} matches
+   * @returns {Where}
+   */
+  /**
+   *
+   * @overload
+   * @param {TemplateStringsArray} where
+   * @param  {...any} values
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {any} value
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {any[]} value
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {string} operator
+   * @param {any} value
+   * @param {boolean} [not]
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {string} operator
+   * @param {any[]} value
+   * @param {boolean} [not]
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {Where}
+   */
+  /**
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {Where}
+   */
+  static or(...items) {
+    return new Where().#or(parse(items));
+  }
+  /**
+   * @overload
+   * @param {Wheres} matches
+   * @returns {this}
+   */
+  /**
+   *
+   * @overload
+   * @param {TemplateStringsArray} where
+   * @param  {...any} values
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {any} value
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {any[]} value
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {string} operator
+   * @param {any} value
+   * @param {boolean} [not]
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {string} operator
+   * @param {any[]} value
+   * @param {boolean} [not]
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {this}
+   */
+  /**
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {this}
+   */
+  not(...items) {
+    return this.#and(toNot(parse(items)));
+  }
+  /**
+   * @overload
+   * @param {Wheres} matches
+   * @returns {Where}
+   */
+  /**
+   *
+   * @overload
+   * @param {TemplateStringsArray} where
+   * @param  {...any} values
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {any} value
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {any[]} value
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {string} operator
+   * @param {any} value
+   * @param {boolean} [not]
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {string} operator
+   * @param {any[]} value
+   * @param {boolean} [not]
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {Where}
+   */
+  /**
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {Where}
+   */
+  static not(...items) {
+    return new Where().#and(toNot(parse(items)));
+  }
+  /**
+   * @overload
+   * @param {Wheres} matches
+   * @returns {this}
+   */
+  /**
+   *
+   * @overload
+   * @param {TemplateStringsArray} where
+   * @param  {...any} values
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {any} value
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {any[]} value
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {string} operator
+   * @param {any} value
+   * @param {boolean} [not]
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {string} operator
+   * @param {any[]} value
+   * @param {boolean} [not]
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {this}
+   */
+  /**
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {this}
+   */
+  orNot(...items) {
+    return this.#or(toNot(parse(items)));
+  }
+  /**
+   * @overload
+   * @param {Wheres} matches
+   * @returns {Where}
+   */
+  /**
+   *
+   * @overload
+   * @param {TemplateStringsArray} where
+   * @param  {...any} values
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {any} value
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {any[]} value
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {string} operator
+   * @param {any} value
+   * @param {boolean} [not]
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {string} operator
+   * @param {any[]} value
+   * @param {boolean} [not]
+   * @returns {Where}
+   */
+  /**
+   * @overload
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {Where}
+   */
+  /**
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {Where}
+   */
+  static orNot(...items) {
+    return new Where().#or(toNot(parse(items)));
+  }
+}
+
+/** @import { Fields, Options, Queryable, Select } from './types' */
+/** @import { WhereValue, Wheres } from './Where.mjs' */
+/**
+ *
+ * @param {number} [value]
+ * @returns {number | undefined}
+ */
+function getInt(value) {
+  if (typeof value === 'number' && !isNaN(value) && isFinite(value) && value >= 1) {
+    return Math.floor(value);
+  }
+}
+/**
+ * 选择字段
+ * @param {string} fn
+ * @param {Record<string, Select>} select
+ * @param {(string | string[] | Record<string, string>)[]} newSelect
+ */
+function selectFn(fn, select, newSelect) {
+  for (let s of newSelect.flat()) {
+    if (!s) {
+      continue;
+    }
+    if (typeof s === 'string') {
+      select[s] = {
+        field: s,
+        fn: 'sum'
+      };
+      continue;
+    }
+    if (typeof s !== 'object') {
+      continue;
+    }
+    for (let [k, v] of Object.entries(s)) {
+      if (!v) {
+        delete select[k];
+      } else if (typeof v === 'string') {
+        select[k] = {
+          field: v,
+          fn
+        };
+      } else {
+        select[k] = {
+          field: k,
+          fn
+        };
+      }
+    }
+  }
+  return select;
+}
+/**
+ * @template {Fields} T
+ * @template {object} [TB=object]
+ * @typedef {object} QueryOptions
+ * @property {string} table
+ * @property {T} fields
+ * @property {string} [pseudo]
+ * @property {((a: object, b?: object | boolean) => TB)?} [build]
+ */
+/**
+ * @template {Fields} T
+ * @template {object} [TB=object]
+ * @implements {Queryable<T>}
+ */
+class Query {
+  /**
+   * @template {Fields} F
+   * @template {new (o: QueryOptions<F>) => Query<F>} T
+   * @this {T}
+   * @param {string} table
+   * @param {F} fields
+   * @param {string} [pseudo]
+   * @returns {InstanceType<T>}
+   */
+  static table(table, fields, pseudo) {
+    const Q = /** @type {any} */this;
+    return new Q({
+      table,
+      fields,
+      pseudo
+    });
+  }
+  /** @readonly @type {string} */
+
+  /** @readonly @type {T} */
+
+  /** @readonly @type {string} */
+
+  /** @type {((a: object, b?: object | boolean) => TB)?} */
+  #build;
+  /** @type {Options} */
+  #options = {
+    where: []
+  };
+  /** @type {string[]} 主键字段 */
+  #primaryFields = [];
+  get options() {
+    return this.#options;
+  }
+  /**
+   * @param {QueryOptions<T, TB> | Query<T, TB>} options
+   */
+  constructor(options) {
+    if (options instanceof Query) {
+      this.table = options.table;
+      this.fields = options.fields;
+      this.pseudo = options.pseudo;
+      this.#build = options.#build;
+      this.#options = {
+        ...options.#options
+      };
+      this.#primaryFields = options.#primaryFields;
+      this.#primary = options.#primary;
+    } else {
+      const {
+        table,
+        fields,
+        pseudo,
+        build
+      } = options;
+      this.table = table;
+      this.fields = fields;
+      this.pseudo = typeof pseudo === 'string' ? pseudo : '';
+      this.#build = typeof build === 'function' ? build : null;
+      this.#primaryFields = Object.entries(fields).filter(([, v]) => v.primary).sort(([, a], [, b]) => Number(a.primary) - Number(b.primary)).map(([v]) => v);
+      if (typeof options[Build] === 'function') {
+        this.#build = options[Build].bind(options);
+      } else if (typeof build === 'function') {
+        this.#build = build.bind(options);
+      } else {
+        this.#build = null;
+      }
+    }
+  }
+  /**
+   * @param {QueryOptions<T, TB> | Query<T, TB>} options
+   * @returns {Query<T, TB>}
+   */
+  _create(options) {
+    return new Query(options);
+  }
+  /**
+   * @returns {ReturnType<this['_create']>}
+   */
+  clone() {
+    /** @type {ReturnType<this['_create']>} */
+    // @ts-ignore
+    const t = this._create(this);
+    return t;
+  }
+  /** @returns {this} */
+  deleted() {
+    this.#options.range = deleted;
+    return this;
+  }
+  /** @returns {this} */
+  undeleted() {
+    this.#options.range = undeleted;
+    return this;
+  }
+  /** @returns {this} */
+  withDeleted() {
+    this.#options.range = withDeleted;
+    return this;
+  }
+  /**
+   * 增加排序项
+   * @param {...string | boolean | [string, boolean?]} sort
+   * @returns {this}
+   */
+  sort(...sort) {
+    if (!sort.length) {
+      this.#options.sort = [];
+      return this;
+    }
+    /** @type {[string, boolean][]} */
+    const list = [];
+    for (let i = 0; i < sort.length; i++) {
+      let value = sort[i];
+      let desc = sort[i + 1] === true;
+      if (Array.isArray(value)) {
+        desc = value[1] === true;
+        [value] = value;
+      }
+      if (typeof value !== 'string') {
+        continue;
+      }
+      list.push([value, desc]);
+    }
+    if (list.length) {
+      this.#options.sort = [...(this.#options.sort || []), ...list];
+    }
+    return this;
+  }
+  /**
+   * 设置获取到的最大数量
+   * @param {number} [limit]
+   * @returns {this}
+   */
+  limit(limit) {
+    this.#options.limit = getInt(limit);
+    return this;
+  }
+  /**
+   * 跳过的记录数
+   * @param {number} [offset]
+   * @returns {this}
+   */
+  offset(offset) {
+    this.#options.offset = getInt(offset);
+    return this;
+  }
+  /**
+   * @overload
+   * @param {Wheres} matches
+   * @returns {this}
+   */
+  /**
+   *
+   * @overload
+   * @param {TemplateStringsArray} where
+   * @param  {...any} values
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {any} value
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {any[]} value
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string} field
+   * @param {string} operator
+   * @param {any} value
+   * @param {boolean} [not]
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {string[]} field
+   * @param {string} operator
+   * @param {any[]} value
+   * @param {boolean} [not]
+   * @returns {this}
+   */
+  /**
+   * @overload
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {this}
+   */
+  /**
+   * @param {[Wheres] | [TemplateStringsArray, ...any] | [string | string[], any] | [string | string[], string, any, boolean?]} items
+   * @returns {this}
+   */
+  where(...items) {
+    const list = Where.parseParams(items);
+    this.#options.where = [...this.#options.where, ...(list || [])];
+    return this;
+  }
+  /**
+   * 选择字段
+   * @param {...string | string[] | Record<string, Select.Param>} newSelect
+   * @returns {this}
+   */
+  select(...newSelect) {
+    const select = {
+      ...this.#options.select
+    };
+    for (let s of newSelect.flat()) {
+      if (!s) {
+        continue;
+      }
+      if (typeof s === 'string') {
+        select[s] = {
+          field: s
+        };
+        continue;
+      }
+      if (typeof s !== 'object') {
+        continue;
+      }
+      for (let [k, v] of Object.entries(s)) {
+        if (!v) {
+          delete select[k];
+        } else if (typeof v === 'string') {
+          select[k] = {
+            field: v
+          };
+        } else if (typeof v === 'object') {
+          const {
+            field,
+            table,
+            fn
+          } = v;
+          if (typeof field !== 'string') {
+            continue;
+          }
+          select[k] = {
+            field,
+            table: typeof table === 'string' ? table : '',
+            fn: typeof fn === 'string' ? fn : ''
+          };
+        } else {
+          select[k] = {
+            field: k
+          };
+        }
+      }
+    }
+    this.#options.select = select;
+    return this;
+  }
+  /**
+   * 字段求和
+   * @param {...string | string[] | Record<string, string>} newSelect
+   * @returns {this}
+   */
+  sum(...newSelect) {
+    const select = {
+      ...this.#options.select
+    };
+    this.#options.select = selectFn('sum', select, newSelect);
+    return this;
+  }
+  /**
+   * 字段最小值
+   * @param {...string | string[] | Record<string, string>} newSelect
+   * @returns {this}
+   */
+  min(...newSelect) {
+    const select = {
+      ...this.#options.select
+    };
+    this.#options.select = selectFn('min', select, newSelect);
+    return this;
+  }
+  /**
+   * 字段最大值
+   * @param {...string | string[] | Record<string, string>} newSelect
+   * @returns {this}
+   */
+  max(...newSelect) {
+    const select = {
+      ...this.#options.select
+    };
+    this.#options.select = selectFn('max', select, newSelect);
+    return this;
+  }
+  /**
+   * 字段平均值
+   * @param {...string | string[] | Record<string, string>} newSelect
+   * @returns {this}
+   */
+  avg(...newSelect) {
+    const select = {
+      ...this.#options.select
+    };
+    this.#options.select = selectFn('max', select, newSelect);
+    return this;
+  }
+  /**
+   * 字段计数
+   * @param {...string | string[] | Record<string, string>} newSelect
+   * @returns {this}
+   */
+  count(...newSelect) {
+    const select = {
+      ...this.#options.select
+    };
+    this.#options.select = selectFn('max', select, newSelect);
+    return this;
+  }
+  /**
+   *
+   * @param {Record<string, any>} update
+   * @returns {this}
+   */
+  set(update) {
+    this.#options.update = {
+      ...this.#options.update,
+      ...update
+    };
+    return this;
+  }
+  /**
+   *
+   * @param {string} alias
+   * @returns
+   */
+  as(alias) {
+    const t = this.clone();
+    t.#options.alias = alias;
+    return t;
+  }
+  /**
+   *
+   * @param {object} a
+   * @param {object | boolean | null} [b]
+   * @returns {TB}
+   */
+  [Build](a, b) {
+    const build = this.#build;
+    if (typeof build === 'function') {
+      return build(a, b);
+    }
+    if (b && typeof b === 'object') {
+      return {
+        ...a,
+        ...b
+      };
+    }
+    return {
+      ...a
+    };
+  }
+  /**
+   *
+   * @param {string} [text]
+   * @returns {this}
+   */
+  contains(text) {
+    if (!text) {
+      return this;
+    }
+    const fields = [];
+    for (const [name, {
+      text,
+      type,
+      array
+    }] of Object.entries(this.fields)) {
+      if (!text || array) {
+        continue;
+      }
+      if (type !== 'text') {
+        continue;
+      }
+      fields.push(name);
+    }
+    if (!fields) {
+      return this;
+    }
+    /** @type {WhereValue[]} */
+    const matches = fields.map(v => ({
+      field: v,
+      operator: 'contains',
+      value: text
+    }));
+    this.#options.where = [...this.#options.where, ...matches];
+    return this;
+  }
+  /** @type {string | number | bigint | object | undefined} */
+  #primary;
+  /**
+   * @param {any} [primary]
+   * @returns {this}
+   */
+  primary(primary) {
+    if (this.#primary) {
+      return this;
+    }
+    if (!primary) {
+      return this;
+    }
+    const primaryFields = this.#primaryFields;
+    if (!primaryFields.length) {
+      return this;
+    }
+    if (primaryFields.length === 1) {
+      const [field] = primaryFields;
+      const m = this.where(field, '=', primary);
+      m.#primary = primary;
+      return m;
+    }
+    if (typeof primary === 'object') {
+      let m = this;
+      for (const p of primaryFields) {
+        m = m.where(p, '=', primary[p]);
+      }
+      m.#primary = primary;
+      return m;
+    }
+    const values = `${primary}`.split('$');
+    if (values.length !== primaryFields.length) ;
+    let m = this;
+    for (let i = 0; i < primaryFields.length; i++) {
+      m = m.where(primaryFields[i], '=', values[i]);
+    }
+    m.#primary = primary;
+    return m;
+  }
+}
+
+/* eslint-disable max-lines */
+/** @import { Fields, IndexInfo, FieldDefine } from './types' */
+/**
+ * @param {any} a
+ * @param {any} b
+ */
+function eq(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (!Array.isArray(a) || !Array.isArray(b)) {
+    return false;
+  }
+  if (a.length !== b.length) {
+    return;
+  }
+  const {
+    length
+  } = a;
+  for (let i = 0; i < length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+/** @typedef {PromiseLike<void> | void} VoidReturn */
+const timeRegex = /^(?: *|T?)(\d+)(?::(\d+)(?::(\d+(?:.\d*)?))?)? *$/;
+/**
+ * @param {string} type
+ * @param {any} value
+ */
+function getBaseValue(type, value) {
+  // TODO: 类型完善
+  switch (type) {
+    case 'i8':
+    case 'i16':
+    case 'i32':
+    case 'i52':
+    case 'u8':
+    case 'u16':
+    case 'u32':
+    case 'u52':
+      {
+        let v = value;
+        if (typeof v === 'string') {
+          v = parseInt(v, 10);
+        } else if (typeof v === 'bigint' || typeof v === 'boolean') {
+          v = Number(v);
+        } else if (typeof v !== 'number') {
+          return;
+        }
+        v = Math.floor(v);
+        if (Number.isNaN(v)) {
+          return;
+        }
+        return v;
+      }
+    case 'i64':
+    case 'u64':
+      {
+        let v = value;
+        if (typeof v === 'string') {
+          const r = /^(-?\d+)/.exec(v);
+          if (!r) {
+            return;
+          }
+          v = BigInt(r[1]);
+        } else if (typeof v === 'boolean') {
+          v = BigInt(v);
+        } else if (typeof v === 'number') {
+          if (Number.isNaN(v)) {
+            return;
+          }
+          v = BigInt(Math.floor(v));
+        } else if (typeof v !== 'bigint') {
+          return;
+        }
+        return v;
+      }
+    case 'id':
+      {
+        let v = value;
+        if (typeof v === 'string') {
+          const r = /^(-?\d+)/.exec(v);
+          if (!r) {
+            return;
+          }
+          v = BigInt(r[1]);
+        } else if (typeof v === 'boolean') {
+          v = BigInt(v);
+        } else if (typeof v === 'number') {
+          if (Number.isNaN(v)) {
+            return;
+          }
+          v = BigInt(Math.floor(v));
+        } else if (typeof v !== 'bigint') {
+          return;
+        }
+        return v;
+      }
+    case 'f32':
+    case 'f64':
+    case 'decimal':
+    case 'numeric':
+    case 'money':
+      {
+        let v = value;
+        if (typeof v === 'string') {
+          v = parseFloat(v);
+        } else if (typeof v === 'bigint' || typeof v === 'boolean') {
+          v = Number(v);
+        } else if (typeof v !== 'number') {
+          return;
+        }
+        if (Number.isNaN(v)) {
+          return;
+        }
+        return v;
+      }
+    case 'date':
+    case 'datetime':
+    case 'timestamp':
+      {
+        let v = value;
+        if (typeof v === 'string') {
+          v = new Date(Date.parse(v));
+        } else if (typeof v === 'bigint' || typeof v === 'number') {
+          v = new Date(Number(v));
+        } else if (!(v instanceof Date)) {
+          return;
+        }
+        if (Number.isNaN(Number(v))) {
+          return;
+        }
+        return v;
+      }
+    case 'time':
+    case 'timetz':
+      {
+        let v = value;
+        if (typeof v === 'string') {
+          const r = timeRegex.exec(v);
+          if (!r) {
+            return;
+          }
+          const t = new Date();
+          t.setHours(parseFloat(r[1]), Number(r[2]) || 0, parseFloat(r[3]) || 0);
+          return t;
+        } else if (typeof v === 'bigint' || typeof v === 'number') {
+          v = new Date(Number(v));
+        } else if (!(v instanceof Date)) {
+          return;
+        }
+        if (Number.isNaN(Number(v))) {
+          return;
+        }
+        return v;
+      }
+  }
+  return value;
+}
+/**
+ * @param {string} type
+ * @param {boolean} array
+ * @param {any} [value]
+ * @param {boolean} [isSet]
+ */
+function getBaseTypeValue(type, array, value, isSet) {
+  if (array) {
+    // TODO: 是否允许空
+    return [value].flatMap(v => getBaseValue(type, v)).filter(v => v !== undefined);
+  }
+  const val = getBaseValue(type, value);
+  // TODO: 是否允许空
+  if (typeof val !== undefined) {
+    return val;
+  }
+  if (isSet) {
+    return val;
+  }
+  // TODO: 默认值
+  return value;
+}
+/**
+ * @param {FieldDefine} field
+ * @param {any} value
+ */
+function getInitValue(field, value) {
+  const {
+    type
+  } = field;
+  if (typeof type === 'string') {
+    return getBaseTypeValue(type, field.array, value, true);
+  }
+  if (!type.table) {
+    return getBaseTypeValue('object', field.array, value, true);
+  }
+  const {
+    constraints
+  } = field;
+  const values = [value].flat().filter(Boolean);
+  if (!values.length) {
+    return [];
+  }
+  const constraintEntries = Object.entries(constraints || {});
+  const noField = constraintEntries.find(([k, v]) => v.noField)?.[0];
+  const keys = new Set(constraintEntries.filter(([k, v]) => v.field || v.value !== undefined).map(([k]) => k));
+  const {
+    fields
+  } = type;
+  if (noField) {
+    keys.add(noField);
+  }
+  return values.map(data => {
+    const doc = {};
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    const values = data instanceof Model ? data.$savedData : data;
+    for (const [key, field] of Object.entries(fields)) {
+      if (keys.has(key)) {
+        continue;
+      }
+      const {
+        type
+      } = field;
+      if (typeof type === 'string') {
+        doc[key] = getBaseTypeValue(type, field.array, values[key]);
+      } else if (!type.table) {
+        doc[key] = getBaseTypeValue('object', field.array, values[key]);
+      }
+    }
+    return doc;
+  });
+}
+/**
+ * @param {FieldDefine} field
+ * @param {any} value
+ * @param {boolean} [immutable]
+ */
+function getSetValue(field, value, immutable) {
+  if (immutable && field.immutable) {
+    return;
+  }
+  const {
+    type
+  } = field;
+  if (typeof type === 'string') {
+    if (immutable && field.primary) {
+      return;
+    }
+    return getBaseTypeValue(type, field.array, value, true);
+  }
+  if (!type.table) {
+    return getBaseTypeValue('object', field.array, value, true);
+  }
+  const values = [value].flat().filter(Boolean);
+  if (!values.length) {
+    return [];
+  }
+  const constraintEntries = Object.entries(field.constraints || {});
+  const noField = constraintEntries.find(([k, v]) => v.noField)?.[0];
+  const {
+    fields
+  } = type;
+  const keys = new Set(constraintEntries.filter(([k, v]) => v.field || v.value !== undefined).map(([k]) => k));
+  if (noField) {
+    keys.add(noField);
+  }
+  return values.map(data => {
+    const doc = {};
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    const values = data instanceof Model ? data.$savedData : data;
+    for (const [key, field] of Object.entries(fields)) {
+      if (keys.has(key)) {
+        continue;
+      }
+      let value = values[key];
+      if (value === undefined) {
+        continue;
+      }
+      const {
+        type
+      } = field;
+      if (typeof type === 'string') {
+        if (typeof type !== 'string') {
+          continue;
+        }
+        value = getBaseTypeValue(type, field.array, value);
+        if (value === undefined) {
+          continue;
+        }
+        doc[key] = value;
+      } else if (!type.table) {
+        if (typeof type !== 'string') {
+          continue;
+        }
+        // TODO:
+        value = getBaseTypeValue('object', field.array, value);
+        if (value === undefined) {
+          continue;
+        }
+        doc[key] = value;
+      }
+    }
+    return doc;
+  });
+}
+/**
+ * @implements {Save}
+ * @implements {Destroy}
+ * @implements {PseudoDestroy}
+ */
+class Model {
+  /** @readonly @type {string | undefined} */
+
+  /** @readonly @type {string} */
+  static table = '';
+  /** @readonly @type {Fields} */
+  static fields = {};
+  /** @readonly @type {readonly IndexInfo[]} */
+  static indexes = [];
+  /**
+   * @template {typeof Model} T
+   * @this {T}
+   * @returns {Query<T['fields'], InstanceType<T>>}
+   */
+  static toQuery() {
+    // @ts-ignore
+    return new Query(this);
+  }
+  /**
+   * @template {typeof Model} T
+   * @this {T}
+   * @param {string[]} [fields]
+   * @returns {T}
+   */
+  static bindFields(fields = Object.keys(this.fields)) {
+    const {
+      prototype
+    } = this;
+    /** @type {string[]} */
+    const list = Array.isArray(fields) ? fields : Object.keys(fields);
+    for (const key of list) {
+      if (!key || typeof key === 'string' && key[0] === '$') {
+        continue;
+      }
+      if (key in prototype) {
+        continue;
+      }
+      Object.defineProperty(prototype, key, {
+        get() {
+          return this.$get(key);
+        },
+        set(value) {
+          this.$set(key, value);
+        },
+        configurable: true,
+        enumerable: true
+      });
+    }
+    return this;
+  }
+  /**
+   * @template {typeof Model} T
+   * @this {T}
+   * @param {Connection} t
+   * @param {object} p
+   * @param {(data: object) => Promise<object>} run
+   * @returns {Promise<InstanceType<T>>}
+   */
+  static async [Create](t, p, run) {
+    const Mod = this;
+    /** @type {InstanceType<T>} */
+    // @ts-ignore
+    const doc = new Mod(p);
+    return doc.#do(() => doc.$_onBeforeSave(t, false), () => run({
+      ...doc.#data,
+      ...doc.#newData
+    }), () => doc.$_onAfterSave(t, false)).then(() => doc);
+  }
+  /**
+   * @template {typeof Model} T
+   * @this {T}
+   * @param {object} a
+   * @param {object | boolean} [b]
+   * @returns {InstanceType<T>}
+   */
+  static [Build](a, b) {
+    const Mod = this;
+    /** @type {InstanceType<T>} */
+    // @ts-ignore
+    const doc = new Mod(a, b);
+    return doc;
+  }
+  /** @type {typeof Model} */
+  #model;
+  /** @type {Record<string, any>} */
+  #data = {};
+  /** @type {Record<string, any>} */
+  #newData = {};
+  #saved = false;
+  #deleted = false;
+  #executing = false;
+  /** @type {Record<string, any> | undefined} */
+  #oldData;
+  get $model() {
+    return this.#model;
+  }
+  get $saved() {
+    return this.#saved;
+  }
+  get $deleted() {
+    return this.#deleted;
+  }
+  get $oldData() {
+    return this.#oldData;
+  }
+  get $savedData() {
+    return {
+      ...this.#data
+    };
+  }
+  get $changedData() {
+    return {
+      ...this.#newData
+    };
+  }
+  /**
+   * @param {object} data
+   * @param {boolean | object} [saved]
+   */
+  constructor(data, saved = false) {
+    const model = new.target;
+    this.#model = model;
+    const {
+      fields
+    } = model;
+    const values = {};
+    for (const [key, field] of Object.entries(fields)) {
+      const {
+        type
+      } = field;
+      // eslint-disable-next-line no-nested-ternary
+      values[key] = typeof type === 'string' ? getBaseTypeValue(type, field.array)
+      // eslint-disable-next-line no-nested-ternary
+      : !type.table ? getBaseTypeValue('object', field.array) : field.array ? [] : null;
+    }
+    if (!saved) {
+      this.#data = values;
+      this.#saved = false;
+      this.#setAll(data);
+      return;
+    }
+    for (const [key, value] of Object.entries(data)) {
+      const field = key in fields && fields[key];
+      const val = field ? getInitValue(field, value) : value;
+      if (val === undefined) {
+        continue;
+      }
+      values[key] = val;
+    }
+    this.#data = values;
+    this.#oldData = data;
+    this.#saved = true;
+    if (typeof saved !== 'object') {
+      return;
+    }
+    this.#setAll(saved);
+  }
+  $clone() {
+    const Model = this.#model;
+    const saved = this.$saved;
+    if (!saved) {
+      return new Model({
+        ...this.#newData
+      });
+    }
+    return new Model({
+      ...this.#data
+    }, {
+      ...this.#newData
+    });
+  }
+  toJSON() {
+    return {
+      ...this.#data,
+      ...this.#newData
+    };
+  }
+  get $fieldChanged() {
+    const changed = new Set(Object.getOwnPropertyNames(this.#newData));
+    if (!changed.size) {
+      return false;
+    }
+    const fields = Object.getOwnPropertyNames(this.#model.fields);
+    return fields.findIndex(f => changed.has(f)) >= 0;
+  }
+  /**
+   * @param {Record<string, any>} values
+   */
+  #setAll(values) {
+    const data = this.#data;
+    const newData = this.#newData;
+    const model = this.#model;
+    const {
+      fields
+    } = model;
+    const isSaved = this.#saved;
+    for (const [key, value] of Object.entries(values)) {
+      const field = key in fields && fields[key];
+      const val = field ? getSetValue(field, value, isSaved) : value;
+      if (val === undefined) {
+        continue;
+      }
+      if (eq(data[key], val)) {
+        delete newData[key];
+      } else {
+        newData[key] = val;
+      }
+    }
+  }
+  /**
+   * @param {string} key
+   * @param {any} value
+   */
+  #set(key, value) {
+    const model = this.#model;
+    const {
+      fields
+    } = model;
+    const field = key in fields && fields[key];
+    const val = field ? getSetValue(field, value, this.#saved) : value;
+    if (val === undefined) {
+      return;
+    }
+    if (eq(this.#data[key], val)) {
+      delete this.#newData[key];
+    } else {
+      this.#newData[key] = val;
+    }
+  }
+  /**
+   * @overload
+   * @param {Record<string, any>} key
+   * @param {any} [value]
+   * @returns {boolean}
+   */
+  /**
+   * @overload
+   * @param {string} key
+   * @param {any} value
+   * @returns {boolean}
+   */
+  /**
+   * @param {string | Record<string, any>} key
+   * @param {any} [value]
+   * @returns {boolean}
+   */
+  $set(key, value) {
+    if (!key) {
+      return false;
+    }
+    if (this.#executing) {
+      return false;
+    }
+    this.#executing = true;
+    try {
+      if (typeof key !== 'object') {
+        this.#set(key, value);
+        return true;
+      }
+      this.#setAll(key);
+      return true;
+    } finally {
+      this.#executing = false;
+    }
+  }
+  /**
+   * @template {Record<string, any>} T
+   * @overload
+   * @param {string} [key]
+   * @param {boolean} [saved]
+   * @returns {T}
+   */
+  /**
+   * @template T
+   * @overload
+   * @param {string} key
+   * @param {boolean} [saved]
+   * @returns {T | undefined}
+   */
+  /**
+   * @template T
+   * @param {string} [key]
+   * @param {boolean} [saved]
+   * @returns {any}
+   */
+  $get(key, saved) {
+    if (!key) {
+      return {
+        ...this.#data,
+        ...this.#newData
+      };
+    }
+    if (!saved && key in this.#newData) {
+      return this.#newData[key];
+    }
+    if (saved !== false) {
+      return this.#data[key];
+    }
+  }
+  /**
+   * @param {(this: this)=> PromiseLike<boolean> | boolean} q
+   * @returns {PromiseLike<boolean> | boolean}
+   */
+  $exec(q) {
+    if (this.#executing) {
+      return false;
+    }
+    this.#executing = true;
+    return (async () => {
+      try {
+        return await q.call(this);
+      } finally {
+        this.#executing = false;
+      }
+    })();
+  }
+  /**
+   * @param {Connection} t
+   * @param {boolean} update
+   * @returns {VoidReturn}
+   */
+  $onBeforeSave(t, update) {}
+  /**
+   * @param {Connection} t
+   * @param {boolean} update
+   * @returns {VoidReturn}
+   */
+  $onAfterSave(t, update) {}
+  /**
+   * @param {Connection} t
+   * @param {boolean} update
+   * @returns {VoidReturn}
+   */
+  $_onBeforeSave(t, update) {
+    return this.$onBeforeSave(t, update);
+  }
+  /**
+   * @param {Connection} t
+   * @param {boolean} update
+   * @returns {VoidReturn}
+   */
+  $_onAfterSave(t, update) {
+    return this.$onAfterSave(t, update);
+  }
+  /**
+   * @param {Connection} t
+   * @param {object?} update
+   * @returns {VoidReturn}
+   */
+  $onBeforeDelete(t, update) {}
+  /**
+   * @param {Connection} t
+   * @param {object?} update
+   * @returns {VoidReturn}
+   */
+  $onAfterDelete(t, update) {}
+  /**
+   * @param {Connection} t
+   * @param {object?} update
+   * @returns {VoidReturn}
+   */
+  $_onBeforeDelete(t, update) {
+    return this.$onBeforeDelete(t, update);
+  }
+  /**
+   * @param {Connection} t
+   * @param {object?} update
+   * @returns {VoidReturn}
+   */
+  $_onAfterDelete(t, update) {
+    return this.$onAfterDelete(t, update);
+  }
+  #running = false;
+  /**
+   * @param {() => any} before
+   * @param {() => Promise<object?>} q
+   * @param {() => any} after
+   * @returns {Promise<this?>}
+   */
+  async #do(before, q, after) {
+    if (this.#running) {
+      return null;
+    }
+    this.#running = true;
+    try {
+      await before();
+      const r = await this.$exec(() => q().then(v => this.#update(v)));
+      if (!r) {
+        return null;
+      }
+      await after();
+      return this;
+    } finally {
+      this.#running = false;
+    }
+  }
+  /**
+   * @param {any} [values]
+   * @returns {boolean}
+   */
+  #update(values) {
+    if (this.#deleted) {
+      return false;
+    }
+    if (!values) {
+      return false;
+    }
+    const oldData = this.#data;
+    this.#oldData = oldData;
+    this.#data = {
+      ...oldData,
+      ...values
+    };
+    const {
+      fields
+    } = this.#model;
+    this.#newData = Object.fromEntries(Object.entries(this.#newData).filter(([k]) => !(k in fields)));
+    this.#saved = true;
+    return true;
+  }
+  /**
+   * @param {Connection} t
+   * @param {(data: any, newData?: any) => Promise<object?>} run
+   * @returns {Promise<this?>}
+   */
+  async [Save](t, run) {
+    const update = this.#saved;
+    return this.#do(() => this.$_onBeforeSave(t, update), () => update ? run(this.#data, this.#newData) : run({
+      ...this.#data,
+      ...this.#newData
+    }), () => this.$_onAfterSave(t, update));
+  }
+  /**
+   * @param {Connection} t
+   * @param {(data: any) => Promise<object?>} run
+   * @returns {Promise<this?>}
+   */
+  async [Destroy](t, run) {
+    if (this.#deleted) {
+      return null;
+    }
+    return this.#do(() => this.$_onBeforeDelete(t, null), () => run(this.#data).then(v => {
+      this.#deleted = Boolean(v);
+      return v;
+    }), () => this.$_onAfterDelete(t, null));
+  }
+  /**
+   * @param {Connection} t
+   * @param {object} update
+   * @param {(data: any) => Promise<object?>} run
+   * @returns {Promise<this?>}
+   */
+  async [PseudoDestroy](t, update, run) {
+    if (this.#deleted) {
+      return null;
+    }
+    return this.#do(() => this.$_onBeforeDelete(t, update), () => run(this.#data), () => this.$_onAfterDelete(t, update));
+  }
+}
+/**
+ * @param {string} key
+ * @param {(this: typeof Model) => any} get
+ * @returns {void}
+ */
+function defGetter$1(key, get) {
+  Object.defineProperty(Model, key, {
+    get,
+    enumerable: true,
+    configurable: true
+  });
+}
+defGetter$1('table', function () {
+  return this.name;
+});
+defGetter$1('fields', function () {
+  return [];
+});
+defGetter$1('indexes', function () {
+  return [];
+});
+
+/** @import { FieldDefine, FieldType, IndexInfo } from './types' */
+class Submodel {
+  #type = Submodel;
+  /** @readonly @type {string} */
+  static table = '';
+  /** @readonly @type {Record<string, FieldDefine<keyof FieldType>>} */
+  static fields = {};
+  /** @readonly @type {readonly IndexInfo[]} */
+  static indexes = [];
+}
+/**
+ * @param {string} key
+ * @param {(this: typeof Submodel) => any} get
+ * @returns {void}
+ */
+function defGetter(key, get) {
+  Object.defineProperty(Submodel, key, {
+    get,
+    enumerable: true,
+    configurable: true
+  });
+}
+defGetter('table', function () {
+  return this.name;
+});
+defGetter('fields', function () {
+  return [];
+});
+defGetter('indexes', function () {
+  return [];
+});
+
+/** @import { FieldDefine, FieldDefineOption, MainFieldType, ToType } from './types' */
+/**
+ * @template {MainFieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array?: false;
+ * 	default?: ToType<T, false, false>;
+ * } & FieldDefineOption} [options]
+ * @returns {FieldDefine<T, false, false>}
+ */
+/**
+ * @template {MainFieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array: true;
+ * 	default?: ToType<T, true, false>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, true, false>}
+ */
+/**
+ * @template {MainFieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array?: false;
+ * 	default?: ToType<T, false, true>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, false, true>}
+ */
+/**
+ * @template {MainFieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array: true;
+ * 	default?: ToType<T, true, true>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, true, true>}
+ */
+/**
+ * @template {MainFieldType} T
+ * @template {boolean} A
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: true;
+ * 	array: A;
+ * 	default?: ToType<T, A, true>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, A, true>}
+ */
+/**
+ * @template {MainFieldType} T
+ * @template {boolean} A
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: false;
+ * 	array: A;
+ * 	default?: ToType<T, A, false>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, A, false>}
+ */
+/**
+ * @template {MainFieldType} T
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array?: false;
+ * 	default?: ToType<T, false, N>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, false, N>}
+ */
+/**
+ * @template {MainFieldType} T
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array: true;
+ * 	default?: ToType<T, true, N>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, true, N>}
+ */
+/**
+ * @template {MainFieldType} T
+ * @template {boolean} A
+ * @template {boolean} N
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable: N;
+ * 	array: A;
+ * 	default?: ToType<T, A, N>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, A, N>}
+ */
+/**
+ * @template {MainFieldType} T
+ * @overload
+ * @param {T} type
+ * @param {{
+ * 	nullable?: boolean;
+ * 	array?: boolean;
+ * 	default?: ToType<T, boolean, boolean>;
+ * } & FieldDefineOption} options
+ * @returns {FieldDefine<T, boolean, boolean>}
+ */
+/**
+ * @template {MainFieldType} T
+ * @param {T} type
+ * @param {{ nullable?: boolean; array?: boolean; default?: any; } & FieldDefineOption} options
+ * @returns {FieldDefine<T, boolean, boolean>}
+ */
+function field(type, {
+  array,
+  nullable,
+  default: def,
+  index,
+  primary,
+  serial,
+  immutable,
+  text,
+  sort,
+  ...p
+} = {}) {
+  return {
+    ...p,
+    type,
+    array: Boolean(array),
+    nullable: Boolean(nullable),
+    default: def,
+    index,
+    primary,
+    serial,
+    immutable,
+    text,
+    sort
+  };
+}
+
+export { Build, Connection, Create, Destroy, Model, PseudoDestroy, Query, Save, Submodel, Where, creating, decrement, field as define, deleted, deleting, divide, field$1 as field, getPrimaryKeys, id, immutable, increment, index, isDevelopment, isPseudo, submodel as model, multiply, now, primary, prop, pseudo, setDevelopment, sort, submodel, toNot, undeleted, updating, values, withDeleted };