prisma-ts-select 0.0.34 → 0.1.3

package/dist/extend/dialects/mysql.d.ts

@@ -0,0 +1,93 @@
+import { Dialect } from './types.js';
+import { S as SQLExpr } from '../sql-expr-BaKWzJ-r.js';
+import { J as JSONValue, a as JSONObject } from '../types-B0F8m0ok.js';
+import { Decimal } from '@prisma/client/runtime/client';
+import { FilterCols, ColName, FilterJsonCols } from './shared.js';
+
+type MySQLCastTypeMap = {
+    SIGNED: bigint;
+    UNSIGNED: bigint;
+    DECIMAL: Decimal;
+    CHAR: string;
+    BINARY: Buffer;
+    DATE: Date;
+    DATETIME: Date;
+    TIME: string;
+    JSON: JSONValue;
+    FLOAT: number;
+    DOUBLE: number;
+};
+type IntervalUnit = 'MICROSECOND' | 'SECOND' | 'MINUTE' | 'HOUR' | 'DAY' | 'WEEK' | 'MONTH' | 'QUARTER' | 'YEAR';
+declare const mysqlContextFns: <TColEntries extends [string, unknown] = never, TCriteria extends object = object>(quoteFn: (ref: string) => string, condFn: (criteria: TCriteria) => string) => {
+    avg: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<Decimal>;
+    sum: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<Decimal>;
+    countAll: () => SQLExpr<bigint>;
+    count: (col: ColName<TColEntries> | "*") => SQLExpr<bigint>;
+    countDistinct: (col: ColName<TColEntries>) => SQLExpr<bigint>;
+    length: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<bigint>;
+    groupConcat: (col: ColName<TColEntries>, sep?: string) => SQLExpr<string>;
+    bitAnd: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    bitOr: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    bitXor: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    stddev: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    stddevSamp: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    variance: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    varSamp: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    jsonArrayAgg: (col: ColName<TColEntries>) => SQLExpr<JSONValue>;
+    jsonObjectAgg: (key: ColName<TColEntries>, val: ColName<TColEntries>) => SQLExpr<JSONValue>;
+    concat: (args_0: SQLExpr<string> | FilterCols<TColEntries, string>, ...args: (SQLExpr<string> | FilterCols<TColEntries, string>)[]) => SQLExpr<string>;
+    substring: (col: FilterCols<TColEntries, string> | SQLExpr<string>, start: number, len?: number) => SQLExpr<string>;
+    left: (col: FilterCols<TColEntries, string> | SQLExpr<string>, n: number) => SQLExpr<string>;
+    right: (col: FilterCols<TColEntries, string> | SQLExpr<string>, n: number) => SQLExpr<string>;
+    repeat: (col: FilterCols<TColEntries, string> | SQLExpr<string>, n: number) => SQLExpr<string>;
+    reverse: (col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<string>;
+    lpad: (col: FilterCols<TColEntries, string> | SQLExpr<string>, len: number, pad: string) => SQLExpr<string>;
+    rpad: (col: FilterCols<TColEntries, string> | SQLExpr<string>, len: number, pad: string) => SQLExpr<string>;
+    locate: (substr: string, col: FilterCols<TColEntries, string> | SQLExpr<string>) => SQLExpr<bigint>;
+    space: (n: number) => SQLExpr<string>;
+    now: () => SQLExpr<Date>;
+    curDate: () => SQLExpr<Date>;
+    year: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<bigint>;
+    month: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<bigint>;
+    day: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<bigint>;
+    hour: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<bigint>;
+    minute: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    second: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    $if: <T>(cond: TCriteria | SQLExpr<unknown>, trueVal: SQLExpr<T>, falseVal: SQLExpr<T>) => SQLExpr<T>;
+    ifNull: <T>(col: FilterCols<TColEntries, T> | SQLExpr<T>, fallback: SQLExpr<NonNullable<T>>) => SQLExpr<NonNullable<T>>;
+    greatest: <T>(args_0: FilterCols<TColEntries, T> | SQLExpr<T>, ...args: (FilterCols<TColEntries, T> | SQLExpr<T>)[]) => SQLExpr<T | null>;
+    least: <T>(args_0: FilterCols<TColEntries, T> | SQLExpr<T>, ...args: (FilterCols<TColEntries, T> | SQLExpr<T>)[]) => SQLExpr<T | null>;
+    dateAdd: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>, n: number, unit: IntervalUnit) => SQLExpr<Date>;
+    dateSub: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>, n: number, unit: IntervalUnit) => SQLExpr<Date>;
+    dateFormat: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>, fmt: string) => SQLExpr<string>;
+    dateDiff: (d1: FilterCols<TColEntries, Date> | SQLExpr<Date>, d2: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    quarter: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<bigint>;
+    weekOfYear: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<number>;
+    dayName: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<string>;
+    lastDay: (col: FilterCols<TColEntries, Date> | SQLExpr<Date>) => SQLExpr<Date>;
+    abs: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<bigint | number>;
+    ceil: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<bigint | number>;
+    floor: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<bigint | number>;
+    round: (col: FilterCols<TColEntries, number> | SQLExpr<number>, decimals?: number) => SQLExpr<number>;
+    power: (base: FilterCols<TColEntries, number> | SQLExpr<number>, exp: number | SQLExpr<number>) => SQLExpr<number>;
+    sqrt: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    mod: (col: FilterCols<TColEntries, number> | SQLExpr<number>, divisor: number) => SQLExpr<bigint | number>;
+    sign: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<bigint | number>;
+    exp: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    pi: () => SQLExpr<number>;
+    ln: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    log: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    log2: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    log10: (x: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number>;
+    truncate: (x: FilterCols<TColEntries, number> | SQLExpr<number>, n: number) => SQLExpr<number>;
+    rand: (seed?: number) => SQLExpr<number>;
+    jsonExtract: (col: FilterJsonCols<TColEntries> | SQLExpr<JSONValue>, path: string) => SQLExpr<JSONValue>;
+    jsonArray: (args_0: SQLExpr<unknown> | ColName<TColEntries>, ...args: (SQLExpr<unknown> | ColName<TColEntries>)[]) => SQLExpr<JSONValue[]>;
+    jsonObject: (pairs: [string, ColName<TColEntries> | SQLExpr<unknown>][]) => SQLExpr<JSONObject>;
+    cast: <T extends keyof MySQLCastTypeMap>(expr: ColName<TColEntries> | SQLExpr<unknown>, type: T) => SQLExpr<MySQLCastTypeMap[T]>;
+};
+type DialectFns<TColEntries extends [string, unknown] = never, TCriteria extends object = object> = ReturnType<typeof mysqlContextFns<TColEntries, TCriteria>>;
+declare const supportedJoinMethods: readonly ["join", "joinUnsafeTypeEnforced", "joinUnsafeIgnoreType", "innerJoin", "innerJoinUnsafeTypeEnforced", "innerJoinUnsafeIgnoreType", "leftJoin", "leftJoinUnsafeTypeEnforced", "leftJoinUnsafeIgnoreType", "rightJoin", "rightJoinUnsafeTypeEnforced", "rightJoinUnsafeIgnoreType", "crossJoin", "crossJoinUnsafeTypeEnforced", "crossJoinUnsafeIgnoreType", "manyToManyJoin"];
+declare const mysqlDialect: Dialect;
+
+export { type DialectFns, type IntervalUnit, mysqlContextFns, mysqlDialect, supportedJoinMethods };

package/dist/extend/dialects/mysql.js

@@ -0,0 +1,161 @@
+// src/sql-expr.ts
+function sqlExpr(sql) {
+  return { sql, toString() {
+    return sql;
+  } };
+}
+function resolveArg(arg, quoteFn) {
+  if (typeof arg !== "string") return arg.sql;
+  return quoteFn(arg);
+}
+
+// src/dialects/shared.ts
+var esc = (s) => s.replace(/'/g, "''");
+var flattenJsonObjectPairs = (pairs, quoteFn) => pairs.flatMap(([k, v]) => [`'${esc(k)}'`, resolveArg(v, quoteFn)]);
+
+// src/dialects/mysql.ts
+var MYSQL_CAST_TYPES = /* @__PURE__ */ new Set(["SIGNED", "UNSIGNED", "DECIMAL", "CHAR", "BINARY", "DATE", "DATETIME", "TIME", "JSON", "FLOAT", "DOUBLE"]);
+var mysqlContextFns = (quoteFn, condFn) => ({
+  avg: (col) => sqlExpr(`AVG(${resolveArg(col, quoteFn)})`),
+  sum: (col) => sqlExpr(`SUM(${resolveArg(col, quoteFn)})`),
+  countAll: () => sqlExpr("COUNT(*)"),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
+  length: (col) => sqlExpr(`LENGTH(${resolveArg(col, quoteFn)})`),
+  groupConcat: (col, sep) => sqlExpr(`GROUP_CONCAT(${quoteFn(col)}${sep !== void 0 ? ` SEPARATOR '${esc(sep)}'` : ""})`),
+  bitAnd: (col) => sqlExpr(`BIT_AND(${quoteFn(col)})`),
+  bitOr: (col) => sqlExpr(`BIT_OR(${quoteFn(col)})`),
+  bitXor: (col) => sqlExpr(`BIT_XOR(${quoteFn(col)})`),
+  stddev: (col) => sqlExpr(`STDDEV(${quoteFn(col)})`),
+  stddevSamp: (col) => sqlExpr(`STDDEV_SAMP(${quoteFn(col)})`),
+  variance: (col) => sqlExpr(`VARIANCE(${quoteFn(col)})`),
+  varSamp: (col) => sqlExpr(`VAR_SAMP(${quoteFn(col)})`),
+  jsonArrayAgg: (col) => sqlExpr(`JSON_ARRAYAGG(${quoteFn(col)})`),
+  jsonObjectAgg: (key, val) => sqlExpr(`JSON_OBJECTAGG(${quoteFn(key)}, ${quoteFn(val)})`),
+  concat: (...args) => {
+    if (args.length === 0) throw new Error("concat: requires at least one argument");
+    return sqlExpr(`CONCAT(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  substring: (col, start, len) => sqlExpr(`SUBSTRING(${resolveArg(col, quoteFn)}, ${start}${len !== void 0 ? `, ${len}` : ""})`),
+  left: (col, n) => sqlExpr(`LEFT(${resolveArg(col, quoteFn)}, ${n})`),
+  right: (col, n) => sqlExpr(`RIGHT(${resolveArg(col, quoteFn)}, ${n})`),
+  repeat: (col, n) => sqlExpr(`REPEAT(${resolveArg(col, quoteFn)}, ${n})`),
+  reverse: (col) => sqlExpr(`REVERSE(${resolveArg(col, quoteFn)})`),
+  lpad: (col, len, pad) => sqlExpr(`LPAD(${resolveArg(col, quoteFn)}, ${len}, '${esc(pad)}')`),
+  rpad: (col, len, pad) => sqlExpr(`RPAD(${resolveArg(col, quoteFn)}, ${len}, '${esc(pad)}')`),
+  locate: (substr, col) => sqlExpr(`LOCATE('${esc(substr)}', ${resolveArg(col, quoteFn)})`),
+  space: (n) => sqlExpr(`SPACE(${n})`),
+  // DateTime base fns (MySQL defaults)
+  now: () => sqlExpr("NOW()"),
+  curDate: () => sqlExpr("CURDATE()"),
+  year: (col) => sqlExpr(`YEAR(${resolveArg(col, quoteFn)})`),
+  month: (col) => sqlExpr(`MONTH(${resolveArg(col, quoteFn)})`),
+  day: (col) => sqlExpr(`DAY(${resolveArg(col, quoteFn)})`),
+  hour: (col) => sqlExpr(`HOUR(${resolveArg(col, quoteFn)})`),
+  minute: (col) => sqlExpr(`MINUTE(${resolveArg(col, quoteFn)})`),
+  second: (col) => sqlExpr(`SECOND(${resolveArg(col, quoteFn)})`),
+  // Control flow
+  $if: (cond, trueVal, falseVal) => {
+    const condSql = typeof cond === "object" && cond !== null && "sql" in cond ? cond.sql : condFn(cond);
+    return sqlExpr(`IF(${condSql}, ${trueVal.sql}, ${falseVal.sql})`);
+  },
+  ifNull: (col, fallback) => sqlExpr(`IFNULL(${resolveArg(col, quoteFn)}, ${fallback.sql})`),
+  // NULL-poisoned: returns NULL if any arg is NULL
+  greatest: (...args) => {
+    if (args.length === 0) throw new Error("greatest: requires at least one argument");
+    return sqlExpr(`GREATEST(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  // NULL-poisoned: returns NULL if any arg is NULL
+  least: (...args) => {
+    if (args.length === 0) throw new Error("least: requires at least one argument");
+    return sqlExpr(`LEAST(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  // DateTime fns (MySQL-only)
+  dateAdd: (col, n, unit) => {
+    if (!Number.isFinite(n)) throw new Error(`dateAdd: n must be a finite number, got ${n}`);
+    return sqlExpr(`DATE_ADD(${resolveArg(col, quoteFn)}, INTERVAL ${n} ${unit})`);
+  },
+  dateSub: (col, n, unit) => {
+    if (!Number.isFinite(n)) throw new Error(`dateSub: n must be a finite number, got ${n}`);
+    return sqlExpr(`DATE_SUB(${resolveArg(col, quoteFn)}, INTERVAL ${n} ${unit})`);
+  },
+  /**
+   * MySQL `DATE_FORMAT` returns `NULL` if the date column value is `NULL`.
+   * Unknown format specifiers are passed through literally, not as errors.
+   */
+  dateFormat: (col, fmt) => sqlExpr(`DATE_FORMAT(${resolveArg(col, quoteFn)}, '${esc(fmt)}')`),
+  dateDiff: (d1, d2) => sqlExpr(`DATEDIFF(${resolveArg(d1, quoteFn)}, ${resolveArg(d2, quoteFn)})`),
+  quarter: (col) => sqlExpr(`QUARTER(${resolveArg(col, quoteFn)})`),
+  weekOfYear: (col) => sqlExpr(`WEEKOFYEAR(${resolveArg(col, quoteFn)})`),
+  dayName: (col) => sqlExpr(`DAYNAME(${resolveArg(col, quoteFn)})`),
+  lastDay: (col) => sqlExpr(`LAST_DAY(${resolveArg(col, quoteFn)})`),
+  // ── Math ─────────────────────────────────────────────────────────────────
+  abs: (col) => sqlExpr(`ABS(${resolveArg(col, quoteFn)})`),
+  ceil: (col) => sqlExpr(`CEIL(${resolveArg(col, quoteFn)})`),
+  floor: (col) => sqlExpr(`FLOOR(${resolveArg(col, quoteFn)})`),
+  round: (col, decimals) => sqlExpr(decimals !== void 0 ? `ROUND(${resolveArg(col, quoteFn)}, ${decimals})` : `ROUND(${resolveArg(col, quoteFn)})`),
+  power: (base, exp) => sqlExpr(`POWER(${resolveArg(base, quoteFn)}, ${typeof exp === "number" ? exp : exp.sql})`),
+  sqrt: (col) => sqlExpr(`SQRT(${resolveArg(col, quoteFn)})`),
+  mod: (col, divisor) => sqlExpr(`MOD(${resolveArg(col, quoteFn)}, ${divisor})`),
+  sign: (col) => sqlExpr(`SIGN(${resolveArg(col, quoteFn)})`),
+  exp: (col) => sqlExpr(`EXP(${resolveArg(col, quoteFn)})`),
+  // ── Math (MySQL-specific) ─────────────────────────────────────────────────
+  pi: () => sqlExpr("PI()"),
+  ln: (x) => sqlExpr(`LN(${resolveArg(x, quoteFn)})`),
+  /** Natural log (ln(x)). Use `log10(x)` for base-10. Note: PG `log(x)` is base-10 — opposite semantics. */
+  log: (x) => sqlExpr(`LOG(${resolveArg(x, quoteFn)})`),
+  log2: (x) => sqlExpr(`LOG2(${resolveArg(x, quoteFn)})`),
+  log10: (x) => sqlExpr(`LOG10(${resolveArg(x, quoteFn)})`),
+  truncate: (x, n) => sqlExpr(`TRUNCATE(${resolveArg(x, quoteFn)}, ${n})`),
+  rand: (seed) => sqlExpr(seed !== void 0 ? `RAND(${seed})` : "RAND()"),
+  // ── JSON scalar fns ───────────────────────────────────────────────────────
+  jsonExtract: (col, path) => sqlExpr(`JSON_EXTRACT(${resolveArg(col, quoteFn)}, '${esc(path)}')`),
+  jsonArray: (...args) => sqlExpr(`JSON_ARRAY(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`),
+  jsonObject: (pairs) => sqlExpr(`JSON_OBJECT(${flattenJsonObjectPairs(pairs, quoteFn).join(", ")})`),
+  // ── Type coercion ────────────────────────────────────────────────────────
+  cast: (expr, type) => {
+    if (!MYSQL_CAST_TYPES.has(type)) throw new Error(`cast: invalid cast type '${String(type)}'`);
+    return sqlExpr(`CAST(${resolveArg(expr, quoteFn)} AS ${type})`);
+  }
+});
+var supportedJoinMethods = [
+  "join",
+  "joinUnsafeTypeEnforced",
+  "joinUnsafeIgnoreType",
+  "innerJoin",
+  "innerJoinUnsafeTypeEnforced",
+  "innerJoinUnsafeIgnoreType",
+  "leftJoin",
+  "leftJoinUnsafeTypeEnforced",
+  "leftJoinUnsafeIgnoreType",
+  "rightJoin",
+  "rightJoinUnsafeTypeEnforced",
+  "rightJoinUnsafeIgnoreType",
+  "crossJoin",
+  "crossJoinUnsafeTypeEnforced",
+  "crossJoinUnsafeIgnoreType",
+  "manyToManyJoin"
+];
+var mysqlDialect = {
+  name: "mysql",
+  needsBooleanCoercion: () => true,
+  quote: (id, _isAlias) => `\`${id}\``,
+  quoteTableIdentifier: (name, _isAlias) => `\`${name}\``,
+  quoteQualifiedColumn: (ref) => {
+    if (!ref.includes(".")) return `\`${ref}\``;
+    const [table, col] = ref.split(".", 2);
+    return `\`${table}\`.\`${col}\``;
+  },
+  quoteOrderByClause: (clause) => {
+    const parts = clause.trim().split(/\s+/);
+    const colRef = parts[0] ?? "";
+    const suffix = parts.slice(1).join(" ");
+    const quoted = colRef.includes(".") ? (() => {
+      const [table, col] = colRef.split(".", 2);
+      return `\`${table}\`.\`${col}\``;
+    })() : `\`${colRef}\``;
+    return suffix ? `${quoted} ${suffix}` : quoted;
+  }
+};
+
+export { mysqlContextFns, mysqlDialect, supportedJoinMethods };

package/dist/extend/dialects/postgresql-v6.d.ts

@@ -0,0 +1,101 @@
+import { ColName, FilterCols, FilterJsonCols } from './shared.js';
+import * as _prisma_client_runtime_client from '@prisma/client/runtime/client';
+import { Decimal } from '@prisma/client/runtime/client';
+import { PgExtractField, PgDateTruncUnit } from './postgresql.js';
+export { postgresqlDialect } from './postgresql.js';
+import { J as JSONValue, a as JSONObject } from '../types-B0F8m0ok.js';
+import { S as SQLExpr } from '../sql-expr-BaKWzJ-r.js';
+import './types.js';
+
+declare const postgresqlV6ContextFns: <TColEntries extends [string, unknown] = never>(quoteFn: (ref: string) => string) => {
+    countAll: () => SQLExpr<bigint>;
+    count: (col: ColName<TColEntries> | "*") => SQLExpr<bigint>;
+    countDistinct: (col: ColName<TColEntries>) => SQLExpr<bigint>;
+    ceil: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number | Decimal>;
+    floor: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number | Decimal>;
+    avg: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    sum: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    length: (col: SQLExpr<string> | FilterCols<TColEntries, string>) => SQLExpr<number>;
+    stringAgg: (col: ColName<TColEntries>, sep: string) => SQLExpr<string>;
+    arrayAgg: (col: ColName<TColEntries>) => SQLExpr<unknown[]>;
+    stddevPop: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    stddevSamp: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    varPop: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    varSamp: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    boolAnd: (col: FilterCols<TColEntries, boolean>) => SQLExpr<boolean>;
+    boolOr: (col: FilterCols<TColEntries, boolean>) => SQLExpr<boolean>;
+    jsonAgg: (col: ColName<TColEntries>) => SQLExpr<JSONValue[]>;
+    bitAnd: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    bitOr: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    jsonObjectAgg: (key: ColName<TColEntries>, val: ColName<TColEntries>) => SQLExpr<JSONValue>;
+    concat: (args_0: SQLExpr<string> | FilterCols<TColEntries, string>, ...args: (SQLExpr<string> | FilterCols<TColEntries, string>)[]) => SQLExpr<string>;
+    substring: (col: SQLExpr<string> | FilterCols<TColEntries, string>, start: number, len?: number) => SQLExpr<string>;
+    left: (col: SQLExpr<string> | FilterCols<TColEntries, string>, n: number) => SQLExpr<string>;
+    right: (col: SQLExpr<string> | FilterCols<TColEntries, string>, n: number) => SQLExpr<string>;
+    repeat: (col: SQLExpr<string> | FilterCols<TColEntries, string>, n: number) => SQLExpr<string>;
+    reverse: (col: SQLExpr<string> | FilterCols<TColEntries, string>) => SQLExpr<string>;
+    lpad: (col: SQLExpr<string> | FilterCols<TColEntries, string>, len: number, pad: string) => SQLExpr<string>;
+    rpad: (col: SQLExpr<string> | FilterCols<TColEntries, string>, len: number, pad: string) => SQLExpr<string>;
+    initcap: (col: SQLExpr<string> | FilterCols<TColEntries, string>) => SQLExpr<string>;
+    strpos: (col: SQLExpr<string> | FilterCols<TColEntries, string>, substr: string) => SQLExpr<number>;
+    splitPart: (col: SQLExpr<string> | FilterCols<TColEntries, string>, delimiter: string, field: number) => SQLExpr<string>;
+    btrim: (col: SQLExpr<string> | FilterCols<TColEntries, string>, chars?: string) => SQLExpr<string>;
+    md5: (col: SQLExpr<string> | FilterCols<TColEntries, string>) => SQLExpr<string>;
+    greatest: <T>(args_0: FilterCols<TColEntries, T> | SQLExpr<T>, ...args: (FilterCols<TColEntries, T> | SQLExpr<T>)[]) => SQLExpr<T>;
+    least: <T>(args_0: FilterCols<TColEntries, T> | SQLExpr<T>, ...args: (FilterCols<TColEntries, T> | SQLExpr<T>)[]) => SQLExpr<T>;
+    now: () => SQLExpr<Date>;
+    curDate: () => SQLExpr<Date>;
+    year: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    month: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    day: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    hour: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    minute: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    second: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    extract: (field: PgExtractField, col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    dateTrunc: (unit: PgDateTruncUnit, col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<Date>;
+    age: (ts1: SQLExpr<Date> | FilterCols<TColEntries, Date>, ts2?: SQLExpr<Date> | FilterCols<TColEntries, Date> | undefined) => SQLExpr<string>;
+    toDate: (text: SQLExpr<string> | FilterCols<TColEntries, string>, fmt: string) => SQLExpr<Date>;
+    abs: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    round: (col: SQLExpr<number> | FilterCols<TColEntries, number>, decimals?: number) => SQLExpr<number>;
+    power: (base: SQLExpr<number> | FilterCols<TColEntries, number>, exp: number | SQLExpr<number>) => SQLExpr<number>;
+    sqrt: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    mod: (col: SQLExpr<number> | FilterCols<TColEntries, number>, divisor: number) => SQLExpr<number>;
+    sign: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    exp: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    pi: () => SQLExpr<number>;
+    ln: (x: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    log: (x: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    logBase: (base: number, x: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    trunc: (x: SQLExpr<number> | FilterCols<TColEntries, number>, n?: number) => SQLExpr<number>;
+    div: (x: SQLExpr<number> | FilterCols<TColEntries, number>, y: number) => SQLExpr<number>;
+    random: () => SQLExpr<number>;
+    jsonExtract: (col: SQLExpr<_prisma_client_runtime_client.JsonValue> | FilterJsonCols<TColEntries>, path: string) => SQLExpr<JSONValue>;
+    jsonArray: (args_0: SQLExpr<unknown> | ColName<TColEntries>, ...args: (SQLExpr<unknown> | ColName<TColEntries>)[]) => SQLExpr<JSONValue[]>;
+    jsonObject: (pairs: [string, SQLExpr<unknown> | ColName<TColEntries>][]) => SQLExpr<JSONObject>;
+    cast: <T extends keyof {
+        INTEGER: number;
+        TEXT: string;
+        BIGINT: bigint;
+        BOOLEAN: boolean;
+        REAL: number;
+        NUMERIC: number;
+        DATE: Date;
+        TIMESTAMP: Date;
+        JSON: JSONValue;
+        JSONB: JSONValue;
+    }>(expr: SQLExpr<unknown> | ColName<TColEntries>, type: T) => SQLExpr<{
+        INTEGER: number;
+        TEXT: string;
+        BIGINT: bigint;
+        BOOLEAN: boolean;
+        REAL: number;
+        NUMERIC: number;
+        DATE: Date;
+        TIMESTAMP: Date;
+        JSON: JSONValue;
+        JSONB: JSONValue;
+    }[T]>;
+};
+type DialectFns<TColEntries extends [string, unknown] = never, _TCriteria extends object = object> = ReturnType<typeof postgresqlV6ContextFns<TColEntries>>;
+
+export { type DialectFns, PgDateTruncUnit, PgExtractField, postgresqlV6ContextFns };

package/dist/extend/dialects/postgresql-v6.js

@@ -0,0 +1,147 @@
+// src/sql-expr.ts
+function sqlExpr(sql) {
+  return { sql, toString() {
+    return sql;
+  } };
+}
+function resolveArg(arg, quoteFn) {
+  if (typeof arg !== "string") return arg.sql;
+  return quoteFn(arg);
+}
+
+// src/dialects/shared.ts
+var esc = (s) => s.replace(/'/g, "''");
+var flattenJsonObjectPairs = (pairs, quoteFn) => pairs.flatMap(([k, v]) => [`'${esc(k)}'`, resolveArg(v, quoteFn)]);
+
+// src/dialects/postgresql.ts
+var PG_CAST_TYPES = /* @__PURE__ */ new Set(["INTEGER", "TEXT", "BIGINT", "BOOLEAN", "REAL", "NUMERIC", "DATE", "TIMESTAMP", "JSON", "JSONB"]);
+var postgresqlContextFns = (quoteFn) => ({
+  avg: (col) => sqlExpr(`AVG(${resolveArg(col, quoteFn)})`),
+  sum: (col) => sqlExpr(`SUM(${resolveArg(col, quoteFn)})`),
+  countAll: () => sqlExpr("COUNT(*)"),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
+  length: (col) => sqlExpr(`LENGTH(${resolveArg(col, quoteFn)})`),
+  stringAgg: (col, sep) => sqlExpr(`STRING_AGG(${quoteFn(col)}, '${esc(sep)}')`),
+  arrayAgg: (col) => sqlExpr(`ARRAY_AGG(${quoteFn(col)})`),
+  stddevPop: (col) => sqlExpr(`STDDEV_POP(${quoteFn(col)})`),
+  stddevSamp: (col) => sqlExpr(`STDDEV_SAMP(${quoteFn(col)})`),
+  varPop: (col) => sqlExpr(`VAR_POP(${quoteFn(col)})`),
+  varSamp: (col) => sqlExpr(`VAR_SAMP(${quoteFn(col)})`),
+  boolAnd: (col) => sqlExpr(`BOOL_AND(${quoteFn(col)})`),
+  boolOr: (col) => sqlExpr(`BOOL_OR(${quoteFn(col)})`),
+  jsonAgg: (col) => sqlExpr(`JSON_AGG(${quoteFn(col)})`),
+  bitAnd: (col) => sqlExpr(`BIT_AND(${quoteFn(col)})`),
+  bitOr: (col) => sqlExpr(`BIT_OR(${quoteFn(col)})`),
+  jsonObjectAgg: (key, val) => sqlExpr(`JSON_OBJECT_AGG(${quoteFn(key)}, ${quoteFn(val)})`),
+  concat: (...args) => {
+    if (args.length === 0) throw new Error("concat: requires at least one argument");
+    return sqlExpr(`CONCAT(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  substring: (col, start, len) => sqlExpr(`SUBSTRING(${resolveArg(col, quoteFn)}, ${start}${len !== void 0 ? `, ${len}` : ""})`),
+  left: (col, n) => sqlExpr(`LEFT(${resolveArg(col, quoteFn)}, ${n})`),
+  right: (col, n) => sqlExpr(`RIGHT(${resolveArg(col, quoteFn)}, ${n})`),
+  repeat: (col, n) => sqlExpr(`REPEAT(${resolveArg(col, quoteFn)}, ${n})`),
+  reverse: (col) => sqlExpr(`REVERSE(${resolveArg(col, quoteFn)})`),
+  lpad: (col, len, pad) => sqlExpr(`LPAD(${resolveArg(col, quoteFn)}, ${len}, '${esc(pad)}')`),
+  rpad: (col, len, pad) => sqlExpr(`RPAD(${resolveArg(col, quoteFn)}, ${len}, '${esc(pad)}')`),
+  initcap: (col) => sqlExpr(`INITCAP(${resolveArg(col, quoteFn)})`),
+  strpos: (col, substr) => sqlExpr(`STRPOS(${resolveArg(col, quoteFn)}, '${esc(substr)}')`),
+  splitPart: (col, delimiter, field) => sqlExpr(`SPLIT_PART(${resolveArg(col, quoteFn)}, '${esc(delimiter)}', ${field})`),
+  btrim: (col, chars) => sqlExpr(`BTRIM(${resolveArg(col, quoteFn)}${chars !== void 0 ? `, '${esc(chars)}'` : ""})`),
+  md5: (col) => sqlExpr(`MD5(${resolveArg(col, quoteFn)})`),
+  // Control flow
+  greatest: (...args) => {
+    if (args.length === 0) throw new Error("greatest: requires at least one argument");
+    return sqlExpr(`GREATEST(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  least: (...args) => {
+    if (args.length === 0) throw new Error("least: requires at least one argument");
+    return sqlExpr(`LEAST(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`);
+  },
+  // DateTime overrides
+  now: () => sqlExpr("NOW()"),
+  curDate: () => sqlExpr("CURRENT_DATE"),
+  year: (col) => sqlExpr(`EXTRACT(YEAR FROM ${resolveArg(col, quoteFn)})::integer`),
+  month: (col) => sqlExpr(`EXTRACT(MONTH FROM ${resolveArg(col, quoteFn)})::integer`),
+  day: (col) => sqlExpr(`EXTRACT(DAY FROM ${resolveArg(col, quoteFn)})::integer`),
+  hour: (col) => sqlExpr(`EXTRACT(HOUR FROM ${resolveArg(col, quoteFn)})::integer`),
+  minute: (col) => sqlExpr(`EXTRACT(MINUTE FROM ${resolveArg(col, quoteFn)})::integer`),
+  second: (col) => sqlExpr(`EXTRACT(SECOND FROM ${resolveArg(col, quoteFn)})::integer`),
+  // PG-only DateTime fns
+  extract: (field, col) => sqlExpr(`EXTRACT(${field} FROM ${resolveArg(col, quoteFn)})`),
+  dateTrunc: (unit, col) => sqlExpr(`DATE_TRUNC('${unit}', ${resolveArg(col, quoteFn)})`),
+  /**
+   * PG `AGE()` returns an `interval`. Typed as `string` since node-postgres serializes
+   * intervals as strings (e.g. `"1 year 2 mons 3 days"`). Arithmetic on the result
+   * must be done in SQL, not JS — use `sqlExpr` to compose further expressions.
+   */
+  age: (ts1, ts2) => sqlExpr(ts2 !== void 0 ? `AGE(${resolveArg(ts1, quoteFn)}, ${resolveArg(ts2, quoteFn)})` : `AGE(${resolveArg(ts1, quoteFn)})`),
+  toDate: (text, fmt) => sqlExpr(`TO_DATE(${resolveArg(text, quoteFn)}, '${esc(fmt)}')`),
+  // ── Math ─────────────────────────────────────────────────────────────────
+  abs: (col) => sqlExpr(`ABS(${resolveArg(col, quoteFn)})`),
+  ceil: (col) => sqlExpr(`CEIL(${resolveArg(col, quoteFn)})`),
+  floor: (col) => sqlExpr(`FLOOR(${resolveArg(col, quoteFn)})`),
+  round: (col, decimals) => sqlExpr(decimals !== void 0 ? `ROUND(${resolveArg(col, quoteFn)}, ${decimals})` : `ROUND(${resolveArg(col, quoteFn)})`),
+  power: (base, exp) => sqlExpr(`POWER(${resolveArg(base, quoteFn)}, ${typeof exp === "number" ? exp : exp.sql})`),
+  sqrt: (col) => sqlExpr(`SQRT(${resolveArg(col, quoteFn)})`),
+  mod: (col, divisor) => sqlExpr(`MOD(${resolveArg(col, quoteFn)}, ${divisor})`),
+  sign: (col) => sqlExpr(`SIGN(${resolveArg(col, quoteFn)})`),
+  exp: (col) => sqlExpr(`EXP(${resolveArg(col, quoteFn)})`),
+  // ── Math (PostgreSQL-specific) ────────────────────────────────────────────
+  pi: () => sqlExpr("PI()"),
+  ln: (x) => sqlExpr(`LN(${resolveArg(x, quoteFn)})`),
+  log: (x) => sqlExpr(`LOG(${resolveArg(x, quoteFn)})`),
+  logBase: (base, x) => sqlExpr(`LOG(${base}, ${resolveArg(x, quoteFn)})`),
+  trunc: (x, n) => sqlExpr(n !== void 0 ? `TRUNC(${resolveArg(x, quoteFn)}, ${n})` : `TRUNC(${resolveArg(x, quoteFn)})`),
+  div: (x, y) => sqlExpr(`DIV(${resolveArg(x, quoteFn)}, ${y})`),
+  random: () => sqlExpr("RANDOM()"),
+  // ── JSON scalar fns ───────────────────────────────────────────────────────
+  /**
+   * Uses jsonb_path_query_first — requires PG 12+ (Prisma 5+ minimum).
+   * @note PG uses JSONPath syntax (e.g. `$.tags[0]`, `$.name`).
+   * MySQL/SQLite use SQL/JSON path syntax — paths are NOT cross-dialect compatible.
+   * Mismatched paths silently return NULL.
+   */
+  jsonExtract: (col, path) => sqlExpr(`jsonb_path_query_first(${resolveArg(col, quoteFn)}, '${esc(path)}')`),
+  jsonArray: (...args) => sqlExpr(`jsonb_build_array(${args.map((a) => resolveArg(a, quoteFn)).join(", ")})`),
+  jsonObject: (pairs) => sqlExpr(`jsonb_build_object(${flattenJsonObjectPairs(pairs, quoteFn).join(", ")})`),
+  // ── Type coercion ────────────────────────────────────────────────────────
+  cast: (expr, type) => {
+    if (!PG_CAST_TYPES.has(type)) throw new Error(`cast: invalid cast type '${String(type)}'`);
+    return sqlExpr(`CAST(${resolveArg(expr, quoteFn)} AS ${type})`);
+  }
+});
+var postgresqlDialect = {
+  name: "postgresql",
+  needsBooleanCoercion: () => false,
+  quote: (id, _isAlias) => `"${id}"`,
+  quoteTableIdentifier: (name, _isAlias) => `"${name}"`,
+  quoteQualifiedColumn: (ref) => {
+    if (!ref.includes(".")) return `"${ref}"`;
+    const [table, col] = ref.split(".", 2);
+    return `"${table}"."${col}"`;
+  },
+  quoteOrderByClause: (clause) => {
+    const parts = clause.trim().split(/\s+/);
+    const colRef = parts[0] ?? "";
+    const suffix = parts.slice(1).join(" ");
+    const quoted = colRef.includes(".") ? (() => {
+      const [table, col] = colRef.split(".", 2);
+      return `"${table}"."${col}"`;
+    })() : `"${colRef}"`;
+    return suffix ? `${quoted} ${suffix}` : quoted;
+  }
+};
+
+// src/dialects/postgresql-v6.ts
+var postgresqlV6ContextFns = (quoteFn) => ({
+  ...postgresqlContextFns(quoteFn),
+  countAll: () => sqlExpr("COUNT(*)"),
+  count: (col) => sqlExpr(col === "*" ? "COUNT(*)" : `COUNT(${quoteFn(col)})`),
+  countDistinct: (col) => sqlExpr(`COUNT(DISTINCT ${quoteFn(col)})`),
+  ceil: (col) => sqlExpr(`CEIL(${resolveArg(col, quoteFn)})`),
+  floor: (col) => sqlExpr(`FLOOR(${resolveArg(col, quoteFn)})`)
+});
+
+export { postgresqlDialect, postgresqlV6ContextFns };

package/dist/extend/dialects/postgresql-v7.d.ts

@@ -0,0 +1,101 @@
+import { ColName, FilterCols, FilterJsonCols } from './shared.js';
+import * as _prisma_client_runtime_client from '@prisma/client/runtime/client';
+import { Decimal } from '@prisma/client/runtime/client';
+import { PgExtractField, PgDateTruncUnit } from './postgresql.js';
+export { postgresqlDialect } from './postgresql.js';
+import { J as JSONValue, a as JSONObject } from '../types-B0F8m0ok.js';
+import { S as SQLExpr } from '../sql-expr-BaKWzJ-r.js';
+import './types.js';
+
+declare const postgresqlV7ContextFns: <TColEntries extends [string, unknown] = never>(quoteFn: (ref: string) => string) => {
+    countAll: () => SQLExpr<bigint>;
+    count: (col: ColName<TColEntries> | "*") => SQLExpr<bigint>;
+    countDistinct: (col: ColName<TColEntries>) => SQLExpr<bigint>;
+    ceil: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number | Decimal>;
+    floor: (col: FilterCols<TColEntries, number> | SQLExpr<number>) => SQLExpr<number | Decimal>;
+    avg: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    sum: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    length: (col: SQLExpr<string> | FilterCols<TColEntries, string>) => SQLExpr<number>;
+    stringAgg: (col: ColName<TColEntries>, sep: string) => SQLExpr<string>;
+    arrayAgg: (col: ColName<TColEntries>) => SQLExpr<unknown[]>;
+    stddevPop: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    stddevSamp: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    varPop: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    varSamp: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    boolAnd: (col: FilterCols<TColEntries, boolean>) => SQLExpr<boolean>;
+    boolOr: (col: FilterCols<TColEntries, boolean>) => SQLExpr<boolean>;
+    jsonAgg: (col: ColName<TColEntries>) => SQLExpr<JSONValue[]>;
+    bitAnd: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    bitOr: (col: FilterCols<TColEntries, number>) => SQLExpr<number>;
+    jsonObjectAgg: (key: ColName<TColEntries>, val: ColName<TColEntries>) => SQLExpr<JSONValue>;
+    concat: (args_0: SQLExpr<string> | FilterCols<TColEntries, string>, ...args: (SQLExpr<string> | FilterCols<TColEntries, string>)[]) => SQLExpr<string>;
+    substring: (col: SQLExpr<string> | FilterCols<TColEntries, string>, start: number, len?: number) => SQLExpr<string>;
+    left: (col: SQLExpr<string> | FilterCols<TColEntries, string>, n: number) => SQLExpr<string>;
+    right: (col: SQLExpr<string> | FilterCols<TColEntries, string>, n: number) => SQLExpr<string>;
+    repeat: (col: SQLExpr<string> | FilterCols<TColEntries, string>, n: number) => SQLExpr<string>;
+    reverse: (col: SQLExpr<string> | FilterCols<TColEntries, string>) => SQLExpr<string>;
+    lpad: (col: SQLExpr<string> | FilterCols<TColEntries, string>, len: number, pad: string) => SQLExpr<string>;
+    rpad: (col: SQLExpr<string> | FilterCols<TColEntries, string>, len: number, pad: string) => SQLExpr<string>;
+    initcap: (col: SQLExpr<string> | FilterCols<TColEntries, string>) => SQLExpr<string>;
+    strpos: (col: SQLExpr<string> | FilterCols<TColEntries, string>, substr: string) => SQLExpr<number>;
+    splitPart: (col: SQLExpr<string> | FilterCols<TColEntries, string>, delimiter: string, field: number) => SQLExpr<string>;
+    btrim: (col: SQLExpr<string> | FilterCols<TColEntries, string>, chars?: string) => SQLExpr<string>;
+    md5: (col: SQLExpr<string> | FilterCols<TColEntries, string>) => SQLExpr<string>;
+    greatest: <T>(args_0: FilterCols<TColEntries, T> | SQLExpr<T>, ...args: (FilterCols<TColEntries, T> | SQLExpr<T>)[]) => SQLExpr<T>;
+    least: <T>(args_0: FilterCols<TColEntries, T> | SQLExpr<T>, ...args: (FilterCols<TColEntries, T> | SQLExpr<T>)[]) => SQLExpr<T>;
+    now: () => SQLExpr<Date>;
+    curDate: () => SQLExpr<Date>;
+    year: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    month: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    day: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    hour: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    minute: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    second: (col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    extract: (field: PgExtractField, col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<number>;
+    dateTrunc: (unit: PgDateTruncUnit, col: SQLExpr<Date> | FilterCols<TColEntries, Date>) => SQLExpr<Date>;
+    age: (ts1: SQLExpr<Date> | FilterCols<TColEntries, Date>, ts2?: SQLExpr<Date> | FilterCols<TColEntries, Date> | undefined) => SQLExpr<string>;
+    toDate: (text: SQLExpr<string> | FilterCols<TColEntries, string>, fmt: string) => SQLExpr<Date>;
+    abs: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    round: (col: SQLExpr<number> | FilterCols<TColEntries, number>, decimals?: number) => SQLExpr<number>;
+    power: (base: SQLExpr<number> | FilterCols<TColEntries, number>, exp: number | SQLExpr<number>) => SQLExpr<number>;
+    sqrt: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    mod: (col: SQLExpr<number> | FilterCols<TColEntries, number>, divisor: number) => SQLExpr<number>;
+    sign: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    exp: (col: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    pi: () => SQLExpr<number>;
+    ln: (x: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    log: (x: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    logBase: (base: number, x: SQLExpr<number> | FilterCols<TColEntries, number>) => SQLExpr<number>;
+    trunc: (x: SQLExpr<number> | FilterCols<TColEntries, number>, n?: number) => SQLExpr<number>;
+    div: (x: SQLExpr<number> | FilterCols<TColEntries, number>, y: number) => SQLExpr<number>;
+    random: () => SQLExpr<number>;
+    jsonExtract: (col: SQLExpr<_prisma_client_runtime_client.JsonValue> | FilterJsonCols<TColEntries>, path: string) => SQLExpr<JSONValue>;
+    jsonArray: (args_0: SQLExpr<unknown> | ColName<TColEntries>, ...args: (SQLExpr<unknown> | ColName<TColEntries>)[]) => SQLExpr<JSONValue[]>;
+    jsonObject: (pairs: [string, SQLExpr<unknown> | ColName<TColEntries>][]) => SQLExpr<JSONObject>;
+    cast: <T extends keyof {
+        INTEGER: number;
+        TEXT: string;
+        BIGINT: bigint;
+        BOOLEAN: boolean;
+        REAL: number;
+        NUMERIC: number;
+        DATE: Date;
+        TIMESTAMP: Date;
+        JSON: JSONValue;
+        JSONB: JSONValue;
+    }>(expr: SQLExpr<unknown> | ColName<TColEntries>, type: T) => SQLExpr<{
+        INTEGER: number;
+        TEXT: string;
+        BIGINT: bigint;
+        BOOLEAN: boolean;
+        REAL: number;
+        NUMERIC: number;
+        DATE: Date;
+        TIMESTAMP: Date;
+        JSON: JSONValue;
+        JSONB: JSONValue;
+    }[T]>;
+};
+type DialectFns<TColEntries extends [string, unknown] = never, _TCriteria extends object = object> = ReturnType<typeof postgresqlV7ContextFns<TColEntries>>;
+
+export { type DialectFns, PgDateTruncUnit, PgExtractField, postgresqlV7ContextFns };