pqb 0.30.1 → 0.30.3

package/dist/index.js

@@ -29,8 +29,8 @@ const templateLiteralToSQL = (template, ctx, quotedAs) => {
 class RawSQL extends orchidCore.RawSQLBase {
   constructor(sql, values, type) {
     super(sql, values);
+    this.result = { value: type };
     if (type) {
-      this.result = { value: type };
       Object.assign(this, type.operators);
     }
   }
@@ -836,102 +836,6 @@ const columnCode = (type, t, code, migration, data = type.data, skip) => {
   return code.length === 1 && typeof code[0] === "string" ? code[0] : code;
 };
 
-function simpleColumnToSQL(ctx, key, column, quotedAs) {
-  if (!column)
-    return `"${key}"`;
-  const { data } = column;
-  return data.computed ? data.computed.toSQL(ctx, quotedAs) : `${quotedAs ? `${quotedAs}.` : ""}"${data.name || key}"`;
-}
-function simpleExistingColumnToSQL(ctx, key, column, quotedAs) {
-  const { data } = column;
-  return data.computed ? data.computed.toSQL(ctx, quotedAs) : `${quotedAs ? `${quotedAs}.` : ""}"${data.name || key}"`;
-}
-const columnToSql = (ctx, data, shape, column, quotedAs, select) => {
-  var _a, _b, _c, _d, _e;
-  const index = column.indexOf(".");
-  if (index !== -1) {
-    const table = column.slice(0, index);
-    const key = column.slice(index + 1);
-    if (key === "*") {
-      if ((_a = data.joinedShapes) == null ? void 0 : _a[table]) {
-        return select ? `row_to_json("${table}".*)` : `"${table}".r`;
-      }
-      return column;
-    }
-    const tableName = ((_b = data.joinOverrides) == null ? void 0 : _b[table]) || table;
-    const quoted = `"${table}"`;
-    const col = quoted === quotedAs ? shape[key] : (_d = (_c = data.joinedShapes) == null ? void 0 : _c[tableName]) == null ? void 0 : _d[key];
-    if (col) {
-      if (col.data.name) {
-        return `"${tableName}"."${col.data.name}"`;
-      }
-      if (col.data.computed) {
-        return `${col.data.computed.toSQL(ctx, quoted)}`;
-      }
-      return `"${tableName}"."${key}"`;
-    }
-    return `"${tableName}"."${key}"`;
-  }
-  if (!select && ((_e = data.joinedShapes) == null ? void 0 : _e[column])) {
-    return `"${column}".r`;
-  }
-  return simpleColumnToSQL(ctx, column, shape[column], quotedAs);
-};
-const columnToSqlWithAs = (ctx, data, column, quotedAs, select) => {
-  var _a, _b, _c, _d;
-  const index = column.indexOf(".");
-  if (index !== -1) {
-    const table = column.slice(0, index);
-    const key = column.slice(index + 1);
-    if (key === "*") {
-      if ((_a = data.joinedShapes) == null ? void 0 : _a[table]) {
-        return select ? `row_to_json("${table}".*) "${table}"` : `"${table}".r "${table}"`;
-      }
-      return column;
-    }
-    const tableName = ((_b = data.joinOverrides) == null ? void 0 : _b[table]) || table;
-    const quoted = `"${table}"`;
-    const col2 = quoted === quotedAs ? data.shape[key] : (_c = data.joinedShapes) == null ? void 0 : _c[tableName][key];
-    if (col2) {
-      if (col2.data.name && col2.data.name !== key) {
-        return `"${tableName}"."${col2.data.name}" "${key}"`;
-      }
-      if (col2.data.computed) {
-        return `${col2.data.computed.toSQL(ctx, quoted)} "${key}"`;
-      }
-    }
-    return `"${tableName}"."${key}"`;
-  }
-  if (!select && ((_d = data.joinedShapes) == null ? void 0 : _d[column])) {
-    return select ? `row_to_json("${column}".*) "${column}"` : `"${column}".r "${column}"`;
-  }
-  const col = data.shape[column];
-  if (col) {
-    if (col.data.name && col.data.name !== column) {
-      return `${quotedAs ? `${quotedAs}.` : ""}"${col.data.name}" "${column}"`;
-    }
-    if (col.data.computed) {
-      return `${col.data.computed.toSQL(ctx, quotedAs)} "${column}"`;
-    }
-  }
-  return `${quotedAs ? `${quotedAs}.` : ""}"${column}"`;
-};
-const ownColumnToSql = (data, column, quotedAs) => {
-  var _a;
-  const name = (_a = data.shape[column]) == null ? void 0 : _a.data.name;
-  return `${quotedAs ? `${quotedAs}.` : ""}"${name || column}"${name && name !== column ? ` "${column}"` : ""}`;
-};
-const rawOrColumnToSql = (ctx, data, expr, quotedAs, shape = data.shape, select) => {
-  return typeof expr === "string" ? columnToSql(ctx, data, shape, expr, quotedAs, select) : expr.toSQL(ctx, quotedAs);
-};
-const quoteSchemaAndTable = (schema, table) => {
-  return schema ? `"${schema}"."${table}"` : `"${table}"`;
-};
-const addValue = (values, value) => {
-  values.push(value);
-  return `$${values.length}`;
-};
-
 var __defProp$f = Object.defineProperty;
 var __defProps$7 = Object.defineProperties;
 var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
@@ -979,7 +883,7 @@ const make = (_op) => {
 const quoteValue$1 = (arg, ctx, quotedAs, jsonArray) => {
   if (arg && typeof arg === "object") {
     if (!jsonArray && Array.isArray(arg)) {
-      return `(${arg.map((value) => addValue(ctx.values, value)).join(", ")})`;
+      return `(${arg.map((value) => orchidCore.addValue(ctx.values, value)).join(", ")})`;
     }
     if (orchidCore.isExpression(arg)) {
       return arg.toSQL(ctx, quotedAs);
@@ -988,7 +892,7 @@ const quoteValue$1 = (arg, ctx, quotedAs, jsonArray) => {
       return `(${arg.toSQL({ values: ctx.values }).text})`;
     }
   }
-  return addValue(ctx.values, arg);
+  return orchidCore.addValue(ctx.values, arg);
 };
 const base = {
   equals: make(
@@ -1861,6 +1765,98 @@ const queryTypeWithLimitOne = {
 };
 const isQueryReturnsAll = (q) => !q.q.returnType || q.q.returnType === "all";
 
+function simpleColumnToSQL(ctx, key, column, quotedAs) {
+  if (!column)
+    return `"${key}"`;
+  const { data } = column;
+  return data.computed ? data.computed.toSQL(ctx, quotedAs) : `${quotedAs ? `${quotedAs}.` : ""}"${data.name || key}"`;
+}
+function simpleExistingColumnToSQL(ctx, key, column, quotedAs) {
+  const { data } = column;
+  return data.computed ? data.computed.toSQL(ctx, quotedAs) : `${quotedAs ? `${quotedAs}.` : ""}"${data.name || key}"`;
+}
+const columnToSql = (ctx, data, shape, column, quotedAs, select) => {
+  var _a, _b, _c, _d, _e;
+  const index = column.indexOf(".");
+  if (index !== -1) {
+    const table = column.slice(0, index);
+    const key = column.slice(index + 1);
+    if (key === "*") {
+      if ((_a = data.joinedShapes) == null ? void 0 : _a[table]) {
+        return select ? `row_to_json("${table}".*)` : `"${table}".r`;
+      }
+      return column;
+    }
+    const tableName = ((_b = data.joinOverrides) == null ? void 0 : _b[table]) || table;
+    const quoted = `"${table}"`;
+    const col = quoted === quotedAs ? shape[key] : (_d = (_c = data.joinedShapes) == null ? void 0 : _c[tableName]) == null ? void 0 : _d[key];
+    if (col) {
+      if (col.data.name) {
+        return `"${tableName}"."${col.data.name}"`;
+      }
+      if (col.data.computed) {
+        return `${col.data.computed.toSQL(ctx, quoted)}`;
+      }
+      return `"${tableName}"."${key}"`;
+    }
+    return `"${tableName}"."${key}"`;
+  }
+  if (!select && ((_e = data.joinedShapes) == null ? void 0 : _e[column])) {
+    return `"${column}".r`;
+  }
+  return simpleColumnToSQL(ctx, column, shape[column], quotedAs);
+};
+const columnToSqlWithAs = (ctx, data, column, quotedAs, select) => {
+  var _a, _b, _c, _d;
+  const index = column.indexOf(".");
+  if (index !== -1) {
+    const table = column.slice(0, index);
+    const key = column.slice(index + 1);
+    if (key === "*") {
+      if ((_a = data.joinedShapes) == null ? void 0 : _a[table]) {
+        return select ? `row_to_json("${table}".*) "${table}"` : `"${table}".r "${table}"`;
+      }
+      return column;
+    }
+    const tableName = ((_b = data.joinOverrides) == null ? void 0 : _b[table]) || table;
+    const quoted = `"${table}"`;
+    const col2 = quoted === quotedAs ? data.shape[key] : (_c = data.joinedShapes) == null ? void 0 : _c[tableName][key];
+    if (col2) {
+      if (col2.data.name && col2.data.name !== key) {
+        return `"${tableName}"."${col2.data.name}" "${key}"`;
+      }
+      if (col2.data.computed) {
+        return `${col2.data.computed.toSQL(ctx, quoted)} "${key}"`;
+      }
+    }
+    return `"${tableName}"."${key}"`;
+  }
+  if (!select && ((_d = data.joinedShapes) == null ? void 0 : _d[column])) {
+    return select ? `row_to_json("${column}".*) "${column}"` : `"${column}".r "${column}"`;
+  }
+  const col = data.shape[column];
+  if (col) {
+    if (col.data.name && col.data.name !== column) {
+      return `${quotedAs ? `${quotedAs}.` : ""}"${col.data.name}" "${column}"`;
+    }
+    if (col.data.computed) {
+      return `${col.data.computed.toSQL(ctx, quotedAs)} "${column}"`;
+    }
+  }
+  return `${quotedAs ? `${quotedAs}.` : ""}"${column}"`;
+};
+const ownColumnToSql = (data, column, quotedAs) => {
+  var _a;
+  const name = (_a = data.shape[column]) == null ? void 0 : _a.data.name;
+  return `${quotedAs ? `${quotedAs}.` : ""}"${name || column}"${name && name !== column ? ` "${column}"` : ""}`;
+};
+const rawOrColumnToSql = (ctx, data, expr, quotedAs, shape = data.shape, select) => {
+  return typeof expr === "string" ? columnToSql(ctx, data, shape, expr, quotedAs, select) : expr.toSQL(ctx, quotedAs);
+};
+const quoteSchemaAndTable = (schema, table) => {
+  return schema ? `"${schema}"."${table}"` : `"${table}"`;
+};
+
 const pushDistinctSql = (ctx, table, distinct, quotedAs) => {
   ctx.sql.push("DISTINCT");
   if (distinct.length) {
@@ -2021,7 +2017,7 @@ const processAnds = (and, ctx, table, query, quotedAs, parens) => {
   return parens && ands.length > 1 ? `(${sql})` : sql;
 };
 const processWhere = (ands, ctx, table, query, data, quotedAs) => {
-  var _a, _b;
+  var _a, _b, _c, _d;
   if (typeof data === "function") {
     const qb = Object.create(table);
     qb.q = getClonedQueryData(query);
@@ -2090,10 +2086,10 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
         );
         const rightPath = item[3];
         ands.push(
-          `jsonb_path_query_first(${leftColumn}, ${addValue(
+          `jsonb_path_query_first(${leftColumn}, ${orchidCore.addValue(
             ctx.values,
             leftPath
-          )}) = jsonb_path_query_first(${rightColumn}, ${addValue(
+          )}) = jsonb_path_query_first(${rightColumn}, ${orchidCore.addValue(
             ctx.values,
             rightPath
           )})`
@@ -2183,7 +2179,8 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
             column = quotedAs === quoted ? query.shape[name] : (_b = (_a = query.joinedShapes) == null ? void 0 : _a[table2]) == null ? void 0 : _b[name];
             quotedColumn = simpleColumnToSQL(ctx, name, column, quoted);
           } else {
-            quotedColumn = void 0;
+            column = (_d = (_c = query.joinedShapes) == null ? void 0 : _c[key]) == null ? void 0 : _d.value;
+            quotedColumn = `"${key}".r`;
           }
           if (!column || !quotedColumn) {
             throw new Error(`Unknown column ${key} provided to condition`);
@@ -2212,7 +2209,7 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
       }
     } else {
       ands.push(
-        `${columnToSql(ctx, query, query.shape, key, quotedAs)} ${value === null ? "IS NULL" : `= ${addValue(ctx.values, value)}`}`
+        `${columnToSql(ctx, query, query.shape, key, quotedAs)} ${value === null ? "IS NULL" : `= ${orchidCore.addValue(ctx.values, value)}`}`
       );
     }
   }
@@ -2225,7 +2222,7 @@ const pushIn = (ctx, query, ands, quotedAs, arg) => {
   let value;
   if (Array.isArray(arg.values)) {
     value = `${arg.values.map(
-      multiple ? (arr) => `(${arr.map((value2) => addValue(ctx.values, value2)).join(", ")})` : (arr) => `${arr.map((value2) => addValue(ctx.values, value2)).join(", ")}`
+      multiple ? (arr) => `(${arr.map((value2) => orchidCore.addValue(ctx.values, value2)).join(", ")})` : (arr) => `${arr.map((value2) => orchidCore.addValue(ctx.values, value2)).join(", ")}`
     ).join(", ")}`;
     value = `(${value})`;
   } else if (orchidCore.isExpression(arg.values)) {
@@ -3456,6 +3453,8 @@ const getShapeFromSelect = (q, isSubQuery) => {
             }
           }
         }
+      } else if (orchidCore.isExpression(item)) {
+        result.value = item.result.value;
       }
     }
   }
@@ -3687,7 +3686,6 @@ class From {
    * ```ts
    * const value = 123;
    * db.table.fromSql`value = ${value}`;
-   * db.table.fromSql(db.table.sql`value = ${value}`);
    * ```
    *
    * @param args - SQL expression
@@ -3757,7 +3755,7 @@ const jsonToSql = (ctx, table, item, values, quotedAs) => {
       column,
       values,
       quotedAs
-    )}, ${addValue(values, path)}${(options == null ? void 0 : options.vars) ? `, ${addValue(values, options.vars)}` : ""}${(options == null ? void 0 : options.silent) ? ", true" : ""})`;
+    )}, ${orchidCore.addValue(values, path)}${(options == null ? void 0 : options.vars) ? `, ${orchidCore.addValue(values, options.vars)}` : ""}${(options == null ? void 0 : options.silent) ? ", true" : ""})`;
   } else if (json[0] === "set") {
     const [, , , column, path, value, options] = json;
     return `jsonb_set(${jsonColumnOrMethodToSql(
@@ -3766,7 +3764,7 @@ const jsonToSql = (ctx, table, item, values, quotedAs) => {
       column,
       values,
       quotedAs
-    )}, '{${path.join(", ")}}', ${addValue(values, JSON.stringify(value))}${(options == null ? void 0 : options.createIfMissing) ? ", true" : ""})`;
+    )}, '{${path.join(", ")}}', ${orchidCore.addValue(values, JSON.stringify(value))}${(options == null ? void 0 : options.createIfMissing) ? ", true" : ""})`;
   } else if (json[0] === "insert") {
     const [, , , column, path, value, options] = json;
     return `jsonb_insert(${jsonColumnOrMethodToSql(
@@ -3775,7 +3773,7 @@ const jsonToSql = (ctx, table, item, values, quotedAs) => {
       column,
       values,
       quotedAs
-    )}, '{${path.join(", ")}}', ${addValue(values, JSON.stringify(value))}${(options == null ? void 0 : options.insertAfter) ? ", true" : ""})`;
+    )}, '{${path.join(", ")}}', ${orchidCore.addValue(values, JSON.stringify(value))}${(options == null ? void 0 : options.insertAfter) ? ", true" : ""})`;
   } else if (json[0] === "remove") {
     const [, , , column, path] = json;
     return `${jsonColumnOrMethodToSql(
@@ -3908,7 +3906,7 @@ const pushSubQuerySql = (ctx, query, as, list, quotedAs) => {
 const coalesce = (ctx, query, sql, quotedAs) => {
   const { coalesceValue } = query.q;
   if (coalesceValue !== void 0) {
-    const value = orchidCore.isExpression(coalesceValue) ? coalesceValue.toSQL(ctx, quotedAs) : addValue(ctx.values, coalesceValue);
+    const value = orchidCore.isExpression(coalesceValue) ? coalesceValue.toSQL(ctx, quotedAs) : orchidCore.addValue(ctx.values, coalesceValue);
     return `COALESCE(${sql}, ${value})`;
   }
   return sql;
@@ -3938,7 +3936,7 @@ const addOrder = (ctx, data, column, quotedAs, dir) => {
   if ((_a = data.sources) == null ? void 0 : _a[column]) {
     const search = data.sources[column];
     const order = dir || (!search.order || search.order === true ? orchidCore.emptyObject : search.order);
-    return `${order.coverDensity ? "ts_rank_cd" : "ts_rank"}(${order.weights ? `${addValue(ctx.values, `{${order.weights}}`)}, ` : ""}${search.vectorSQL}, "${column}"${order.normalization !== void 0 ? `, ${addValue(ctx.values, order.normalization)}` : ""}) ${order.dir || "DESC"}`;
+    return `${order.coverDensity ? "ts_rank_cd" : "ts_rank"}(${order.weights ? `${orchidCore.addValue(ctx.values, `{${order.weights}}`)}, ` : ""}${search.vectorSQL}, "${column}"${order.normalization !== void 0 ? `, ${orchidCore.addValue(ctx.values, order.normalization)}` : ""}) ${order.dir || "DESC"}`;
   }
   return `${columnToSql(ctx, data, data.shape, column, quotedAs)} ${dir || "ASC"}`;
 };
@@ -4090,7 +4088,7 @@ const fromToSql = (ctx, data, from, quotedAs) => {
 };
 const getSearchLang = (ctx, data, source, quotedAs) => {
   var _a;
-  return (_a = source.langSQL) != null ? _a : source.langSQL = "languageColumn" in source ? columnToSql(ctx, data, data.shape, source.languageColumn, quotedAs) : orchidCore.isRawSQL(source.language) ? source.language.toSQL(ctx) : addValue(ctx.values, source.language || data.language || "english");
+  return (_a = source.langSQL) != null ? _a : source.langSQL = "languageColumn" in source ? columnToSql(ctx, data, data.shape, source.languageColumn, quotedAs) : orchidCore.isRawSQL(source.language) ? source.language.toSQL(ctx) : orchidCore.addValue(ctx.values, source.language || data.language || "english");
 };
 const getSearchText = (ctx, data, source, quotedAs, forHeadline) => {
   let sql = source.textSQL;
@@ -4116,7 +4114,7 @@ const getSearchText = (ctx, data, source, quotedAs, forHeadline) => {
     sql = columnToSql(ctx, data, data.shape, source.vector, quotedAs);
   } else {
     if (typeof source.text === "string") {
-      sql = addValue(ctx.values, source.text);
+      sql = orchidCore.addValue(ctx.values, source.text);
     } else {
       sql = source.text.toSQL(ctx, quotedAs);
     }
@@ -4132,7 +4130,7 @@ const getTsVector = (ctx, data, lang, source, quotedAs) => {
       let tsVector = "";
       let i = 0;
       for (const key in source.in) {
-        tsVector = (tsVector ? `${tsVector} || ` : "") + `setweight(to_tsvector(${lang}, ${text[i++]}), ${addValue(
+        tsVector = (tsVector ? `${tsVector} || ` : "") + `setweight(to_tsvector(${lang}, ${text[i++]}), ${orchidCore.addValue(
           ctx.values,
           source.in[key]
         )})`;
@@ -4195,7 +4193,7 @@ const pushInsertSql = (ctx, q, query, quotedAs) => {
     if (orchidCore.isExpression(values)) {
       let valuesSql = values.toSQL(ctx, quotedAs);
       if (runtimeDefaults) {
-        valuesSql += `, ${runtimeDefaults.map((fn) => addValue(ctx.values, fn())).join(", ")}`;
+        valuesSql += `, ${runtimeDefaults.map((fn) => orchidCore.addValue(ctx.values, fn())).join(", ")}`;
       }
       ctx.sql.push(`VALUES (${valuesSql})`);
     } else {
@@ -4205,7 +4203,7 @@ const pushInsertSql = (ctx, q, query, quotedAs) => {
         sql = values.map(
           (raw) => (
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            `(${raw.toSQL(ctx, quotedAs)}, ${runtimeDefaults.map((fn) => addValue(v, fn())).join(", ")})`
+            `(${raw.toSQL(ctx, quotedAs)}, ${runtimeDefaults.map((fn) => orchidCore.addValue(v, fn())).join(", ")})`
           )
         ).join(", ");
       } else {
@@ -4285,7 +4283,7 @@ const pushInsertSql = (ctx, q, query, quotedAs) => {
         const arr = [];
         for (const key in set) {
           arr.push(
-            `"${((_d = shape[key]) == null ? void 0 : _d.data.name) || key}" = ${addValue(
+            `"${((_d = shape[key]) == null ? void 0 : _d.data.name) || key}" = ${orchidCore.addValue(
               ctx.values,
               set[key]
             )}`
@@ -4319,11 +4317,11 @@ const encodeRow = (ctx, q, QueryClass, row, runtimeDefaults, quotedAs) => {
         return `(${joinSubQuery(q, value).toSQL(ctx).text})`;
       }
     }
-    return value === void 0 ? "DEFAULT" : addValue(ctx.values, value);
+    return value === void 0 ? "DEFAULT" : orchidCore.addValue(ctx.values, value);
   });
   if (runtimeDefaults) {
     for (const fn of runtimeDefaults) {
-      arr.push(addValue(ctx.values, fn()));
+      arr.push(orchidCore.addValue(ctx.values, fn()));
     }
   }
   return arr.join(", ");
@@ -4439,10 +4437,10 @@ const processValue = (ctx, table, QueryClass, key, value, quotedAs) => {
     } else if (value instanceof QueryClass) {
       return `(${joinSubQuery(table, value).toSQL(ctx).text})`;
     } else if ("op" in value && "arg" in value) {
-      return `"${table.q.shape[key].data.name || key}" ${value.op} ${addValue(ctx.values, value.arg)}`;
+      return `"${table.q.shape[key].data.name || key}" ${value.op} ${orchidCore.addValue(ctx.values, value.arg)}`;
     }
   }
-  return addValue(ctx.values, value);
+  return orchidCore.addValue(ctx.values, value);
 };
 
 const pushDeleteSql = (ctx, table, query, quotedAs) => {
@@ -4507,14 +4505,14 @@ const pushTruncateSql = (ctx, table, query) => {
 const pushColumnInfoSql = (ctx, table, query) => {
   var _a;
   ctx.sql.push(
-    `SELECT * FROM information_schema.columns WHERE table_name = ${addValue(
+    `SELECT * FROM information_schema.columns WHERE table_name = ${orchidCore.addValue(
       ctx.values,
       table.table
     )} AND table_catalog = current_database() AND table_schema = ${query.schema || "current_schema()"}`
   );
   if (query.column) {
     ctx.sql.push(
-      `AND column_name = ${addValue(
+      `AND column_name = ${orchidCore.addValue(
         ctx.values,
         ((_a = table.q.shape[query.column]) == null ? void 0 : _a.data.name) || query.column
       )}`
@@ -4724,7 +4722,7 @@ const makeSQL = (table, options) => {
   }
   pushLimitSQL(sql, values, query);
   if (query.offset) {
-    sql.push(`OFFSET ${addValue(values, query.offset)}`);
+    sql.push(`OFFSET ${orchidCore.addValue(values, query.offset)}`);
   }
   if (query.for) {
     sql.push("FOR", query.for.type);
@@ -4745,7 +4743,7 @@ function pushLimitSQL(sql, values, q) {
     if (queryTypeWithLimitOne[q.returnType]) {
       sql.push(`LIMIT 1`);
     } else if (q.limit) {
-      sql.push(`LIMIT ${addValue(values, q.limit)}`);
+      sql.push(`LIMIT ${orchidCore.addValue(values, q.limit)}`);
     }
   }
 }
@@ -5359,7 +5357,7 @@ class FnExpression extends orchidCore.Expression {
           for (const key in pairs) {
             args.push(
               // ::text is needed to bypass "could not determine data type of parameter" postgres error
-              `${addValue(values, key)}::text, ${rawOrColumnToSql(
+              `${orchidCore.addValue(values, key)}::text, ${rawOrColumnToSql(
                 ctx,
                 this.q,
                 pairs[key],
@@ -5369,7 +5367,7 @@ class FnExpression extends orchidCore.Expression {
           }
           return args.join(", ");
         } else {
-          return addValue(values, arg.value);
+          return orchidCore.addValue(values, arg.value);
         }
       }).join(", ")
     );
@@ -5411,7 +5409,8 @@ class FnExpression extends orchidCore.Expression {
   }
 }
 function makeFnExpression(self, type, fn, args, options) {
-  const q = self.clone();
+  const q = extendQuery(self, type.operators);
+  q.baseQuery.type = orchidCore.ExpressionTypeMethod.prototype.type;
   new FnExpression(
     q,
     fn,
@@ -5433,49 +5432,6 @@ nullableInt.parseItem = nullableInt.parseFn = (input) => input === null ? null :
 const nullableFloat = new RealColumn(defaultSchemaConfig);
 nullableFloat.parseItem = nullableFloat.parseFn = (input) => input === null ? null : parseFloat(input);
 class AggregateMethods {
-  /**
-   * `fn` allows to call an arbitrary SQL function.
-   *
-   * For example, calling `sqrt` function to get a square root from some numeric column:
-   *
-   * ```ts
-   * const q = await User.select({
-   *   // todo: use type callback instead of generic type
-   *   sqrt: (q) => q.fn<number>('sqrt', ['numericColumn']),
-   * }).take();
-   *
-   * q.sqrt; // has type `number` just as provided
-   * ```
-   *
-   * If this is an aggregate function, you can specify aggregation options via third parameter.
-   *
-   * Forth parameter is for runtime column type. When specified, allows to chain the function with the column operators:
-   *
-   * ```ts
-   * const q = await User.select({
-   *   // chain `sqrt("numericColumn")` with the "greater than 5"
-   *   sqrtIsGreaterThan5: (q) => q.fn('sqrt', ['numericColumn'], {}, (t) => t.float()).gt(5),
-   * }).take();
-   *
-   * // Return type is boolean | null
-   * // todo: it should be just boolean if the column is not nullable, but for now it's always nullable
-   * q.sqrtIsGreaterThan5
-   * ```
-   *
-   * @param fn
-   * @param args
-   * @param options
-   * @param type
-   */
-  fn(fn, args, options, type) {
-    return makeFnExpression(
-      this,
-      (type == null ? void 0 : type(this.columnTypes)) || orchidCore.emptyObject,
-      fn,
-      args,
-      options
-    );
-  }
   /**
    * Use `exists()` to check if there is at least one record-matching condition.
    *
@@ -5820,7 +5776,7 @@ class AggregateMethods {
    *     // select a column with alias
    *     nameAlias: 'name',
    *     // select raw SQL with alias
-   *     foo: db.table.sql<string>`"bar" || "baz"`,
+   *     foo: sql<string>`"bar" || "baz"`,
    *   },
    *   aggregateOptions,
    * );
@@ -5830,7 +5786,7 @@ class AggregateMethods {
    *   object: (q) =>
    *     q.jsonObjectAgg({
    *       nameAlias: 'name',
-   *       foo: db.table.sql<string>`"bar" || "baz"`,
+   *       foo: sql<string>`"bar" || "baz"`,
    *     }),
    * });
    * ```
@@ -6302,7 +6258,7 @@ class Create {
    *
    * await db.table.create({
    *   // raw SQL
-   *   column1: db.table.sql`'John' | 'Doe'`,
+   *   column1: sql`'John' || ' ' || 'Doe'`,
    *
    *   // query that returns a single value
    *   // returning multiple values will result in Postgres error
@@ -6365,7 +6321,7 @@ class Create {
    * ```ts
    * const oneRecord = await db.table.createRaw({
    *   columns: ['name', 'amount'],
-   *   values: db.table.sql`'name', random()`,
+   *   values: sql`'name', random()`,
    * });
    * ```
    *
@@ -6394,7 +6350,7 @@ class Create {
    * ```ts
    * const manyRecords = await db.table.createManyRaw({
    *   columns: ['name', 'amount'],
-   *   values: [db.table.sql`'one', 2`, db.table.sql`'three', 4`],
+   *   values: [sql`'one', 2`, sql`'three', 4`],
    * });
    * ```
    *
@@ -6548,11 +6504,11 @@ class Create {
    * // raw SQL expression:
    * db.table
    *   .create(data)
-   *   .onConfict(db.table.sql`(email) where condition`)
+   *   .onConfict(sql`(email) where condition`)
    *   .merge();
    * ```
    *
-   * You can use the db.table.sql function in onConflict.
+   * You can use the `sql` function exported from your `BaseTable` file in onConflict.
    * It can be useful to specify a condition when you have a partial index:
    *
    * ```ts
@@ -6563,7 +6519,7 @@ class Create {
    *     active: true,
    *   })
    *   // ignore only when having conflicting email and when active is true.
-   *   .onConflict(db.table.sql`(email) where active`)
+   *   .onConflict(sql`(email) where active`)
    *   .ignore();
    * ```
    *
@@ -6663,7 +6619,7 @@ class OnConflictQueryBuilder {
    * db.table
    *   .create(data)
    *   .onConflict()
-   *   .set(db.table.sql`raw SQL expression`);
+   *   .set(sql`raw SQL expression`);
    *
    * // update records only on certain conditions
    * db.table
@@ -6837,16 +6793,20 @@ class For {
 
 class QueryGet {
   /**
-   * `.get` returns a single value, it will add `LIMIT 1` to the query, and accepts a column name or a raw expression.
-   * It will throw `NotFoundError` when not found.
+   * `.get` returns a single value, adds `LIMIT 1` to the query, and accepts a column name or a raw SQL expression.
+   *
+   * `get` throws a `NotFoundError` when not found, and `getOptional` returns `undefined`.
    *
    * ```ts
    * import { NumberColumn } from 'orchid-orm';
+   * import { sql } from './baseTable';
    *
    * const firstName: string = await db.table.get('name');
    *
-   * const rawResult: number = await db.table.get(
-   *   db.table.sql((t) => t.integer())`1 + 1`,
+   * const rawResult: number = await db.table.get(sql((t) => t.integer())`1 + 1`);
+   *
+   * const firstNameOptional: string | undefined = await db.table.getOptional(
+   *   'name',
    * );
    * ```
    *
@@ -6934,7 +6894,7 @@ class Having {
    * Provide SQL expression for the `HAVING` SQL statement:
    *
    * ```ts
-   * db.table.having`count(*) >= ${10}`;
+   * db.table.havingSql`count(*) >= ${10}`;
    * ```
    *
    * @param args - SQL expression
@@ -7190,15 +7150,14 @@ class Join {
    *   profile: (q) => q.profile,
    * });
    *
-   * // select posts with counts of comments, order by comments count
+   * // select posts with counts of comments, filter and order by comments count
    * // result type is Array<Post & { commentsCount: number }>
    * await db.post
    *   .select('*', {
    *     commentsCount: (q) => q.comments.count(),
    *   })
-   *   .order({
-   *     commentsCount: 'DESC',
-   *   });
+   *   .where({ commentsCount: { gt: 10 } })
+   *   .order({ commentsCount: 'DESC' });
    *
    * // select authors with array of their book titles
    * // result type is Array<Author & { books: string[] }>
@@ -7449,7 +7408,8 @@ class Join {
    * ```ts
    * db.user.join(
    *   db.message,
-   *   db.user.sql`lower("message"."text") = lower("user"."name")`,
+   *   // `sql` can be imported from your `BaseTable` file
+   *   sql`lower("message"."text") = lower("user"."name")`,
    * );
    * ```
    *
@@ -7458,16 +7418,16 @@ class Join {
    * ```ts
    * db.user.join(
    *   db.message,
-   *   db.user.sql`lower("message"."text")`,
-   *   db.user.sql`lower("user"."name")`,
+   *   sql`lower("message"."text")`,
+   *   sql`lower("user"."name")`,
    * );
    *
    * // with operator:
    * db.user.join(
    *   db.message,
-   *   db.user.sql`lower("message"."text")`,
+   *   sql`lower("message"."text")`,
    *   '!=',
-   *   db.user.sql`lower("user"."name")`,
+   *   sql`lower("user"."name")`,
    * );
    * ```
    *
@@ -7481,7 +7441,7 @@ class Join {
    *   'message.userId': 'user.id',
    *
    *   // value can be a raw SQL expression:
-   *   text: db.user.sql`lower("user"."name")`,
+   *   text: sql`lower("user"."name")`,
    * });
    * ```
    *
@@ -8271,7 +8231,7 @@ class With {
    *     id: columnTypes.integer(),
    *     name: columnTypes.text(3, 100),
    *   },
-   *   db.table.sql`SELECT id, name FROM "someTable"`,
+   *   sql`SELECT id, name FROM "someTable"`,
    * );
    *
    * // accepts query:
@@ -8279,7 +8239,7 @@ class With {
    *
    * // accepts a callback for a query builder:
    * db.table.with('alias', (qb) =>
-   *   qb.select({ one: db.table.sql`1`.type((t) => t.integer()) }),
+   *   qb.select({ one: sql`1`.type((t) => t.integer()) }),
    * );
    *
    * // All mentioned forms can accept options as a second argument:
@@ -8331,7 +8291,7 @@ class Union {
    * SomeTable.select('id', 'name').union(
    *   [
    *     OtherTable.select('id', 'name'),
-   *     SomeTable.sql`SELECT id, name FROM "thirdTable"`,
+   *     sql`SELECT id, name FROM "thirdTable"`,
    *   ],
    *   true, // optional wrap parameter
    * );
@@ -8526,7 +8486,8 @@ class Where {
    *   },
    *
    *   // where column equals to raw SQL
-   *   column: db.table.sql`sql expression`,
+   *   // import `sql` from your `BaseTable`
+   *   column: sql`sql expression`,
    * });
    * ```
    *
@@ -8575,12 +8536,7 @@ class Where {
    * `where` supports raw SQL:
    *
    * ```ts
-   * db.table.where(db.table.sql`a = b`);
-   *
-   * // or
-   * import { raw } from 'orchid-orm';
-   *
-   * db.table.where(raw`a = b`);
+   * db.table.where(sql`a = b`);
    * ```
    *
    * `where` can accept a callback with a specific query builder containing all "where" methods such as `where`, `orWhere`, `whereNot`, `whereIn`, `whereExists`:
@@ -8601,7 +8557,7 @@ class Where {
    * db.table.where(
    *   { id: 1 },
    *   db.table.where({ name: 'John' }),
-   *   db.table.sql`a = b`,
+   *   sql`a = b`,
    * );
    * ```
    *
@@ -8714,8 +8670,6 @@ class Where {
    * All column operators can take a value of the same type as the column, a sub-query, or a raw SQL expression:
    *
    * ```ts
-   * import { sql } from 'orchid-orm';
-   *
    * db.table.where({
    *   numericColumn: {
    *     // lower than 5
@@ -8764,7 +8718,7 @@ class Where {
    *     // WHERE "column" IN (SELECT "column" FROM "otherTable")
    *     in: OtherTable.select('column'),
    *
-   *     in: db.table.sql`('a', 'b')`,
+   *     in: sql`('a', 'b')`,
    *   },
    * });
    * ```
@@ -8811,7 +8765,7 @@ class Where {
    *     between: [1, 10],
    *
    *     // sub-query and raw SQL expression
-   *     between: [OtherTable.select('column').take(), db.table.sql`2 + 2`],
+   *     between: [OtherTable.select('column').take(), sql`2 + 2`],
    *   },
    * });
    * ```
@@ -8903,15 +8857,7 @@ class Where {
    * Use a custom SQL expression in `WHERE` statement:
    *
    * ```ts
-   * db.table.where`a = b`;
-   *
-   * // or
-   * db.table.where(db.table.sql`a = b`);
-   *
-   * // or
-   * import { raw } from 'orchid-orm';
-   *
-   * db.table.where(raw`a = b`);
+   * db.table.whereSql`a = b`;
    * ```
    *
    * @param args - SQL expression
@@ -8944,10 +8890,10 @@ class Where {
     );
   }
   /**
-   * `whereNot` version accepting SQL expression:
+   * `whereNotSql` is a version of `whereNot` accepting SQL expression:
    *
    * ```ts
-   * db.table.whereNot`sql expression`
+   * db.table.whereNotSql`sql expression`
    * ```
    *
    * @param args - SQL expression
@@ -9024,7 +8970,7 @@ class Where {
    * It supports raw SQL expression:
    *
    * ```ts
-   * db.table.whereIn(['id', 'name'], db.table.sql`((1, 'one'), (2, 'two'))`);
+   * db.table.whereIn(['id', 'name'], sql`((1, 'one'), (2, 'two'))`);
    * ```
    */
   whereIn(...args) {
@@ -9338,7 +9284,7 @@ class Update {
    *   column1: 123,
    *
    *   // use raw SQL to update the column
-   *   column2: db.table.sql`2 + 2`,
+   *   column2: sql`2 + 2`,
    *
    *   // use query that returns a single value
    *   // returning multiple values will result in Postgres error
@@ -9466,7 +9412,7 @@ class Update {
    * const updatedCount = await db.table.find(1).updateRaw`name = ${value}`;
    *
    * // or update with `sql` function:
-   * await db.table.find(1).updateRaw(db.table.sql`name = ${value}`);
+   * await db.table.find(1).updateRaw(sql`name = ${value}`);
    * ```
    * @param args - raw SQL via a template string or by using a `sql` method
    */
@@ -9732,7 +9678,7 @@ class Headline extends orchidCore.Expression {
     const { q, source, params } = this;
     const lang = getSearchLang(ctx, q, source, quotedAs);
     const text = (params == null ? void 0 : params.text) ? params.text instanceof orchidCore.Expression ? params.text.toSQL(ctx, quotedAs) : columnToSql(ctx, q, q.shape, params.text, quotedAs) : getSearchText(ctx, q, source, quotedAs, true);
-    const options = (params == null ? void 0 : params.options) ? `, ${params.options instanceof orchidCore.Expression ? params.options.toSQL(ctx, quotedAs) : addValue(ctx.values, params.options)}` : "";
+    const options = (params == null ? void 0 : params.options) ? `, ${params.options instanceof orchidCore.Expression ? params.options.toSQL(ctx, quotedAs) : orchidCore.addValue(ctx.values, params.options)}` : "";
     return `ts_headline(${lang}, ${text}, "${source.as}"${options})`;
   }
 }
@@ -10149,7 +10095,7 @@ class QueryUpsertOrCreate {
   }
 }
 
-class RawSqlMethods {
+class SqlMethod {
   sql(...args) {
     const sql = raw(...args);
     sql.columnTypes = this.columnTypes;
@@ -10390,6 +10336,118 @@ class RefExpression extends orchidCore.Expression {
     return columnToSql(ctx, this.q, this.q.shape, this.ref, quotedAs);
   }
 }
+class ExpressionMethods {
+  /**
+   * `column` references a table column, this can be used in raw SQL or when building a column expression.
+   * Only for referencing a column in the query's table. For referencing joined table's columns, see [ref](#ref).
+   *
+   * ```ts
+   * await db.table.select({
+   *   // select `("table"."id" = 1 OR "table"."name" = 'name') AS "one"`,
+   *   // returns a boolean
+   *   one: (q) =>
+   *     q.sql<boolean>`${q.column('id')} = ${1} OR ${q.column('name')} = ${'name'}`,
+   *
+   *   // selects the same as above, but by building a query
+   *   two: (q) => q.column('id').equals(1).or(q.column('name').equals('name')),
+   * });
+   * ```
+   *
+   * @param name - column name
+   */
+  column(name) {
+    const column = this.shape[name];
+    return new ColumnRefExpression(
+      column,
+      name
+    );
+  }
+  /**
+   * `ref` is similar to [column](#column), but it also allows to reference a column of joined table,
+   * and other dynamically defined columns.
+   *
+   * ```ts
+   * await db.table.join('otherTable').select({
+   *   // select `("otherTable"."id" = 1 OR "otherTable"."name" = 'name') AS "one"`,
+   *   // returns a boolean
+   *   one: (q) =>
+   *     q.sql<boolean>`${q.ref('otherTable.id')} = ${1} OR ${q.ref(
+   *       'otherTable.name',
+   *     )} = ${'name'}`,
+   *
+   *   // selects the same as above, but by building a query
+   *   two: (q) =>
+   *     q
+   *       .ref('otherTable.id')
+   *       .equals(1)
+   *       .or(q.ref('otherTable.name').equals('name')),
+   * });
+   * ```
+   *
+   * @param arg - any available column name, such as of a joined table
+   */
+  ref(arg) {
+    const q = this.clone();
+    const { shape } = q.q;
+    let column;
+    const index = arg.indexOf(".");
+    if (index !== -1) {
+      const table = arg.slice(0, index);
+      const col = arg.slice(index + 1);
+      if (table === (q.q.as || q.table)) {
+        column = shape[col];
+      } else {
+        column = q.q.joinedShapes[table][col];
+      }
+    } else {
+      column = shape[arg];
+    }
+    return new RefExpression(column, q.q, arg);
+  }
+  val(value) {
+    return new orchidCore.ValExpression(value);
+  }
+  /**
+   * `fn` allows to call an arbitrary SQL function.
+   *
+   * For example, calling `sqrt` function to get a square root from some numeric column:
+   *
+   * ```ts
+   * const q = await User.select({
+   *   sqrt: (q) => q.fn<number>('sqrt', ['numericColumn']),
+   * }).take();
+   *
+   * q.sqrt; // has type `number` just as provided
+   * ```
+   *
+   * If this is an aggregate function, you can specify aggregation options (see [Aggregate](/guide/aggregate.html)) via third parameter.
+   *
+   * Use `type` method to specify a column type so that its operators such as `lt` and `gt` become available:
+   *
+   * ```ts
+   * const q = await User.select({
+   *   // Produces `sqrt("numericColumn") > 5`
+   *   sqrtIsGreaterThan5: (q) =>
+   *     q
+   *       .fn('sqrt', ['numericColumn'])
+   *       .type((t) => t.float())
+   *       .gt(5),
+   * }).take();
+   *
+   * // Return type is boolean | null
+   * // todo: it should be just boolean if the column is not nullable, but for now it's always nullable
+   * q.sqrtIsGreaterThan5;
+   * ```
+   *
+   * @param fn
+   * @param args
+   * @param options
+   */
+  fn(fn, args, options) {
+    return makeFnExpression(this, orchidCore.emptyObject, fn, args, options);
+  }
+}
+
 const _queryAll = (q) => {
   q.q.returnType = "all";
   q.q.all = true;
@@ -10534,11 +10592,13 @@ class QueryMethods {
    * db.table.distinct().select('name');
    * ```
    *
-   * Can accept column names or raw expressions to place it to `DISTINCT ON (...)`:
+   * Can accept column names or raw SQL expressions to place it to `DISTINCT ON (...)`:
    *
    * ```ts
+   * import { sql } from './baseTable';
+   *
    * // Distinct on the name and raw SQL
-   * db.table.distinct('name', db.table.sql`raw sql`).select('id', 'name');
+   * db.table.distinct('name', sql`raw sql`).select('id', 'name');
    * ```
    *
    * @param columns - column names or a raw SQL
@@ -10698,9 +10758,11 @@ class QueryMethods {
    * Also, it's possible to group by a selected value:
    *
    * ```ts
+   * import { sql } from './baseTable';
+   *
    * const results = db.product
    *   .select({
-   *     month: db.product.sql`extract(month from "createdAt")`.type((t) =>
+   *     month: sql`extract(month from "createdAt")`.type((t) =>
    *       // month is returned as string, parse it to int
    *       t.string().parse(parseInt),
    *     ),
@@ -10804,8 +10866,6 @@ class QueryMethods {
    *
    * ```ts
    * db.table.orderSql`raw sql`;
-   * // or
-   * db.table.orderSql(db.table.sql`raw sql`);
    * ```
    *
    * @param args - SQL expression
@@ -11000,71 +11060,32 @@ class QueryMethods {
     };
   }
   /**
-   * `column` references a table column, this can be used in raw SQL or when building a column expression.
-   * Only for referencing a column in the query's table. For referencing joined table's columns, see [ref](#ref).
-   *
-   * ```ts
-   * await db.table.select({
-   *   // select `("table"."id" = 1 OR "table"."name" = 'name') AS "one"`,
-   *   // returns a boolean
-   *   one: (q) =>
-   *     q.sql<boolean>`${q.column('id')} = ${1} OR ${q.column('name')} = ${'name'}`,
-   *
-   *   // selects the same as above, but by building a query
-   *   two: (q) => q.column('id').equals(1).or(q.column('name').equals('name')),
-   * });
-   * ```
+   * Narrows a part of the query output type.
+   * Use with caution, type-safety isn't guaranteed with it.
+   * This is similar so using `as` keyword from TypeScript, except that it applies only to a part of the result.
    *
-   * @param name - column name
-   */
-  column(name) {
-    const column = this.shape[name];
-    return new ColumnRefExpression(
-      column,
-      name
-    );
-  }
-  /**
-   * `ref` is similar to [column](#column), but it also allows to reference a column of joined table,
-   * and other dynamically defined columns.
+   * The syntax `()<{ ... }>()` is enforced by internal limitations.
    *
    * ```ts
-   * await db.table.join('otherTable').select({
-   *   // select `("otherTable"."id" = 1 OR "otherTable"."name" = 'name') AS "one"`,
-   *   // returns a boolean
-   *   one: (q) =>
-   *     q.sql<boolean>`${q.ref('otherTable.id')} = ${1} OR ${q.ref(
-   *       'otherTable.name',
-   *     )} = ${'name'}`,
+   * const rows = db.table
+   *   // filter out records where the `nullableColumn` is null
+   *   .where({ nullableColumn: { not: null } });
+   *   // narrows only a specified column, the rest of result is unchanged
+   *   .narrowType()<{ nullableColumn: string }>()
    *
-   *   // selects the same as above, but by building a query
-   *   two: (q) =>
-   *     q
-   *       .ref('otherTable.id')
-   *       .equals(1)
-   *       .or(q.ref('otherTable.name').equals('name')),
-   * });
-   * ```
+   * // the column had type `string | null`, now it is `string`
+   * rows[0].nullableColumn
    *
-   * @param arg - any available column name, such as of a joined table
+   * // imagine that table has a enum column kind with variants 'first' | 'second'
+   * // and a boolean `approved`
+   * db.table
+   *   .where({ kind: 'first', approved: true })
+   *   // after applying such `where`, it's safe to narrow the type to receive the literal values
+   *   .narrowType()<{ kind: 'first', approved: true }>();
+   * ```
    */
-  ref(arg) {
-    const q = this.clone();
-    const { shape } = q.q;
-    let column;
-    const index = arg.indexOf(".");
-    if (index !== -1) {
-      const table = arg.slice(0, index);
-      const col = arg.slice(index + 1);
-      if (table === (q.q.as || q.table)) {
-        column = shape[col];
-      } else {
-        column = q.q.joinedShapes[table][col];
-      }
-    } else {
-      column = shape[arg];
-    }
-    return new RefExpression(column, q.q, arg);
+  narrowType() {
+    return () => this;
   }
 }
 orchidCore.applyMixins(QueryMethods, [
@@ -11094,10 +11115,11 @@ orchidCore.applyMixins(QueryMethods, [
   QueryUpsertOrCreate,
   QueryGet,
   MergeQueryMethods,
-  RawSqlMethods,
+  SqlMethod,
   TransformMethods,
   ScopeMethods,
-  SoftDeleteMethods
+  SoftDeleteMethods,
+  ExpressionMethods
 ]);
 
 const makeIndex = (columns, first, second) => {
@@ -11705,6 +11727,7 @@ exports.DomainColumn = DomainColumn;
 exports.DoublePrecisionColumn = DoublePrecisionColumn;
 exports.DynamicRawSQL = DynamicRawSQL;
 exports.EnumColumn = EnumColumn;
+exports.ExpressionMethods = ExpressionMethods;
 exports.FnExpression = FnExpression;
 exports.For = For;
 exports.From = From;
@@ -11745,7 +11768,6 @@ exports.QueryLog = QueryLog;
 exports.QueryMethods = QueryMethods;
 exports.QueryUpsertOrCreate = QueryUpsertOrCreate;
 exports.RawSQL = RawSQL;
-exports.RawSqlMethods = RawSqlMethods;
 exports.RealColumn = RealColumn;
 exports.RefExpression = RefExpression;
 exports.SearchMethods = SearchMethods;
@@ -11753,6 +11775,7 @@ exports.Select = Select;
 exports.SerialColumn = SerialColumn;
 exports.SmallIntColumn = SmallIntColumn;
 exports.SmallSerialColumn = SmallSerialColumn;
+exports.SqlMethod = SqlMethod;
 exports.StringColumn = StringColumn;
 exports.TextBaseColumn = TextBaseColumn;
 exports.TextColumn = TextColumn;