@metamorph/drizzle-orm 0.39.4

package/sql/expressions/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var expressions_exports = {};
+module.exports = __toCommonJS(expressions_exports);
+__reExport(expressions_exports, require("./conditions.cjs"), module.exports);
+__reExport(expressions_exports, require("./select.cjs"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./conditions.cjs"),
+  ...require("./select.cjs")
+});
+//# sourceMappingURL=index.cjs.map

package/sql/expressions/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/sql/expressions/index.ts"],"sourcesContent":["export * from './conditions.ts';\nexport * from './select.ts';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,gCAAc,4BAAd;AACA,gCAAc,wBADd;","names":[]}

package/sql/expressions/index.d.cts

@@ -0,0 +1,2 @@
+export * from "./conditions.cjs";
+export * from "./select.cjs";

package/sql/expressions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./conditions.js";
+export * from "./select.js";

package/sql/expressions/index.js

@@ -0,0 +1,3 @@
+export * from "./conditions.js";
+export * from "./select.js";
+//# sourceMappingURL=index.js.map

package/sql/expressions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/sql/expressions/index.ts"],"sourcesContent":["export * from './conditions.ts';\nexport * from './select.ts';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;","names":[]}

package/sql/expressions/select.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc2) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var select_exports = {};
+__export(select_exports, {
+  asc: () => asc,
+  desc: () => desc
+});
+module.exports = __toCommonJS(select_exports);
+var import_sql = require("../sql.cjs");
+function asc(column) {
+  return import_sql.sql`${column} asc`;
+}
+function desc(column) {
+  return import_sql.sql`${column} desc`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asc,
+  desc
+});
+//# sourceMappingURL=select.cjs.map

package/sql/expressions/select.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/sql/expressions/select.ts"],"sourcesContent":["import type { AnyColumn } from '../../column.ts';\nimport type { SQL, SQLWrapper } from '../sql.ts';\nimport { sql } from '../sql.ts';\n\n/**\n * Used in sorting, this specifies that the given\n * column or expression should be sorted in ascending\n * order. By the SQL standard, ascending order is the\n * default, so it is not usually necessary to specify\n * ascending sort order.\n *\n * ## Examples\n *\n * ```ts\n * // Return cars, starting with the oldest models\n * // and going in ascending order to the newest.\n * db.select().from(cars)\n *   .orderBy(asc(cars.year));\n * ```\n *\n * @see desc to sort in descending order\n */\nexport function asc(column: AnyColumn | SQLWrapper): SQL {\n\treturn sql`${column} asc`;\n}\n\n/**\n * Used in sorting, this specifies that the given\n * column or expression should be sorted in descending\n * order.\n *\n * ## Examples\n *\n * ```ts\n * // Select users, with the most recently created\n * // records coming first.\n * db.select().from(users)\n *   .orderBy(desc(users.createdAt));\n * ```\n *\n * @see asc to sort in ascending order\n */\nexport function desc(column: AnyColumn | SQLWrapper): SQL {\n\treturn sql`${column} desc`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,iBAAoB;AAoBb,SAAS,IAAI,QAAqC;AACxD,SAAO,iBAAM,MAAM;AACpB;AAkBO,SAAS,KAAK,QAAqC;AACzD,SAAO,iBAAM,MAAM;AACpB;","names":[]}

package/sql/expressions/select.d.cts

@@ -0,0 +1,38 @@
+import type { AnyColumn } from "../../column.cjs";
+import type { SQL, SQLWrapper } from "../sql.cjs";
+/**
+ * Used in sorting, this specifies that the given
+ * column or expression should be sorted in ascending
+ * order. By the SQL standard, ascending order is the
+ * default, so it is not usually necessary to specify
+ * ascending sort order.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Return cars, starting with the oldest models
+ * // and going in ascending order to the newest.
+ * db.select().from(cars)
+ *   .orderBy(asc(cars.year));
+ * ```
+ *
+ * @see desc to sort in descending order
+ */
+export declare function asc(column: AnyColumn | SQLWrapper): SQL;
+/**
+ * Used in sorting, this specifies that the given
+ * column or expression should be sorted in descending
+ * order.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select users, with the most recently created
+ * // records coming first.
+ * db.select().from(users)
+ *   .orderBy(desc(users.createdAt));
+ * ```
+ *
+ * @see asc to sort in ascending order
+ */
+export declare function desc(column: AnyColumn | SQLWrapper): SQL;

package/sql/expressions/select.d.ts

@@ -0,0 +1,38 @@
+import type { AnyColumn } from "../../column.js";
+import type { SQL, SQLWrapper } from "../sql.js";
+/**
+ * Used in sorting, this specifies that the given
+ * column or expression should be sorted in ascending
+ * order. By the SQL standard, ascending order is the
+ * default, so it is not usually necessary to specify
+ * ascending sort order.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Return cars, starting with the oldest models
+ * // and going in ascending order to the newest.
+ * db.select().from(cars)
+ *   .orderBy(asc(cars.year));
+ * ```
+ *
+ * @see desc to sort in descending order
+ */
+export declare function asc(column: AnyColumn | SQLWrapper): SQL;
+/**
+ * Used in sorting, this specifies that the given
+ * column or expression should be sorted in descending
+ * order.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select users, with the most recently created
+ * // records coming first.
+ * db.select().from(users)
+ *   .orderBy(desc(users.createdAt));
+ * ```
+ *
+ * @see asc to sort in ascending order
+ */
+export declare function desc(column: AnyColumn | SQLWrapper): SQL;

package/sql/expressions/select.js

@@ -0,0 +1,12 @@
+import { sql } from "../sql.js";
+function asc(column) {
+  return sql`${column} asc`;
+}
+function desc(column) {
+  return sql`${column} desc`;
+}
+export {
+  asc,
+  desc
+};
+//# sourceMappingURL=select.js.map

package/sql/expressions/select.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/sql/expressions/select.ts"],"sourcesContent":["import type { AnyColumn } from '../../column.ts';\nimport type { SQL, SQLWrapper } from '../sql.ts';\nimport { sql } from '../sql.ts';\n\n/**\n * Used in sorting, this specifies that the given\n * column or expression should be sorted in ascending\n * order. By the SQL standard, ascending order is the\n * default, so it is not usually necessary to specify\n * ascending sort order.\n *\n * ## Examples\n *\n * ```ts\n * // Return cars, starting with the oldest models\n * // and going in ascending order to the newest.\n * db.select().from(cars)\n *   .orderBy(asc(cars.year));\n * ```\n *\n * @see desc to sort in descending order\n */\nexport function asc(column: AnyColumn | SQLWrapper): SQL {\n\treturn sql`${column} asc`;\n}\n\n/**\n * Used in sorting, this specifies that the given\n * column or expression should be sorted in descending\n * order.\n *\n * ## Examples\n *\n * ```ts\n * // Select users, with the most recently created\n * // records coming first.\n * db.select().from(users)\n *   .orderBy(desc(users.createdAt));\n * ```\n *\n * @see asc to sort in ascending order\n */\nexport function desc(column: AnyColumn | SQLWrapper): SQL {\n\treturn sql`${column} desc`;\n}\n"],"mappings":"AAEA,SAAS,WAAW;AAoBb,SAAS,IAAI,QAAqC;AACxD,SAAO,MAAM,MAAM;AACpB;AAkBO,SAAS,KAAK,QAAqC;AACzD,SAAO,MAAM,MAAM;AACpB;","names":[]}

package/sql/functions/aggregate.cjs

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var aggregate_exports = {};
+__export(aggregate_exports, {
+  avg: () => avg,
+  avgDistinct: () => avgDistinct,
+  count: () => count,
+  countDistinct: () => countDistinct,
+  max: () => max,
+  min: () => min,
+  sum: () => sum,
+  sumDistinct: () => sumDistinct
+});
+module.exports = __toCommonJS(aggregate_exports);
+var import_column = require("../../column.cjs");
+var import_entity = require("../../entity.cjs");
+var import_sql = require("../sql.cjs");
+function count(expression) {
+  return import_sql.sql`count(${expression || import_sql.sql.raw("*")})`.mapWith(Number);
+}
+function countDistinct(expression) {
+  return import_sql.sql`count(distinct ${expression})`.mapWith(Number);
+}
+function avg(expression) {
+  return import_sql.sql`avg(${expression})`.mapWith(String);
+}
+function avgDistinct(expression) {
+  return import_sql.sql`avg(distinct ${expression})`.mapWith(String);
+}
+function sum(expression) {
+  return import_sql.sql`sum(${expression})`.mapWith(String);
+}
+function sumDistinct(expression) {
+  return import_sql.sql`sum(distinct ${expression})`.mapWith(String);
+}
+function max(expression) {
+  return import_sql.sql`max(${expression})`.mapWith((0, import_entity.is)(expression, import_column.Column) ? expression : String);
+}
+function min(expression) {
+  return import_sql.sql`min(${expression})`.mapWith((0, import_entity.is)(expression, import_column.Column) ? expression : String);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  avg,
+  avgDistinct,
+  count,
+  countDistinct,
+  max,
+  min,
+  sum,
+  sumDistinct
+});
+//# sourceMappingURL=aggregate.cjs.map

package/sql/functions/aggregate.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/sql/functions/aggregate.ts"],"sourcesContent":["import { type AnyColumn, Column } from '~/column.ts';\nimport { is } from '~/entity.ts';\nimport { type SQL, sql, type SQLWrapper } from '../sql.ts';\n\n/**\n * Returns the number of values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Number employees with null values\n * db.select({ value: count() }).from(employees)\n * // Number of employees where `name` is not null\n * db.select({ value: count(employees.name) }).from(employees)\n * ```\n *\n * @see countDistinct to get the number of non-duplicate values in `expression`\n */\nexport function count(expression?: SQLWrapper): SQL<number> {\n\treturn sql`count(${expression || sql.raw('*')})`.mapWith(Number);\n}\n\n/**\n * Returns the number of non-duplicate values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Number of employees where `name` is distinct\n * db.select({ value: countDistinct(employees.name) }).from(employees)\n * ```\n *\n * @see count to get the number of values in `expression`, including duplicates\n */\nexport function countDistinct(expression: SQLWrapper): SQL<number> {\n\treturn sql`count(distinct ${expression})`.mapWith(Number);\n}\n\n/**\n * Returns the average (arithmetic mean) of all non-null values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Average salary of an employee\n * db.select({ value: avg(employees.salary) }).from(employees)\n * ```\n *\n * @see avgDistinct to get the average of all non-null and non-duplicate values in `expression`\n */\nexport function avg(expression: SQLWrapper): SQL<string | null> {\n\treturn sql`avg(${expression})`.mapWith(String);\n}\n\n/**\n * Returns the average (arithmetic mean) of all non-null and non-duplicate values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Average salary of an employee where `salary` is distinct\n * db.select({ value: avgDistinct(employees.salary) }).from(employees)\n * ```\n *\n * @see avg to get the average of all non-null values in `expression`, including duplicates\n */\nexport function avgDistinct(expression: SQLWrapper): SQL<string | null> {\n\treturn sql`avg(distinct ${expression})`.mapWith(String);\n}\n\n/**\n * Returns the sum of all non-null values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Sum of every employee's salary\n * db.select({ value: sum(employees.salary) }).from(employees)\n * ```\n *\n * @see sumDistinct to get the sum of all non-null and non-duplicate values in `expression`\n */\nexport function sum(expression: SQLWrapper): SQL<string | null> {\n\treturn sql`sum(${expression})`.mapWith(String);\n}\n\n/**\n * Returns the sum of all non-null and non-duplicate values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Sum of every employee's salary where `salary` is distinct (no duplicates)\n * db.select({ value: sumDistinct(employees.salary) }).from(employees)\n * ```\n *\n * @see sum to get the sum of all non-null values in `expression`, including duplicates\n */\nexport function sumDistinct(expression: SQLWrapper): SQL<string | null> {\n\treturn sql`sum(distinct ${expression})`.mapWith(String);\n}\n\n/**\n * Returns the maximum value in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // The employee with the highest salary\n * db.select({ value: max(employees.salary) }).from(employees)\n * ```\n */\nexport function max<T extends SQLWrapper>(expression: T): SQL<(T extends AnyColumn ? T['_']['data'] : string) | null> {\n\treturn sql`max(${expression})`.mapWith(is(expression, Column) ? expression : String) as any;\n}\n\n/**\n * Returns the minimum value in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // The employee with the lowest salary\n * db.select({ value: min(employees.salary) }).from(employees)\n * ```\n */\nexport function min<T extends SQLWrapper>(expression: T): SQL<(T extends AnyColumn ? T['_']['data'] : string) | null> {\n\treturn sql`min(${expression})`.mapWith(is(expression, Column) ? expression : String) as any;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAuC;AACvC,oBAAmB;AACnB,iBAA+C;AAgBxC,SAAS,MAAM,YAAsC;AAC3D,SAAO,uBAAY,cAAc,eAAI,IAAI,GAAG,CAAC,IAAI,QAAQ,MAAM;AAChE;AAcO,SAAS,cAAc,YAAqC;AAClE,SAAO,gCAAqB,UAAU,IAAI,QAAQ,MAAM;AACzD;AAcO,SAAS,IAAI,YAA4C;AAC/D,SAAO,qBAAU,UAAU,IAAI,QAAQ,MAAM;AAC9C;AAcO,SAAS,YAAY,YAA4C;AACvE,SAAO,8BAAmB,UAAU,IAAI,QAAQ,MAAM;AACvD;AAcO,SAAS,IAAI,YAA4C;AAC/D,SAAO,qBAAU,UAAU,IAAI,QAAQ,MAAM;AAC9C;AAcO,SAAS,YAAY,YAA4C;AACvE,SAAO,8BAAmB,UAAU,IAAI,QAAQ,MAAM;AACvD;AAYO,SAAS,IAA0B,YAA4E;AACrH,SAAO,qBAAU,UAAU,IAAI,YAAQ,kBAAG,YAAY,oBAAM,IAAI,aAAa,MAAM;AACpF;AAYO,SAAS,IAA0B,YAA4E;AACrH,SAAO,qBAAU,UAAU,IAAI,YAAQ,kBAAG,YAAY,oBAAM,IAAI,aAAa,MAAM;AACpF;","names":[]}

package/sql/functions/aggregate.d.cts

@@ -0,0 +1,104 @@
+import { type AnyColumn } from "../../column.cjs";
+import { type SQL, type SQLWrapper } from "../sql.cjs";
+/**
+ * Returns the number of values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Number employees with null values
+ * db.select({ value: count() }).from(employees)
+ * // Number of employees where `name` is not null
+ * db.select({ value: count(employees.name) }).from(employees)
+ * ```
+ *
+ * @see countDistinct to get the number of non-duplicate values in `expression`
+ */
+export declare function count(expression?: SQLWrapper): SQL<number>;
+/**
+ * Returns the number of non-duplicate values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Number of employees where `name` is distinct
+ * db.select({ value: countDistinct(employees.name) }).from(employees)
+ * ```
+ *
+ * @see count to get the number of values in `expression`, including duplicates
+ */
+export declare function countDistinct(expression: SQLWrapper): SQL<number>;
+/**
+ * Returns the average (arithmetic mean) of all non-null values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Average salary of an employee
+ * db.select({ value: avg(employees.salary) }).from(employees)
+ * ```
+ *
+ * @see avgDistinct to get the average of all non-null and non-duplicate values in `expression`
+ */
+export declare function avg(expression: SQLWrapper): SQL<string | null>;
+/**
+ * Returns the average (arithmetic mean) of all non-null and non-duplicate values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Average salary of an employee where `salary` is distinct
+ * db.select({ value: avgDistinct(employees.salary) }).from(employees)
+ * ```
+ *
+ * @see avg to get the average of all non-null values in `expression`, including duplicates
+ */
+export declare function avgDistinct(expression: SQLWrapper): SQL<string | null>;
+/**
+ * Returns the sum of all non-null values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Sum of every employee's salary
+ * db.select({ value: sum(employees.salary) }).from(employees)
+ * ```
+ *
+ * @see sumDistinct to get the sum of all non-null and non-duplicate values in `expression`
+ */
+export declare function sum(expression: SQLWrapper): SQL<string | null>;
+/**
+ * Returns the sum of all non-null and non-duplicate values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Sum of every employee's salary where `salary` is distinct (no duplicates)
+ * db.select({ value: sumDistinct(employees.salary) }).from(employees)
+ * ```
+ *
+ * @see sum to get the sum of all non-null values in `expression`, including duplicates
+ */
+export declare function sumDistinct(expression: SQLWrapper): SQL<string | null>;
+/**
+ * Returns the maximum value in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // The employee with the highest salary
+ * db.select({ value: max(employees.salary) }).from(employees)
+ * ```
+ */
+export declare function max<T extends SQLWrapper>(expression: T): SQL<(T extends AnyColumn ? T['_']['data'] : string) | null>;
+/**
+ * Returns the minimum value in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // The employee with the lowest salary
+ * db.select({ value: min(employees.salary) }).from(employees)
+ * ```
+ */
+export declare function min<T extends SQLWrapper>(expression: T): SQL<(T extends AnyColumn ? T['_']['data'] : string) | null>;

package/sql/functions/aggregate.d.ts

@@ -0,0 +1,104 @@
+import { type AnyColumn } from "../../column.js";
+import { type SQL, type SQLWrapper } from "../sql.js";
+/**
+ * Returns the number of values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Number employees with null values
+ * db.select({ value: count() }).from(employees)
+ * // Number of employees where `name` is not null
+ * db.select({ value: count(employees.name) }).from(employees)
+ * ```
+ *
+ * @see countDistinct to get the number of non-duplicate values in `expression`
+ */
+export declare function count(expression?: SQLWrapper): SQL<number>;
+/**
+ * Returns the number of non-duplicate values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Number of employees where `name` is distinct
+ * db.select({ value: countDistinct(employees.name) }).from(employees)
+ * ```
+ *
+ * @see count to get the number of values in `expression`, including duplicates
+ */
+export declare function countDistinct(expression: SQLWrapper): SQL<number>;
+/**
+ * Returns the average (arithmetic mean) of all non-null values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Average salary of an employee
+ * db.select({ value: avg(employees.salary) }).from(employees)
+ * ```
+ *
+ * @see avgDistinct to get the average of all non-null and non-duplicate values in `expression`
+ */
+export declare function avg(expression: SQLWrapper): SQL<string | null>;
+/**
+ * Returns the average (arithmetic mean) of all non-null and non-duplicate values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Average salary of an employee where `salary` is distinct
+ * db.select({ value: avgDistinct(employees.salary) }).from(employees)
+ * ```
+ *
+ * @see avg to get the average of all non-null values in `expression`, including duplicates
+ */
+export declare function avgDistinct(expression: SQLWrapper): SQL<string | null>;
+/**
+ * Returns the sum of all non-null values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Sum of every employee's salary
+ * db.select({ value: sum(employees.salary) }).from(employees)
+ * ```
+ *
+ * @see sumDistinct to get the sum of all non-null and non-duplicate values in `expression`
+ */
+export declare function sum(expression: SQLWrapper): SQL<string | null>;
+/**
+ * Returns the sum of all non-null and non-duplicate values in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Sum of every employee's salary where `salary` is distinct (no duplicates)
+ * db.select({ value: sumDistinct(employees.salary) }).from(employees)
+ * ```
+ *
+ * @see sum to get the sum of all non-null values in `expression`, including duplicates
+ */
+export declare function sumDistinct(expression: SQLWrapper): SQL<string | null>;
+/**
+ * Returns the maximum value in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // The employee with the highest salary
+ * db.select({ value: max(employees.salary) }).from(employees)
+ * ```
+ */
+export declare function max<T extends SQLWrapper>(expression: T): SQL<(T extends AnyColumn ? T['_']['data'] : string) | null>;
+/**
+ * Returns the minimum value in `expression`.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // The employee with the lowest salary
+ * db.select({ value: min(employees.salary) }).from(employees)
+ * ```
+ */
+export declare function min<T extends SQLWrapper>(expression: T): SQL<(T extends AnyColumn ? T['_']['data'] : string) | null>;

package/sql/functions/aggregate.js

@@ -0,0 +1,38 @@
+import { Column } from "../../column.js";
+import { is } from "../../entity.js";
+import { sql } from "../sql.js";
+function count(expression) {
+  return sql`count(${expression || sql.raw("*")})`.mapWith(Number);
+}
+function countDistinct(expression) {
+  return sql`count(distinct ${expression})`.mapWith(Number);
+}
+function avg(expression) {
+  return sql`avg(${expression})`.mapWith(String);
+}
+function avgDistinct(expression) {
+  return sql`avg(distinct ${expression})`.mapWith(String);
+}
+function sum(expression) {
+  return sql`sum(${expression})`.mapWith(String);
+}
+function sumDistinct(expression) {
+  return sql`sum(distinct ${expression})`.mapWith(String);
+}
+function max(expression) {
+  return sql`max(${expression})`.mapWith(is(expression, Column) ? expression : String);
+}
+function min(expression) {
+  return sql`min(${expression})`.mapWith(is(expression, Column) ? expression : String);
+}
+export {
+  avg,
+  avgDistinct,
+  count,
+  countDistinct,
+  max,
+  min,
+  sum,
+  sumDistinct
+};
+//# sourceMappingURL=aggregate.js.map

package/sql/functions/aggregate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/sql/functions/aggregate.ts"],"sourcesContent":["import { type AnyColumn, Column } from '~/column.ts';\nimport { is } from '~/entity.ts';\nimport { type SQL, sql, type SQLWrapper } from '../sql.ts';\n\n/**\n * Returns the number of values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Number employees with null values\n * db.select({ value: count() }).from(employees)\n * // Number of employees where `name` is not null\n * db.select({ value: count(employees.name) }).from(employees)\n * ```\n *\n * @see countDistinct to get the number of non-duplicate values in `expression`\n */\nexport function count(expression?: SQLWrapper): SQL<number> {\n\treturn sql`count(${expression || sql.raw('*')})`.mapWith(Number);\n}\n\n/**\n * Returns the number of non-duplicate values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Number of employees where `name` is distinct\n * db.select({ value: countDistinct(employees.name) }).from(employees)\n * ```\n *\n * @see count to get the number of values in `expression`, including duplicates\n */\nexport function countDistinct(expression: SQLWrapper): SQL<number> {\n\treturn sql`count(distinct ${expression})`.mapWith(Number);\n}\n\n/**\n * Returns the average (arithmetic mean) of all non-null values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Average salary of an employee\n * db.select({ value: avg(employees.salary) }).from(employees)\n * ```\n *\n * @see avgDistinct to get the average of all non-null and non-duplicate values in `expression`\n */\nexport function avg(expression: SQLWrapper): SQL<string | null> {\n\treturn sql`avg(${expression})`.mapWith(String);\n}\n\n/**\n * Returns the average (arithmetic mean) of all non-null and non-duplicate values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Average salary of an employee where `salary` is distinct\n * db.select({ value: avgDistinct(employees.salary) }).from(employees)\n * ```\n *\n * @see avg to get the average of all non-null values in `expression`, including duplicates\n */\nexport function avgDistinct(expression: SQLWrapper): SQL<string | null> {\n\treturn sql`avg(distinct ${expression})`.mapWith(String);\n}\n\n/**\n * Returns the sum of all non-null values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Sum of every employee's salary\n * db.select({ value: sum(employees.salary) }).from(employees)\n * ```\n *\n * @see sumDistinct to get the sum of all non-null and non-duplicate values in `expression`\n */\nexport function sum(expression: SQLWrapper): SQL<string | null> {\n\treturn sql`sum(${expression})`.mapWith(String);\n}\n\n/**\n * Returns the sum of all non-null and non-duplicate values in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // Sum of every employee's salary where `salary` is distinct (no duplicates)\n * db.select({ value: sumDistinct(employees.salary) }).from(employees)\n * ```\n *\n * @see sum to get the sum of all non-null values in `expression`, including duplicates\n */\nexport function sumDistinct(expression: SQLWrapper): SQL<string | null> {\n\treturn sql`sum(distinct ${expression})`.mapWith(String);\n}\n\n/**\n * Returns the maximum value in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // The employee with the highest salary\n * db.select({ value: max(employees.salary) }).from(employees)\n * ```\n */\nexport function max<T extends SQLWrapper>(expression: T): SQL<(T extends AnyColumn ? T['_']['data'] : string) | null> {\n\treturn sql`max(${expression})`.mapWith(is(expression, Column) ? expression : String) as any;\n}\n\n/**\n * Returns the minimum value in `expression`.\n *\n * ## Examples\n *\n * ```ts\n * // The employee with the lowest salary\n * db.select({ value: min(employees.salary) }).from(employees)\n * ```\n */\nexport function min<T extends SQLWrapper>(expression: T): SQL<(T extends AnyColumn ? T['_']['data'] : string) | null> {\n\treturn sql`min(${expression})`.mapWith(is(expression, Column) ? expression : String) as any;\n}\n"],"mappings":"AAAA,SAAyB,cAAc;AACvC,SAAS,UAAU;AACnB,SAAmB,WAA4B;AAgBxC,SAAS,MAAM,YAAsC;AAC3D,SAAO,YAAY,cAAc,IAAI,IAAI,GAAG,CAAC,IAAI,QAAQ,MAAM;AAChE;AAcO,SAAS,cAAc,YAAqC;AAClE,SAAO,qBAAqB,UAAU,IAAI,QAAQ,MAAM;AACzD;AAcO,SAAS,IAAI,YAA4C;AAC/D,SAAO,UAAU,UAAU,IAAI,QAAQ,MAAM;AAC9C;AAcO,SAAS,YAAY,YAA4C;AACvE,SAAO,mBAAmB,UAAU,IAAI,QAAQ,MAAM;AACvD;AAcO,SAAS,IAAI,YAA4C;AAC/D,SAAO,UAAU,UAAU,IAAI,QAAQ,MAAM;AAC9C;AAcO,SAAS,YAAY,YAA4C;AACvE,SAAO,mBAAmB,UAAU,IAAI,QAAQ,MAAM;AACvD;AAYO,SAAS,IAA0B,YAA4E;AACrH,SAAO,UAAU,UAAU,IAAI,QAAQ,GAAG,YAAY,MAAM,IAAI,aAAa,MAAM;AACpF;AAYO,SAAS,IAA0B,YAA4E;AACrH,SAAO,UAAU,UAAU,IAAI,QAAQ,GAAG,YAAY,MAAM,IAAI,aAAa,MAAM;AACpF;","names":[]}

package/sql/functions/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var functions_exports = {};
+module.exports = __toCommonJS(functions_exports);
+__reExport(functions_exports, require("./aggregate.cjs"), module.exports);
+__reExport(functions_exports, require("./vector.cjs"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./aggregate.cjs"),
+  ...require("./vector.cjs")
+});
+//# sourceMappingURL=index.cjs.map

package/sql/functions/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/sql/functions/index.ts"],"sourcesContent":["export * from './aggregate.ts';\nexport * from './vector.ts';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,8BAAc,2BAAd;AACA,8BAAc,wBADd;","names":[]}

package/sql/functions/index.d.cts

@@ -0,0 +1,2 @@
+export * from "./aggregate.cjs";
+export * from "./vector.cjs";

package/sql/functions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./aggregate.js";
+export * from "./vector.js";

package/sql/functions/index.js

@@ -0,0 +1,3 @@
+export * from "./aggregate.js";
+export * from "./vector.js";
+//# sourceMappingURL=index.js.map

package/sql/functions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/sql/functions/index.ts"],"sourcesContent":["export * from './aggregate.ts';\nexport * from './vector.ts';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;","names":[]}

package/sql/functions/vector.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vector_exports = {};
+__export(vector_exports, {
+  cosineDistance: () => cosineDistance,
+  hammingDistance: () => hammingDistance,
+  innerProduct: () => innerProduct,
+  jaccardDistance: () => jaccardDistance,
+  l1Distance: () => l1Distance,
+  l2Distance: () => l2Distance
+});
+module.exports = __toCommonJS(vector_exports);
+var import_sql = require("../sql.cjs");
+function toSql(value) {
+  return JSON.stringify(value);
+}
+function l2Distance(column, value) {
+  if (Array.isArray(value)) {
+    return import_sql.sql`${column} <-> ${toSql(value)}`;
+  }
+  return import_sql.sql`${column} <-> ${value}`;
+}
+function l1Distance(column, value) {
+  if (Array.isArray(value)) {
+    return import_sql.sql`${column} <+> ${toSql(value)}`;
+  }
+  return import_sql.sql`${column} <+> ${value}`;
+}
+function innerProduct(column, value) {
+  if (Array.isArray(value)) {
+    return import_sql.sql`${column} <#> ${toSql(value)}`;
+  }
+  return import_sql.sql`${column} <#> ${value}`;
+}
+function cosineDistance(column, value) {
+  if (Array.isArray(value)) {
+    return import_sql.sql`${column} <=> ${toSql(value)}`;
+  }
+  return import_sql.sql`${column} <=> ${value}`;
+}
+function hammingDistance(column, value) {
+  if (Array.isArray(value)) {
+    return import_sql.sql`${column} <~> ${toSql(value)}`;
+  }
+  return import_sql.sql`${column} <~> ${value}`;
+}
+function jaccardDistance(column, value) {
+  if (Array.isArray(value)) {
+    return import_sql.sql`${column} <%> ${toSql(value)}`;
+  }
+  return import_sql.sql`${column} <%> ${value}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cosineDistance,
+  hammingDistance,
+  innerProduct,
+  jaccardDistance,
+  l1Distance,
+  l2Distance
+});
+//# sourceMappingURL=vector.cjs.map