imodel 0.3.0 → 0.4.0

package/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.3.0
+ * imodel v0.4.0
  * (c) 2019-2025 undefined
  * @license undefined
  */
@@ -52,6 +52,7 @@ function isPseudo(model) {
 }
 
 const now = Symbol();
+const uuid = Symbol();
 const increment$1 = Symbol();
 const decrement$1 = Symbol();
 const multiply$1 = Symbol();
@@ -63,38 +64,10 @@ var values = /*#__PURE__*/Object.freeze({
     divide: divide$1,
     increment: increment$1,
     multiply: multiply$1,
-    now: now
+    now: now,
+    uuid: uuid
 });
 
-/** @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: 0
-      };
-    }
-  }
-  return allFields;
-}
-
 /** @import { Options, Queryable } from '../types' */
 /**
  *
@@ -162,81 +135,45 @@ async function getSpecificValue(val) {
   return value;
 }
 
-/** @import { SetValue } from '../../set.mjs' */
-/** @import { Fields, Skip } from '../../types' */
-/**
- *
- * @param {Fields} fields
- * @param {Record<string, SetValue> | null | undefined} [update]
- * @param {boolean | Skip} [skip]
- * @returns {Promise<Record<string, SetValue>>}
- */
-async function getSetNewValue(fields, update, skip) {
-  const data = {
-    ...update
-  };
-  if (!(skip === true || skip && skip.specific)) {
-    for (const [name, field] of Object.entries(fields)) {
-      if (field.primary) {
-        continue;
-      }
-      const updating = await getSpecificValue(field.updating);
-      if (updating !== void 0) {
-        data[name] = updating;
-      }
-    }
-  }
-  return Object.fromEntries(Object.entries(data).filter(([k, v]) => {
-    const field = k in fields && fields[k];
-    if (!field) {
-      return;
-    }
-    if (field.immutable) {
-      if (!skip) {
-        return;
-      }
-      if (skip !== true && !skip.immutable) {
-        return;
-      }
-    }
-    return true;
-  }));
-}
-
 /** @import { Fields } from '../../types' */
 /**
  *
  * @param {Record<string, any>} data
- * @param {Fields} fields
+ * @param {Fields} columns
+ * @param {Record<string, string> | null} fieldColumns
  * @returns {Promise<Record<string, any>>}
  */
-async function getInsertValue(data, fields) {
+async function getInsertValue(data, columns, fieldColumns) {
   const insertValue = {};
-  for (const [k, field] of Object.entries(fields)) {
-    const creating = await getSpecificValue(field.creating);
+  for (const [k, col] of fieldColumns ? Object.entries(fieldColumns) : Object.keys(columns).map(v => [v, v])) {
+    const column = columns[col];
+    if (!column) {
+      continue;
+    }
+    const creating = await getSpecificValue(column.creating);
     if (creating !== void 0) {
-      insertValue[k] = creating;
+      insertValue[col] = creating;
       continue;
     }
-    const updating = await getSpecificValue(field.updating);
+    const updating = await getSpecificValue(column.updating);
     if (updating !== void 0) {
-      insertValue[k] = updating;
+      insertValue[col] = updating;
       continue;
     }
     const val = data[k];
     if (val !== undefined) {
-      insertValue[k] = val;
+      insertValue[col] = val;
       continue;
     }
-    const def = field.default;
+    const def = column.default;
     if (def === undefined) {
       continue;
     }
     if (typeof def === 'function') {
-      insertValue[k] = def(data);
+      insertValue[col] = def(data);
       continue;
     }
-    insertValue[k] = def;
+    insertValue[col] = def;
   }
   return insertValue;
 }
@@ -288,58 +225,91 @@ function setDefaultOptions(v) {
   return v;
 }
 
+/**
+ *
+ * @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) {
+      // eslint-disable-next-line eqeqeq
+      if (sub[k] != v) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+
 /** @import { FieldDefine, Fields, FieldType, TableDefine } from '../../types' */
 /**
  *
  * @param {Fields} fields
- * @returns {[Fields<keyof FieldType>, [string, FieldDefine<TableDefine>][]]}
+ * @returns {[columns: Fields<keyof FieldType>, fieldColumns: Record<string, string> | null, [string, FieldDefine<TableDefine>][], baseFields: Fields<keyof FieldType>]}
  */
-function separateFields(fields) {
+function toColumns(fields) {
+  /** @type {Fields<keyof FieldType>} */
+  const baseFields = Object.create(null);
   /** @type {Fields<keyof FieldType>} */
-  const base = Object.create(null);
+  const columns = Object.create(null);
+  /** @type {Record<string, string>} */
+  const fieldColumns = Object.create(null);
+  let named = false;
   /** @type {[string, FieldDefine<TableDefine>][]} */
   const sub = [];
   for (const [k, v] of Object.entries(fields)) {
     const {
       type
     } = v;
+    if (!type) {
+      continue;
+    }
+    const column = v.column || k;
     if (typeof type === 'string') {
       // @ts-ignore
-      base[k] = v;
-    } else if (!type.table) {
-      base[k] = {
+      baseFields[k] = columns[column] = v;
+      fieldColumns[k] = column;
+      if (k !== column) {
+        named = true;
+      }
+      continue;
+    }
+    if (!type.table) {
+      baseFields[k] = columns[column] = {
         ...v,
         type: 'object',
         primary: 0
       };
-    } else {
-      // @ts-ignore
-      sub.push([k, v]);
+      fieldColumns[k] = column;
+      if (k !== column) {
+        named = true;
+      }
+      continue;
     }
+    // @ts-ignore
+    sub.push([k, v]);
   }
-  return [base, sub];
+  return [columns, named ? fieldColumns : null, sub, baseFields];
 }
 
 /**
  *
- * @param {*} item
- * @param {[string, string][]} mapList
- * @returns
+ * @param {Record<string, any>[]} list
+ * @param {Record<string, string>?} fieldColumns
  */
-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;
-  };
+function toFieldList(list, fieldColumns) {
+  if (!fieldColumns) {
+    return list;
+  }
+  const map = Object.entries(fieldColumns);
+  return list.map(it => Object.fromEntries(map.map(([k, v]) => [k, it[v]])));
 }
 
-/** @import { Environment, FieldDefine, Fields, GetName, IConnection, TableDefine } from '../types' */
+/** @import { Environment, FieldDefine, Fields, IConnection, TableDefine } from '../types' */
 /**
  *
  * @param {any} p
@@ -447,13 +417,13 @@ async function createSub(conn, env, fields, newList, list) {
       }
       continue;
     }
-    const [baseFields, tableFields] = separateFields(fields);
-    const insertKeys = Object.entries(baseFields).map(v => v[0]);
-    const insertValues = await Promise.all(fieldValues.map(d => getInsertValue(d, fields)));
+    const [columns, fieldColumns, tableFields] = toColumns(fields);
+    const insertKeys = Object.entries(columns).map(v => v[0]);
+    const insertValues = await Promise.all(fieldValues.map(d => getInsertValue(d, columns, fieldColumns)));
     const {
       table
     } = type;
-    const result = table && typeof table === 'object' ? table.insert(env, conn, '', baseFields, insertValues, insertKeys) : conn.insert(env, table || '', baseFields, insertValues, insertKeys);
+    const result = (table && typeof table === 'object' ? table.insert(env, conn, columns, insertValues, insertKeys) : conn.insert(env, table || '', columns, insertValues, insertKeys)).then(r => toFieldList(r, fieldColumns));
     promises.push(result.then(r => createSub(conn, env, tableFields, fieldValues, r)));
     promises.push(array ? result.then(values => {
       for (const [value] of allList) {
@@ -498,16 +468,16 @@ async function create(conn, env, model, p, mapDo = defaultMap) {
     }
     records.push(data);
   }
-  const [baseFields, tableFields] = separateFields(fields);
-  const insertValues = await Promise.all(records.map(d => getInsertValue(d, baseFields)));
+  const [columns, fieldColumns, tableFields] = toColumns(fields);
+  const insertValues = await Promise.all(records.map(d => getInsertValue(d, columns, fieldColumns)));
   let insertKeys = [];
   if (!insertKeys.length && !isArray) {
-    insertKeys = Object.entries(insertValues[0]).filter(([k, v]) => v !== undefined && k in baseFields).map(([k]) => k);
+    insertKeys = Object.entries(insertValues[0]).filter(([k, v]) => v !== undefined && k in columns).map(([k]) => k);
   }
   if (!insertKeys.length) {
-    insertKeys = Object.entries(baseFields).map(([k]) => k);
+    insertKeys = Object.entries(columns).map(([k]) => k);
   }
-  const list = table && typeof table === 'object' ? await table.insert(env, conn, '', baseFields, insertValues, insertKeys) : await conn.insert(env, table || '', baseFields, insertValues, insertKeys);
+  const list = toFieldList(table && typeof table === 'object' ? await table.insert(env, conn, columns, insertValues, insertKeys) : await conn.insert(env, table || '', columns, insertValues, insertKeys), fieldColumns);
   await createSub(conn, env, tableFields, records, list);
   const value = list.map((v, i) => mapDo(v, getOtherValues(records[i], fields)));
   return isArray ? value : value[0];
@@ -516,12 +486,12 @@ async function create(conn, env, model, p, mapDo = defaultMap) {
 /** @import { Fields } from './types' */
 /**
  *
- * @param {Fields} fields
+ * @param {Fields} fieldsOrColumns
  * @returns {string[]}
  */
-function getPrimaryKeys(fields) {
-  const list = Object.entries(fields);
-  const primaryKeys = list.filter(([v, o]) => typeof o.type === 'string' && o.primary);
+function getPrimaryKeys(fieldsOrColumns) {
+  const list = Object.entries(fieldsOrColumns);
+  const primaryKeys = list.filter(([v, o]) => o.type && typeof o.type === 'string' && o.primary);
   if (primaryKeys.length) {
     return primaryKeys.map(([k]) => k);
   }
@@ -530,8 +500,8 @@ function getPrimaryKeys(fields) {
 
 /** @import { Constraint, Fields, FieldType } from '../../types' */
 /**
- * @param {Fields<keyof FieldType>} fields
- * @param {Fields<keyof FieldType>} parentFields
+ * @param {Fields} fields
+ * @param {Set<string>} parentFields
  * @param {Record<string, string | Constraint> | undefined} constraints
  * @returns {[string, string][]?}
  */
@@ -549,7 +519,7 @@ function getMapList(fields, parentFields, constraints) {
     if (typeof field !== 'string') {
       continue;
     }
-    if (!(field in parentFields)) {
+    if (!parentFields.has(field)) {
       continue;
     }
     where.push([k, field]);
@@ -564,17 +534,17 @@ function getMapList(fields, parentFields, constraints) {
 /**
  *
  * @param {Record<string, Constraint> | undefined} value
- * @param {Fields<keyof FieldType>} fields
+ * @param {Fields<keyof FieldType>} columns
  * @returns {[string, unknown][]}
  */
-function getValueEntries(value, fields) {
+function getValueEntries(value, columns) {
   if (!value) {
     return [];
   }
   /** @type {[string, unknown][]} */
   const where = [];
   for (const [k, v] of Object.entries(value)) {
-    if (!(k in fields)) {
+    if (!(k in columns)) {
       continue;
     }
     if (!v || typeof v !== 'object') {
@@ -620,18 +590,68 @@ function valueEntries2where(value) {
   }));
 }
 
-/** @import { Environment, FieldDefine, Fields, FieldType, GetName, IConnection, MatchArg, Queryable, TableDefine } from '../types' */
+/** @import { WhereValue } from '../../Where.mjs' */
+/**
+ *
+ * @param {WhereValue['field']} field
+ * @param {Record<string, string>} fieldColumns
+ * @returns {WhereValue['field']}
+ */
+function field$2(field, fieldColumns) {
+  if (!field) {
+    return field;
+  }
+  if (!Array.isArray(field)) {
+    if (typeof field === 'string') {
+      return fieldColumns[field];
+    }
+    return {
+      ...field,
+      field: fieldColumns[field.field]
+    };
+  }
+  return field.map(field => {
+    if (typeof field === 'string') {
+      return fieldColumns[field];
+    }
+    return {
+      ...field,
+      field: fieldColumns[field.field]
+    };
+  });
+}
+/**
+ *
+ * @param {WhereValue[] | null | undefined} where
+ * @param {Record<string, string>?} fieldColumns
+ * @returns {WhereValue[]}
+ */
+function where2column(where, fieldColumns) {
+  if (!where) {
+    return [];
+  }
+  if (!fieldColumns) {
+    return where;
+  }
+  // @ts-ignore
+  return where.map(v => ({
+    ...v,
+    field: field$2(v.field, fieldColumns)
+  }));
+}
+
+/** @import { Environment, FieldDefine, IConnection, Queryable, TableDefine } from '../types' */
 /**
  *
  * @param {IConnection} conn
  * @param {any[]} list
  * @param {[string, FieldDefine<TableDefine>][]} fields
- * @param {Fields<keyof FieldType>} baseFields
+ * @param {Set<string>} baseFieldSet
  * @param {Environment} env
  * @param {boolean} [hasResult]
  * @returns
  */
-async function deleteSub(conn, list, fields, baseFields, env, hasResult) {
+async function deleteSub(conn, list, fields, baseFieldSet, env, hasResult) {
   if (!list.length) {
     return list;
   }
@@ -646,29 +666,25 @@ async function deleteSub(conn, list, fields, baseFields, env, hasResult) {
     const {
       fields
     } = type;
-    const [subfields, tableFields] = separateFields(fields);
-    const mapList = getMapList(subfields, baseFields, constraints);
+    const [columns, fieldColumns, tableFields] = toColumns(fields);
+    const mapList = getMapList(fields, baseFieldSet, constraints);
     if (!mapList) {
       continue;
     }
-    const value = getValueEntries(constraints, subfields);
-    const where = [subList2where(list, mapList), ...valueEntries2where(value)];
+    const value = getValueEntries(constraints, columns);
+    const where = where2column([subList2where(list, mapList), ...valueEntries2where(value)], fieldColumns);
     const {
       table
     } = type;
-    /** @type {MatchArg} */
-    const argv = {
-      table: typeof table === 'string' ? table : '',
-      fields: subfields,
-      where
-    };
+    const tableName = typeof table === 'string' ? table : '';
     if (!tableFields.length && !hasResult) {
-      const result = table && typeof table === 'object' ? table.delete(env, conn, argv) : conn.delete(env, argv);
+      const result = table && typeof table === 'object' ? table.delete(env, conn, columns, where) : conn.delete(env, tableName, columns, where);
       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, l, tableFields, subfields, env, hasResult)));
+    const result = (table && typeof table === 'object' ? table.deleteReturn(env, conn, Object.keys(columns), columns, where) : conn.deleteReturn(env, Object.keys(columns), tableName, columns, where)).then(r => toFieldList(r, fieldColumns));
+    const subFieldSet = new Set(Object.keys(fieldColumns || columns));
+    promises.push(result.then(l => deleteSub(conn, l, tableFields, subFieldSet, env, hasResult)));
     constraintEntries.find(([k, v]) => v.noField)?.[0];
     promises.push(array ? result.then(subList => {
       for (const item of list) {
@@ -696,39 +712,93 @@ async function deleteMany(conn, queryable, env) {
     table,
     fields
   } = queryable;
-  const {
-    where
-  } = queryable.options;
-  const [baseFields, tableFields] = separateFields(fields);
+  const [columns, fieldColumns, tableFields] = toColumns(fields);
+  const where = where2column(queryable.options.where, fieldColumns);
   if (!tableFields.length) {
-    return table && typeof table === 'object' ? table.delete(env, conn, {
-      table: '',
-      fields: baseFields,
-      where
-    }) : conn.delete(env, {
-      table: table || '',
-      fields: baseFields,
-      where
-    });
+    return table && typeof table === 'object' ? table.delete(env, conn, columns, where) : conn.delete(env, table || '', columns, where);
   }
-  const list = table && typeof table === 'object' ? await table.deleteReturn(env, conn, {
-    table: '',
-    fields: baseFields,
-    where
-  }, Object.keys(baseFields)) : await conn.deleteReturn(env, {
-    table: table || '',
-    fields: baseFields,
-    where
-  }, Object.keys(baseFields));
+  const list = toFieldList(table && typeof table === 'object' ? await table.deleteReturn(env, conn, Object.keys(columns), columns, where) : await conn.deleteReturn(env, Object.keys(columns), table || '', columns, where), fieldColumns);
   if (!list) {
     return 0;
   }
-  await deleteSub(conn, list, tableFields, baseFields, env);
+  const baseFieldSet = new Set(Object.keys(fieldColumns || columns));
+  await deleteSub(conn, list, tableFields, baseFieldSet, env);
   return list.length;
 }
 
+/**
+ *
+ * @param {string[]} list
+ * @param {Record<string, string>?} fieldColumns
+ */
+function field2column(list, fieldColumns) {
+  if (!fieldColumns) {
+    return list;
+  }
+  return list.map(k => fieldColumns[k]);
+}
+
+/**
+ *
+ * @param {Record<string, any>[]} list
+ * @param {Record<string, string>?} fieldColumns
+ */
+function toColumnList(list, fieldColumns) {
+  if (!fieldColumns) {
+    return list;
+  }
+  const map = Object.entries(fieldColumns);
+  return list.map(it => Object.fromEntries(map.map(([k, v]) => [v, it[k]])));
+}
+
+/** @import { SetValue } from '../../set.mjs' */
+/** @import { Fields, Skip, FieldType } from '../../types' */
+/**
+ *
+ * @param {Fields<keyof FieldType>} columns
+ * @param {Record<string, string> | null} fieldColumns
+ * @param {Record<string, SetValue> | null | undefined} [update]
+ * @param {boolean | Skip} [skip]
+ * @returns {Promise<Record<string, SetValue>>}
+ */
+async function getSetValue$1(columns, fieldColumns, update, skip) {
+  /** @type {Record<string, SetValue>} */
+  const data = {};
+  if (update) {
+    for (const [k, v] of Object.entries(update)) {
+      const key = fieldColumns ? fieldColumns[k] : k;
+      const field = columns[key];
+      if (!field) {
+        continue;
+      }
+      if (field.immutable) {
+        if (!skip) {
+          continue;
+        }
+        if (skip !== true && !skip.immutable) {
+          continue;
+        }
+      }
+      data[key] = v;
+    }
+  }
+  if (!(skip === true || skip && skip.specific)) {
+    for (const [name, field] of Object.entries(columns)) {
+      if (field.primary) {
+        continue;
+      }
+      const updating = await getSpecificValue(field.updating);
+      if (updating === void 0) {
+        continue;
+      }
+      data[name] = updating;
+    }
+  }
+  return data;
+}
+
 /* eslint-disable no-labels */
-/** @import { Constraint, Environment, FieldDefine, GetName, IConnection, TableDefine } from '../types' */
+/** @import { Constraint, Environment, FieldDefine, IConnection, TableDefine } from '../types' */
 /** @import { WhereValue } from '../Where.mjs' */
 /**
  *
@@ -743,9 +813,6 @@ function classify(newList, oldList, keys, notFound, found) {
     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;
         }
@@ -835,24 +902,23 @@ async function updateItem(conn, env, updatedOldNewList, key, type, array, constr
   if (!has) {
     return;
   }
-  const oldList = oldListValues.flat();
-  const newList = newListValues.flat();
-  const {
-    fields
-  } = type;
+  const [columns, fieldColumns, tableFields, fields] = toColumns(type.fields);
   /** @type {Record<string, any>} */
-  const commonKeys = {};
-  for (const [k, v] of Object.entries(constraints || {})) {
+  const commonValues = {};
+  for (const [k, v] of constraintEntries) {
     const {
       field,
       value
     } = v;
-    if (field || value !== undefined) {
-      commonKeys[k] = 1;
+    if (!field && value !== undefined) {
+      commonValues[k] = value;
     }
   }
-  const [baseFields, tableFields] = separateFields(fields);
-  const primaryKeys = getPrimaryKeys(baseFields);
+  const oldList = oldListValues.flat();
+  const newList = newListValues.flat();
+  const primaryKeys = getPrimaryKeys(fields);
+  const fieldKeys = Object.keys(fields);
+  const columnKeys = Object.keys(columns);
   // 分离出新建、修改、删除
   // TODO: 优化分离逻辑
   const needDelete = oldList;
@@ -864,9 +930,9 @@ async function updateItem(conn, env, updatedOldNewList, key, type, array, constr
   const needUpdate = [];
   /** @type {Record<string, any>[]} */
   const unmatched = [];
-  const aKeys = Object.keys(baseFields).filter(v => !(v in commonKeys));
+  const aKeys = fieldKeys.filter(v => !(v in commonValues));
+  const pKeys = primaryKeys.filter(v => !(v in commonValues));
   classify(newList, needDelete, aKeys, unmatched, eq);
-  const pKeys = primaryKeys.filter(v => !(v in commonKeys));
   classify(unmatched, needDelete, pKeys, needCreate, needUpdate);
   const {
     table
@@ -874,10 +940,10 @@ async function updateItem(conn, env, updatedOldNewList, key, type, array, constr
   if (needDelete.length) {
     // 批量删除
     /** @type {WhereValue[]} */
-    const where = primaryKeys.filter(v => v in commonKeys).map(k => ({
+    const where = primaryKeys.filter(v => v in commonValues).map(k => ({
       field: k,
       operator: '=',
-      value: commonKeys[k] ?? null
+      value: commonValues[k] ?? null
     }));
     if (pKeys.length === 1) {
       const [key] = pKeys;
@@ -893,16 +959,8 @@ async function updateItem(conn, env, updatedOldNewList, key, type, array, constr
         value: needDelete.map(v => pKeys.map(k => v[k] ?? null))
       });
     }
-    const promise = typeof table === 'object' ? table.deleteReturn(env, conn, {
-      table: '',
-      fields: baseFields,
-      where
-    }, Object.keys(baseFields)) : conn.deleteReturn(env, {
-      table: table || '',
-      fields: baseFields,
-      where
-    }, Object.keys(baseFields));
-    promises.push(promise.then(list => deleteSub(conn, list, tableFields, baseFields, env)));
+    const promise = typeof table === 'object' ? table.deleteReturn(env, conn, columnKeys, columns, where2column(where, fieldColumns)) : conn.deleteReturn(env, columnKeys, table || '', columns, where2column(where, fieldColumns));
+    promises.push(promise.then(list => deleteSub(conn, toFieldList(list, fieldColumns), tableFields, new Set(Object.keys(fieldColumns || columns)), env)));
   }
   /** @type {typeof updatedOldNewList} */
   const list = eq.map(([n, o]) => [{
@@ -914,34 +972,37 @@ async function updateItem(conn, env, updatedOldNewList, key, type, array, constr
   const subPromises = [list];
   // 批量修改
   if (needUpdate.length) {
-    const keys = new Set(needUpdate.map(v => Object.keys(v[0])).flat());
-    const update = await getSetNewValue(baseFields);
-    for (const k of Object.keys(update)) {
-      keys.delete(k);
+    let keysColumn = new Set(needUpdate.map(v => Object.keys(v[0])).flat());
+    if (fieldColumns) {
+      keysColumn = new Set(field2column([...keysColumn], fieldColumns));
     }
-    const setKeys = Object.entries(baseFields).filter(([, v]) => typeof v.type === 'string' && !v.primary && !v.immutable).map(v => v[0]).filter(v => keys.has(v));
+    const updateColumn = await getSetValue$1(columns, fieldColumns);
+    for (const k of Object.keys(updateColumn)) {
+      keysColumn.delete(k);
+    }
+    const setKeysColumn = Object.entries(columns).filter(([, v]) => !v.primary && !v.immutable).map(v => v[0]).filter(v => keysColumn.has(v));
     /** @type {WhereValue[]} */
-    const where = Object.entries(commonKeys).filter(([k]) => primaryKeys.includes(k)).map(([k, v]) => ({
+    const where = Object.entries(commonValues).filter(([k]) => primaryKeys.includes(k)).map(([k, v]) => ({
       field: k,
       operator: '=',
       value: v
     }));
     for (const [value, old] of needUpdate) {
-      for (const key of setKeys) {
+      for (const key of fieldKeys) {
         if (value[key] !== undefined) {
           continue;
         }
         value[key] = old[key];
       }
     }
-    const list = typeof table === 'object' ? table.updateManyReturn(env, conn, '', baseFields, update, pKeys, setKeys, needUpdate.map(v => v[0]), where, Object.keys(baseFields)) : conn.updateManyReturn(env, table || '', baseFields, update, pKeys, setKeys, needUpdate.map(v => v[0]), where, Object.keys(baseFields));
+    const list = (typeof table === 'object' ? table.updateManyReturn(env, conn, columns, updateColumn, field2column(pKeys, fieldColumns), setKeysColumn, toColumnList(needUpdate.map(v => v[0]), fieldColumns), where2column(where, fieldColumns), columnKeys) : conn.updateManyReturn(env, table || '', columns, updateColumn, field2column(pKeys, fieldColumns), setKeysColumn, toColumnList(needUpdate.map(v => v[0]), fieldColumns), where2column(where, fieldColumns), columnKeys)).then(l => toFieldList(l, fieldColumns));
     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 === 'object' ? table.insert(env, conn, '', baseFields, await Promise.all(needCreate.map(d => getInsertValue(d, baseFields))), key.map(v => v[0])) : conn.insert(env, table || '', baseFields, await Promise.all(needCreate.map(d => getInsertValue(d, baseFields))), key.map(v => v[0]));
+    const subColumnData = await Promise.all(needCreate.map(d => getInsertValue(d, columns, fieldColumns)));
+    const list = (typeof table === 'object' ? table.insert(env, conn, columns, subColumnData, Object.keys(columns)) : conn.insert(env, table || '', columns, subColumnData, Object.keys(columns))).then(l => toFieldList(l, fieldColumns));
     listPromises.push(list);
     promises.push(list.then(list => createSub(conn, env, tableFields, needCreate, list)));
   }
@@ -1014,29 +1075,21 @@ async function updateData (conn, model, data, newData, env) {
     fields
   } = model;
   const savedData = data;
-  const has = keys.filter(v => v in fields && (typeof fields[v]?.type === 'string' || !fields[v]?.type.table)).length;
+  const has = keys.filter(v => v in fields && (typeof fields[v]?.type === 'string' || fields[v]?.type && !fields[v]?.type.table)).length;
   /** @type {WhereValue[]} */
   const where = getPrimaryKeys(fields).map(k => ({
     field: k,
     operator: '=',
     value: savedData[k]
   }));
-  const [baseFields, tableFields] = separateFields(fields);
+  const [columns, fieldColumns, tableFields] = toColumns(fields);
   let list = [];
   if (!has) {
     list = [data];
   } else if (table && typeof table === 'object') {
-    list = await table.updateReturn(env, conn, {
-      table: '',
-      fields: baseFields,
-      where
-    }, await getSetNewValue(fields, newData), Object.keys(baseFields));
+    list = toFieldList(await table.updateReturn(env, conn, Object.keys(columns), columns, await getSetValue$1(columns, fieldColumns, newData), where2column(where, fieldColumns)), fieldColumns);
   } else {
-    list = await conn.updateReturn(env, {
-      table: table || '',
-      fields: baseFields,
-      where
-    }, await getSetNewValue(fields, newData), Object.keys(baseFields));
+    list = toFieldList(await conn.updateReturn(env, Object.keys(columns), table || '', columns, await getSetValue$1(columns, fieldColumns, newData), where2column(where, fieldColumns)), fieldColumns);
   }
   const oldList = [data];
   const newList = [newData];
@@ -1046,16 +1099,31 @@ async function updateData (conn, model, data, newData, env) {
   return list[0];
 }
 
+/** @import { SetValue } from '../../set.mjs' */
+/**
+ *
+ * @param {Record<string, SetValue>} update
+ * @param {Record<string, string>?} fieldColumns
+ * @returns {Record<string, SetValue>}
+ */
+function set2column(update, fieldColumns) {
+  if (!fieldColumns) {
+    return update;
+  }
+  // @ts-ignore
+  return Object.fromEntries(Object.entries(update).map(([k, v]) => [fieldColumns[k], v]));
+}
+
 /** @import { SetValue } from '../../set.mjs' */
 /** @import { Fields } from '../../types' */
 /**
  *
- * @param {Fields} fields
+ * @param {Fields} columns
  * @param {Record<string, SetValue>} update
  * @returns
  */
-async function setDeleteTimestamp(fields, update) {
-  for (const [name, field] of Object.entries(fields)) {
+async function setDeleteTimestamp(columns, update) {
+  for (const [name, field] of Object.entries(columns)) {
     if (field.primary) {
       continue;
     }
@@ -1069,7 +1137,7 @@ async function setDeleteTimestamp(fields, update) {
 
 /** @import { WhereValue } from '../Where.mjs' */
 /** @import { SetValue } from '../set.mjs' */
-/** @import { Environment, IConnection, GetName, TableDefine } from '../types' */
+/** @import { Environment, IConnection, TableDefine } from '../types' */
 /**
  *
  * @param {IConnection} conn
@@ -1084,13 +1152,13 @@ async function pseudoDestroy (conn, tableDef, data, update, env) {
     table,
     fields
   } = tableDef;
-  const baseFields = toBaseFields(fields);
   /** @type {WhereValue[]} */
   const where = getPrimaryKeys(fields).map(k => ({
     field: k,
     operator: '=',
     value: data[k]
   }));
+  const [columns, fieldColumns] = toColumns(fields);
   const pseudo = tableDef.pseudo || '';
   where.push({
     field: pseudo,
@@ -1102,24 +1170,13 @@ async function pseudoDestroy (conn, tableDef, data, update, env) {
   };
   const pseudoValue = Number(new Date());
   value[pseudo] = pseudoValue;
-  await 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: table || '',
-    fields: baseFields,
-    where
-  }, value, Object.keys(baseFields));
-  if (!dataUpdated) {
-    return null;
-  }
-  return dataUpdated;
+  const set = set2column(value, fieldColumns);
+  await setDeleteTimestamp(columns, set);
+  const dataUpdated = table && typeof table === 'object' ? await table.updateReturn(env, conn, Object.keys(columns), columns, set, where2column(where, fieldColumns)) : await conn.updateReturn(env, Object.keys(columns), table || '', columns, set, where2column(where, fieldColumns));
+  return toFieldList(dataUpdated, fieldColumns)[0] || null;
 }
 
-/** @import { WhereValue } from '../Where.mjs' */
-/** @import { IConnection, TableDefine, Environment, GetName } from '../types' */
+/** @import { IConnection, TableDefine, Environment } from '../types' */
 /**
  *
  * @param {IConnection} conn
@@ -1133,23 +1190,15 @@ async function completelyDelete (conn, tableDef, data, env) {
     table,
     fields
   } = tableDef;
-  const [baseFields, tableFields] = separateFields(fields);
-  /** @type {WhereValue[]} */
-  const where = getPrimaryKeys(fields).map(k => ({
+  const [columns, fieldColumns, tableFields] = toColumns(fields);
+  const where = where2column(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: table || '',
-    fields: baseFields,
-    where
-  }, Object.keys(baseFields));
-  const [deleted] = await deleteSub(conn, list, tableFields, baseFields, env, true);
+  })), fieldColumns);
+  const list = toFieldList(table && typeof table === 'object' ? await table.deleteReturn(env, conn, Object.keys(columns), columns, where) : await conn.deleteReturn(env, Object.keys(columns), table || '', columns, where), fieldColumns);
+  const baseFieldSet = new Set(Object.keys(fieldColumns || columns));
+  const [deleted] = await deleteSub(conn, list, tableFields, baseFieldSet, env, true);
   return deleted || null;
 }
 
@@ -1159,15 +1208,39 @@ const Save = Symbol();
 const Create = Symbol();
 const Build = Symbol();
 
-/** @import { Fields, FieldType, Select } from '../types' */
+/** @import { Fields, FieldType, Select } from '../../types' */
 /**
- * @param {Fields<keyof FieldType>} fields
+ * @param {Select} select
+ * @param {Record<string, string>} fieldColumns
+ * @returns {Select}
+ */
+function toSelectItem(select, fieldColumns) {
+  return {
+    ...select,
+    field: fieldColumns[select.field]
+  };
+}
+/**
+ * @param {Fields<keyof FieldType>} columns
+ * @param {Record<string, string>?} fieldColumns
  * @param {Record<string, Select>?} [select]
  * @returns {[string, Select][]}
  */
-function toSelect(fields, select) {
+function select2column(columns, fieldColumns, select) {
   const list = select ? Object.entries(select) : [];
-  return list.length ? list : Object.keys(fields).map(k => [k, {
+  if (list.length) {
+    if (!fieldColumns) {
+      return list;
+    }
+    return list.map(([k, s]) => [k, toSelectItem(s, fieldColumns)]);
+  }
+  if (fieldColumns) {
+    return Object.entries(fieldColumns).map(([f, c]) => [f, {
+      field: c
+    }]);
+  }
+  let keys = Object.keys(columns);
+  return keys.map(k => [k, {
     field: k
   }]);
 }
@@ -1175,32 +1248,45 @@ function toSelect(fields, select) {
 /** @import { Fields, FieldType } from '../../types' */
 /**
  *
- * @param {Fields<keyof FieldType>} fields
- * @param {string} [noField]
+ * @param {Fields<keyof FieldType>} columns
+ * @param {string} [noColumn]
  * @returns {[string, boolean][]}
  */
-function getDefaultSort(fields, noField) {
+function getDefaultSort(columns, noColumn) {
   /** @type {[string, boolean, number][]} */
-  const sorted = Object.entries(fields).map(([f, d]) => [f, (d.sort || 0) < 0, Math.abs(d.sort || 0)]);
+  const sorted = Object.entries(columns).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]);
+  if (noColumn) {
+    sort.unshift([noColumn, false]);
   }
   return sort;
 }
 
-/** @import { Environment, FieldDefine, Fields, FieldType, GetName, IConnection, TableDefine } from '../types' */
+/**
+ *
+ * @param {[field: string, desc: boolean][]} sort
+ * @param {Record<string, string>?} fieldColumns
+ * @returns {[field: string, desc: boolean][]}
+ */
+function sort2column(sort, fieldColumns) {
+  if (!fieldColumns) {
+    return sort;
+  }
+  return sort.map(([f, d]) => [fieldColumns[f], d]);
+}
+
+/** @import { Environment, FieldDefine, Fields, FieldType, IConnection, TableDefine } from '../types' */
 /**
  *
  * @param {IConnection} conn
  * @param {any[]} list
  * @param {[string, FieldDefine<TableDefine>][]} fields
- * @param {Fields<keyof FieldType>} baseFields
+ * @param {Set<string>} baseFieldSet
  * @param {Environment} env
  * @returns {Promise<any[]>}
  */
-async function findSub(conn, list, fields, baseFields, env) {
+async function findSub(conn, list, fields, baseFieldSet, env) {
   if (!list.length) {
     return list;
   }
@@ -1216,31 +1302,29 @@ async function findSub(conn, list, fields, baseFields, env) {
     const {
       fields
     } = type;
-    const [subfields, tableFields] = separateFields(fields);
-    const mapList = getMapList(subfields, baseFields, constraints);
+    const [columns, fieldColumns, tableFields] = toColumns(fields);
+    const noColumn = noField && fieldColumns ? fieldColumns[noField] : noField;
+    const mapList = getMapList(fields, baseFieldSet, constraints);
     if (!mapList) {
       continue;
     }
-    const value = getValueEntries(constraints, subfields);
-    const where = [subList2where(list, mapList), ...valueEntries2where(value)];
+    const value = getValueEntries(constraints, columns);
+    const where = where2column([subList2where(list, mapList), ...valueEntries2where(value)], fieldColumns);
+    const select = select2column(columns, fieldColumns);
     const {
       table
     } = type;
     /** @type {PromiseLike<object[] | object>} */
-    const result = table && typeof table === 'object' ? table.select(env, conn, {
-      table: '',
-      fields: subfields,
+    const result = table && typeof table === 'object' ? table.find(env, conn, columns, {
       where,
-      sort: getDefaultSort(subfields, noField),
-      select: toSelect(subfields)
-    }) : conn.select(env, {
-      table: table || '',
-      fields: subfields,
+      sort: getDefaultSort(columns, noColumn),
+      select
+    }) : conn.find(env, table || '', columns, {
       where,
-      sort: getDefaultSort(subfields, noField),
-      select: toSelect(subfields)
+      sort: getDefaultSort(columns, noColumn),
+      select
     });
-    promises.push(result.then(list => findSub(conn, list, tableFields, subfields, env)));
+    promises.push(result.then(list => findSub(conn, list, tableFields, new Set(Object.keys(fieldColumns || columns)), env)));
     promises.push(array ? result.then(subList => {
       for (const item of list) {
         item[key] = subList.filter(createFilter(item, mapList));
@@ -1271,33 +1355,27 @@ async function find(conn, p, env) {
     where,
     sort,
     offset,
-    limit,
-    alias
+    limit
   } = getOptions(p);
-  const [baseFields, tableFields] = separateFields(fields);
-  const list = table && typeof table === 'object' ? await table.select(env, conn, {
-    table: '',
-    fields: baseFields,
-    alias,
-    where,
+  const [columns, fieldColumns, tableFields] = toColumns(fields);
+  const list = table && typeof table === 'object' ? await table.find(env, conn, columns, {
+    where: where2column(where, fieldColumns),
     offset,
     limit,
-    sort: sort?.length ? sort : getDefaultSort(baseFields),
-    select: toSelect(baseFields)
-  }) : await conn.select(env, {
-    table: table || '',
-    fields: baseFields,
-    alias,
-    where,
+    sort: sort?.length ? sort2column(sort, fieldColumns) : getDefaultSort(columns),
+    select: select2column(columns, fieldColumns)
+  }) : await conn.find(env, table || '', columns, {
+    where: where2column(where, fieldColumns),
     offset,
     limit,
-    sort: sort?.length ? sort : getDefaultSort(baseFields),
-    select: toSelect(baseFields)
+    sort: sort?.length ? sort2column(sort, fieldColumns) : getDefaultSort(columns),
+    select: select2column(columns, fieldColumns)
   });
   if (!list.length) {
     return [];
   }
-  await findSub(conn, list, tableFields, baseFields, env);
+  const baseFieldSet = new Set(Object.keys(fieldColumns || columns));
+  await findSub(conn, list, tableFields, baseFieldSet, env);
   if (typeof p[Build] !== 'function') {
     return list;
   }
@@ -1306,7 +1384,7 @@ async function find(conn, p, env) {
   return list.map(it => R(it, true, env));
 }
 
-/** @import { Environment, TableDefine, IConnection, GetName } from '../types' */
+/** @import { Environment, TableDefine, IConnection } from '../types' */
 /**
  *
  * @template {TableDefine} T
@@ -1323,28 +1401,22 @@ async function first(conn, p, env) {
   // @ts-ignore
   const {
     where,
-    sort,
-    alias
+    sort
   } = getOptions(p);
-  const [baseFields, tableFields] = separateFields(fields);
-  const list = table && typeof table === 'object' ? await table.select(env, conn, {
-    table: '',
-    fields: baseFields,
-    alias,
-    where,
+  const [columns, fieldColumns, tableFields] = toColumns(fields);
+  const list = table && typeof table === 'object' ? await table.find(env, conn, columns, {
+    where: where2column(where, fieldColumns),
     limit: 1,
-    sort: sort?.length ? sort : getDefaultSort(baseFields),
-    select: toSelect(baseFields)
-  }) : await conn.select(env, {
-    table: table || '',
-    fields: baseFields,
-    alias,
-    where,
+    sort: sort?.length ? sort2column(sort, fieldColumns) : getDefaultSort(columns),
+    select: select2column(columns, fieldColumns)
+  }) : await conn.find(env, table || '', columns, {
+    where: where2column(where, fieldColumns),
     limit: 1,
-    sort: sort?.length ? sort : getDefaultSort(baseFields),
-    select: toSelect(baseFields)
+    sort: sort?.length ? sort2column(sort, fieldColumns) : getDefaultSort(columns),
+    select: select2column(columns, fieldColumns)
   });
-  const [item] = await findSub(conn, list, tableFields, baseFields, env);
+  const baseFieldSet = new Set(Object.keys(fieldColumns || columns));
+  const [item] = await findSub(conn, list, tableFields, baseFieldSet, env);
   if (!item) {
     return null;
   }
@@ -1354,7 +1426,7 @@ async function first(conn, p, env) {
   return p[Build](item, true, env);
 }
 
-/** @import { Environment, GetName, IConnection, Queryable } from '../types' */
+/** @import { Environment, IConnection, Queryable } from '../types' */
 /**
  * @param {IConnection} conn
  * @param {Queryable} queryable
@@ -1369,35 +1441,127 @@ async function pseudoDeleteMany(conn, queryable, update, env) {
   const {
     where
   } = getOptions(queryable);
+  const [columns, fieldColumns] = toColumns(fields);
   const value = typeof update !== 'object' ? {} : {
     ...update
   };
   const pseudoValue = Number(new Date());
   const pseudo = queryable.pseudo || '';
   value[pseudo] = pseudoValue;
-  await 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: table || '',
-    fields: baseFields,
-    where
-  }, value, Object.keys(baseFields));
+  const set = set2column(value, fieldColumns);
+  await setDeleteTimestamp(columns, set);
+  const list = table && typeof table === 'object' ? await table.updateReturn(env, conn, Object.keys(columns), columns, set, where2column(where, fieldColumns)) : await conn.updateReturn(env, Object.keys(columns), table || '', columns, set, where2column(where, fieldColumns));
   return list.length;
 }
 
+/** @import { TableDefine } from '../types/table' */
+/** @import { DBIndex, DBTable } from '../types/connection' */
+/**
+ *
+ * @param {(TableDefine | DBTable)[]} tables
+ */
+function table2db(tables) {
+  /** @type {DBTable[]} */
+  const allTables = [];
+  /** @type {Map<string, DBTable & {indexes: DBIndex[]}>} */
+  const map = new Map();
+  const saved = new Set();
+  /** @type {(TableDefine | DBTable)[]} */
+  const list = [...tables];
+  for (let define = list.pop(); define; define = list.pop()) {
+    if (saved.has(define)) {
+      continue;
+    }
+    saved.add(define);
+    const {
+      table,
+      fields,
+      indexes
+    } = define;
+    if (table && typeof table === 'string') {
+      let t = map.get(table);
+      if (!t) {
+        t = {
+          table,
+          fields: Object.create(null),
+          indexes: []
+        };
+        map.set(table, t);
+        allTables.push(t);
+      }
+      const dbColumns = t.fields;
+      for (const [name, field] of Object.entries(fields)) {
+        const {
+          type,
+          size,
+          scale,
+          default: value,
+          nullable,
+          array,
+          primary
+        } = field;
+        if (!type) {
+          continue;
+        }
+        const key = field.column || name;
+        const old = dbColumns[key];
+        if (typeof type === 'string') {
+          if (!old) {
+            t.fields[key] = {
+              type,
+              size,
+              scale,
+              default: value,
+              nullable,
+              array,
+              primary
+            };
+          } else {
+            t.fields[key] = {
+              type,
+              size: size || old.size,
+              scale: scale || old.scale,
+              default: value ?? old.default,
+              nullable: nullable ?? old.nullable,
+              array: array ?? old.array,
+              primary: primary || old.primary
+            };
+          }
+          continue;
+        }
+        if (type.table) {
+          continue;
+        }
+        if (!old) {
+          t.fields[key] = {
+            type: 'object',
+            nullable,
+            array
+          };
+        } else {
+          old.type = 'object';
+          old.array = array ?? old.array;
+          old.nullable = nullable ?? old.nullable;
+        }
+      }
+      for (const index of indexes || []) {
+        t.indexes.push(index);
+      }
+    }
+    for (const {
+      type
+    } of Object.values(fields)) {
+      if (!type || typeof type === 'string') {
+        continue;
+      }
+      list.push(type);
+    }
+  }
+  return allTables;
+}
+
 /* 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 { DBTable, GetName, Skip, TableType } from '../types/connection' */
 /**
  *
  * @param {Fields<keyof FieldType>} fields
@@ -1610,6 +1774,7 @@ class Connection {
       if (newData) {
         /** @type {any} */
         const doc = data;
+        // @ts-ignore
         return updateData(conn, model, doc, newData, this.#env);
       }
       return create(conn, this.#env, model, data);
@@ -1660,6 +1825,7 @@ class Connection {
     };
     if (typeof data[PseudoDestroy] !== 'function') {
       const conn = await this.#getConnection();
+      // @ts-ignore
       return pseudoDestroy(conn, tableDef, data, update, this.#env);
     }
     const r = /** @type {PseudoDestroy} */data;
@@ -1730,22 +1896,24 @@ class Connection {
     table,
     fields
   }, data, keys) {
-    const baseFields = toBaseFields(fields);
+    const [columns, fieldColumns] = toColumns(fields);
     const isArray = Array.isArray(data);
-    const insertValues = (isArray ? data : [data]).map(d => getInsertValue(d, fields));
+    const insertValues = (isArray ? data : [data]).map(d => getInsertValue(d, columns, fieldColumns));
     if (!insertValues.length) {
       throw new Error();
     }
-    let insertKeys = [...new Set(keys || [])].filter(k => k in baseFields);
+    let insertKeys = fieldColumns ? [...new Set(keys || [])].map(k => fieldColumns[k]).filter(Boolean) : [...new Set(keys || [])].filter(k => k in columns);
     if (!insertKeys.length && !isArray) {
-      insertKeys = Object.entries(insertValues[0]).filter(([k, v]) => v !== undefined && k in baseFields).map(([k]) => k);
+      insertKeys = Object.entries(insertValues[0]).filter(([k, v]) => v !== undefined && k in columns).map(([k]) => k);
     }
     if (!insertKeys.length) {
-      insertKeys = Object.entries(baseFields).map(v => v[0]);
+      insertKeys = Object.entries(columns).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, table || '', baseFields, insertValues, insertKeys);
-    return isArray ? (/** @type {*}*/p) : p[0];
+    const result = table && typeof table === 'object' ? await table.insert(this.#env, conn, columns, insertValues, insertKeys) : await conn.insert(this.#env, table || '', columns, insertValues, insertKeys);
+    const list = toFieldList(result, fieldColumns);
+    // @ts-ignore
+    return isArray ? list : list[0];
   }
   /**
    * @param {TableDefine} tableDefine
@@ -1758,16 +1926,9 @@ class Connection {
     table,
     fields
   }, update, where, skip) {
+    const [columns, fieldColumns, tableFields] = toColumns(fields);
     const conn = await this.#getConnection();
-    return table && typeof table === 'object' ? table.update(this.#env, conn, {
-      table: '',
-      fields: toBaseFields(fields),
-      where: where || undefined
-    }, await getSetNewValue(fields, update, skip)) : conn.update(this.#env, {
-      table: table || '',
-      fields: toBaseFields(fields),
-      where: where || undefined
-    }, await getSetNewValue(fields, update, skip));
+    return table && typeof table === 'object' ? table.update(this.#env, conn, columns, await getSetValue$1(columns, fieldColumns, update, skip), where2column(where, fieldColumns)) : conn.update(this.#env, table || '', columns, await getSetValue$1(columns, fieldColumns, update, skip), where2column(where, fieldColumns));
   }
   /**
    * @template {Fields<MainFieldType>} T
@@ -1782,17 +1943,10 @@ class Connection {
     table,
     fields
   }, update, returning, where, skip) {
+    const [columns, fieldColumns, tableFields] = toColumns(fields);
     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
-    }, await getSetNewValue(fields, update, skip), returning?.length ? returning : Object.keys(baseFields)) : conn.updateReturn(this.#env, {
-      table: table || '',
-      fields: baseFields,
-      where: where || undefined
-    }, await getSetNewValue(fields, update, skip), returning?.length ? returning : Object.keys(baseFields));
+    const result = table && typeof table === 'object' ? await table.updateReturn(this.#env, conn, returning?.length ? field2column(returning, fieldColumns) : Object.keys(columns), columns, await getSetValue$1(columns, fieldColumns, update, skip), where2column(where, fieldColumns)) : await conn.updateReturn(this.#env, returning?.length ? field2column(returning, fieldColumns) : Object.keys(columns), table || '', columns, await getSetValue$1(columns, fieldColumns, update, skip), where2column(where, fieldColumns));
+    return toFieldList(result, fieldColumns);
   }
   /**
    * @param {TableDefine} tableDefine
@@ -1806,11 +1960,11 @@ class Connection {
     table,
     fields
   }, pKeys, setKeys, list, skip) {
-    const baseFields = toBaseFields(fields);
-    const update = await getSetNewValue(fields, null, skip);
-    const [whereFields, setFields] = getKeys(baseFields, update, pKeys, setKeys);
+    const [columns, fieldColumns, tableFields] = toColumns(fields);
+    const update = await getSetValue$1(columns, fieldColumns, null, skip);
+    const [whereColumns, setColumns] = getKeys(columns, update, field2column(pKeys, fieldColumns), field2column(setKeys, fieldColumns));
     const conn = await this.#getConnection();
-    return table && typeof table === 'object' ? table.updateMany(this.#env, conn, '', baseFields, update, whereFields, setFields, list, []) : conn.updateMany(this.#env, table || '', baseFields, update, whereFields, setFields, list, []);
+    return table && typeof table === 'object' ? table.updateMany(this.#env, conn, columns, update, whereColumns, setColumns, toColumnList(list, fieldColumns), []) : conn.updateMany(this.#env, table || '', columns, update, whereColumns, setColumns, list, []);
   }
   /**
    * @template {Fields<MainFieldType>} T
@@ -1826,11 +1980,12 @@ class Connection {
     table,
     fields
   }, pKeys, setKeys, list, returning, skip) {
-    const baseFields = toBaseFields(fields);
-    const update = getSetNewValue(fields, null, skip);
-    const [whereFields, setFields] = getKeys(baseFields, update, pKeys, setKeys);
+    const [columns, fieldColumns, tableFields] = toColumns(fields);
+    const update = getSetValue$1(columns, fieldColumns, null, skip);
+    const [whereColumns, setColumns] = getKeys(columns, update, field2column(pKeys, fieldColumns), field2column(setKeys, fieldColumns));
     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, table || '', baseFields, update, whereFields, setFields, list, [], returning?.length ? returning : Object.keys(baseFields));
+    const result = table && typeof table === 'object' ? await table.updateManyReturn(this.#env, conn, columns, update, whereColumns, setColumns, toColumnList(list, fieldColumns), [], returning?.length ? field2column(returning, fieldColumns) : Object.keys(columns)) : await conn.updateManyReturn(this.#env, table || '', columns, update, whereColumns, setColumns, toColumnList(list, fieldColumns), [], returning?.length ? field2column(returning, fieldColumns) : Object.keys(columns));
+    return toFieldList(result, fieldColumns);
   }
   /**
    * @param {TableDefine} tableDefine
@@ -1841,16 +1996,9 @@ class Connection {
     table,
     fields
   }, where) {
+    const [columns, fieldColumns, tableFields] = toColumns(fields);
     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: table || '',
-      fields: toBaseFields(fields),
-      where
-    });
+    return table && typeof table === 'object' ? table.delete(this.#env, conn, columns, where2column(where, fieldColumns)) : conn.delete(this.#env, table || '', columns, where2column(where, fieldColumns));
   }
   /**
    * @template {Fields<MainFieldType>} T
@@ -1863,17 +2011,10 @@ class Connection {
     table,
     fields
   }, returning, where) {
+    const [columns, fieldColumns, tableFields] = toColumns(fields);
     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: table || '',
-      fields: baseFields,
-      where
-    }, returning?.length ? returning : Object.keys(baseFields));
+    const result = table && typeof table === 'object' ? await table.deleteReturn(this.#env, conn, returning?.length ? field2column(returning, fieldColumns) : Object.keys(columns), columns, where2column(where, fieldColumns)) : await conn.deleteReturn(this.#env, returning?.length ? field2column(returning, fieldColumns) : Object.keys(columns), table || '', columns, where2column(where, fieldColumns));
+    return toFieldList(result, fieldColumns);
   }
   /**
    *
@@ -1881,50 +2022,49 @@ class Connection {
    * @returns {Promise<number>}
    */
   async count(queryable) {
+    const [columns, fieldColumns, tableFields] = toColumns(queryable.fields);
     const {
-      table,
-      fields
+      table
     } = queryable;
     const options = getOptions(queryable);
+    const where = where2column(options.where, fieldColumns);
     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: table || '',
-      fields: toBaseFields(fields)
-    });
+    return table && typeof table === 'object' ? table.count(this.#env, conn, columns, where) : conn.count(this.#env, table || '', columns, where);
   }
   /**
    * @param {Queryable} queryable
    * @returns {Promise<any[]>}
    */
   async select(queryable) {
+    const [columns, fieldColumns, tableFields] = toColumns(queryable.fields);
     const {
       table
     } = queryable;
-    const fields = toBaseFields(queryable.fields);
     const options = getOptions(queryable);
+    const {
+      offset,
+      limit
+    } = options;
+    const where = where2column(options.where, fieldColumns);
     const conn = await this.#getConnection();
-    const select = toSelect(fields, options.select);
+    const select = select2column(columns, fieldColumns, options.select);
     const {
       sort
     } = options;
-    return table && typeof table === 'object' ? table.select(this.#env, conn, {
-      ...options,
-      table: '',
-      fields,
+    const result = table && typeof table === 'object' ? await table.find(this.#env, conn, columns, {
+      offset,
+      limit,
+      where,
       select,
-      sort: sort?.length ? sort : getDefaultSort(fields)
-    }) : conn.select(this.#env, {
-      ...options,
-      table: table || '',
-      fields,
+      sort: sort?.length ? sort2column(sort, fieldColumns) : getDefaultSort(columns)
+    }) : await conn.find(this.#env, table || '', columns, {
+      offset,
+      limit,
+      where,
       select,
-      sort: sort?.length ? sort : getDefaultSort(fields)
+      sort: sort?.length ? sort2column(sort, fieldColumns) : getDefaultSort(columns)
     });
+    return result;
   }
   /**
    * @param {string} table
@@ -2023,62 +2163,6 @@ class Connection {
     const conn = await this.#getConnection();
     return conn.renameTable(this.#env, 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, 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, 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, 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, view);
-  }
   /** @type {AbortController[]} */
   #layers = [];
   /**
@@ -2164,12 +2248,20 @@ class Connection {
     return conn.loadTables(this.#env, tables);
   }
   /**
-   * @param {DBTable[]} tables
+   * @param {TableDefine | DBTable} table
+   * @returns {Promise<void>}
+   */
+  async syncTable(table) {
+    const conn = await this.#getConnection();
+    return conn.syncTables(this.#env, table2db([table]));
+  }
+  /**
+   * @param {(TableDefine | DBTable)[]} tables
    * @returns {Promise<void>}
    */
   async syncTables(tables) {
     const conn = await this.#getConnection();
-    return conn.syncTables(this.#env, tables);
+    return conn.syncTables(this.#env, table2db(tables));
   }
   /**
    * @template T
@@ -2411,12 +2503,7 @@ function submodel(type, constraints, p1, p2) {
   const define = {
     ...p,
     constraints,
-    type: {
-      table: type.table,
-      fields: type.fields,
-      pseudo: type.pseudo,
-      indexes: type.indexes
-    },
+    type,
     array,
     nullable: false,
     immutable
@@ -2782,6 +2869,16 @@ function prop(prop, value) {
   return (_, ctx) => setProp(ctx, prop, value);
 }
 
+/** @import { FieldDecorator } from './index.mjs' */
+/**
+ *
+ * @param {string} [column]
+ * @returns {FieldDecorator<any>}
+ */
+function column(column) {
+  return (_, ctx) => setProp(ctx, 'column', column);
+}
+
 /** @import { FieldDecorator } from './index.mjs' */
 /**
  *
@@ -3543,7 +3640,7 @@ class Where {
   }
 }
 
-/** @typedef {SetValue.Increment | SetValue.Decrement | SetValue.Multiply | SetValue.Divide | string | number | bigint | boolean | null | typeof now | (string | number | bigint | boolean)[]} SetValue */
+/** @typedef {SetValue.Increment | SetValue.Decrement | SetValue.Multiply | SetValue.Divide | string | number | bigint | boolean | null | typeof now | typeof uuid | (string | number | bigint | boolean)[]} SetValue */
 /** @typedef {{[values.increment]: number | bigint}} SetValue.Increment */
 /** @typedef {{[values.decrement]: number | bigint}} SetValue.Decrement */
 /** @typedef {{[values.multiply]: number | bigint}} SetValue.Multiply */
@@ -4305,7 +4402,7 @@ function getInitValue(field, value) {
   if (typeof type === 'string') {
     return getBaseTypeValue(type, field.array, value, true);
   }
-  if (!type.table) {
+  if (!type?.table) {
     return getBaseTypeValue('object', field.array, value, true);
   }
   const {
@@ -4335,6 +4432,9 @@ function getInitValue(field, value) {
       const {
         type
       } = field;
+      if (!type) {
+        continue;
+      }
       if (typeof type === 'string') {
         doc[key] = getBaseTypeValue(type, field.array, values[key]);
       } else if (!type.table) {
@@ -4362,6 +4462,9 @@ function getSetValue(field, value, immutable) {
     }
     return getBaseTypeValue(type, field.array, value, true);
   }
+  if (!type) {
+    return;
+  }
   if (!type.table) {
     return getBaseTypeValue('object', field.array, value, true);
   }
@@ -4393,6 +4496,9 @@ function getSetValue(field, value, immutable) {
       const {
         type
       } = field;
+      if (!type) {
+        continue;
+      }
       if (typeof type === 'string') {
         if (typeof type !== 'string') {
           continue;
@@ -4552,6 +4658,9 @@ class Model {
       const {
         type
       } = field;
+      if (!type) {
+        continue;
+      }
       // eslint-disable-next-line no-nested-ternary
       values[key] = typeof type === 'string' ? getBaseTypeValue(type, field.array)
       // eslint-disable-next-line no-nested-ternary
@@ -5095,4 +5204,4 @@ function field(type, {
   };
 }
 
-export { Build, Connection, Create, Destroy, Model, PseudoDestroy, Query, Save, Submodel, Where, creating, decrement, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, submodel as model, multiply, now, primary, prop, pseudo, setDevelopment, sort, submodel, toNot, toPrimaries, toPrimary, undeleted, updating, values, withDeleted };
+export { Build, Connection, Create, Destroy, Model, PseudoDestroy, Query, Save, Submodel, Where, column, creating, decrement, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, submodel as model, multiply, now, primary, prop, pseudo, setDevelopment, sort, submodel, toNot, toPrimaries, toPrimary, undeleted, updating, uuid, values, withDeleted };