relq 1.0.0

package/dist/cjs/function/create-function-builder.cjs

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropFunctionBuilder = exports.CreateFunctionBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const relq_errors_1 = require("../errors/relq-errors.cjs");
+class CreateFunctionBuilder {
+    functionName;
+    __parameters = [];
+    returnType;
+    __returnsTable;
+    __returnsSetOf;
+    __language = 'plpgsql';
+    functionBody;
+    volatility = 'VOLATILE';
+    security = 'INVOKER';
+    __parallel = 'UNSAFE';
+    costValue;
+    rowsValue;
+    strictFlag = false;
+    leakproofFlag = false;
+    orReplaceFlag = false;
+    constructor(functionName) {
+        this.functionName = functionName;
+    }
+    parameter(name, type, defaultValue, mode = 'IN') {
+        this.__parameters.push({ name, type, default: defaultValue, mode });
+        return this;
+    }
+    parameters(params) {
+        Object.entries(params).forEach(([name, type]) => {
+            this.__parameters.push({ name, type });
+        });
+        return this;
+    }
+    returns(type) {
+        this.returnType = type;
+        return this;
+    }
+    returnsTable(columns) {
+        this.__returnsTable = columns;
+        return this;
+    }
+    returnsSetOf(type) {
+        this.__returnsSetOf = type;
+        return this;
+    }
+    language(lang) {
+        this.__language = lang;
+        return this;
+    }
+    body(sql) {
+        this.functionBody = sql.trim();
+        return this;
+    }
+    immutable() {
+        this.volatility = 'IMMUTABLE';
+        return this;
+    }
+    stable() {
+        this.volatility = 'STABLE';
+        return this;
+    }
+    volatile() {
+        this.volatility = 'VOLATILE';
+        return this;
+    }
+    securityDefiner() {
+        this.security = 'DEFINER';
+        return this;
+    }
+    securityInvoker() {
+        this.security = 'INVOKER';
+        return this;
+    }
+    parallel(safety) {
+        this.__parallel = safety;
+        return this;
+    }
+    strict() {
+        this.strictFlag = true;
+        return this;
+    }
+    leakproof() {
+        this.leakproofFlag = true;
+        return this;
+    }
+    cost(estimatedCost) {
+        this.costValue = estimatedCost;
+        return this;
+    }
+    rows(estimatedRows) {
+        this.rowsValue = estimatedRows;
+        return this;
+    }
+    orReplace() {
+        this.orReplaceFlag = true;
+        return this;
+    }
+    toString() {
+        if (!this.returnType && !this.__returnsTable && !this.__returnsSetOf) {
+            throw new relq_errors_1.RelqBuilderError('Return type is required', { builder: 'CreateFunctionBuilder', missing: 'returnType', hint: 'Use .returns(), .returnsTable(), or .returnsSetOf()' });
+        }
+        if (!this.functionBody) {
+            throw new relq_errors_1.RelqBuilderError('Function body is required', { builder: 'CreateFunctionBuilder', missing: 'body', hint: 'Use .body()' });
+        }
+        let sql = 'CREATE';
+        if (this.orReplaceFlag) {
+            sql += ' OR REPLACE';
+        }
+        sql += ` FUNCTION ${pg_format_1.default.ident(this.functionName)}`;
+        if (this.__parameters.length > 0) {
+            const params = this.__parameters.map(p => {
+                let paramSQL = '';
+                if (p.mode && p.mode !== 'IN') {
+                    paramSQL += `${p.mode} `;
+                }
+                paramSQL += `${pg_format_1.default.ident(p.name)} ${p.type}`;
+                if (p.default !== undefined) {
+                    paramSQL += ` DEFAULT ${(0, pg_format_1.default)('%L', p.default)}`;
+                }
+                return paramSQL;
+            });
+            sql += `(${params.join(', ')})`;
+        }
+        else {
+            sql += '()';
+        }
+        if (this.__returnsTable) {
+            const tableCols = Object.entries(this.__returnsTable)
+                .map(([name, type]) => `${pg_format_1.default.ident(name)} ${type}`)
+                .join(', ');
+            sql += ` RETURNS TABLE(${tableCols})`;
+        }
+        else if (this.__returnsSetOf) {
+            sql += ` RETURNS SETOF ${this.__returnsSetOf}`;
+        }
+        else {
+            sql += ` RETURNS ${this.returnType}`;
+        }
+        sql += ` LANGUAGE ${this.language}`;
+        sql += ` ${this.volatility}`;
+        if (this.strictFlag) {
+            sql += ' STRICT';
+        }
+        sql += ` SECURITY ${this.security}`;
+        sql += ` PARALLEL ${this.__parallel}`;
+        if (this.leakproofFlag) {
+            sql += ' LEAKPROOF';
+        }
+        if (this.costValue !== undefined) {
+            sql += ` COST ${this.costValue}`;
+        }
+        if (this.rowsValue !== undefined) {
+            sql += ` ROWS ${this.rowsValue}`;
+        }
+        sql += ` AS $$${this.functionBody}$$`;
+        return sql;
+    }
+}
+exports.CreateFunctionBuilder = CreateFunctionBuilder;
+class DropFunctionBuilder {
+    functionName;
+    parameterTypes;
+    ifExistsFlag = false;
+    cascadeFlag = false;
+    constructor(functionName, parameterTypes) {
+        this.functionName = functionName;
+        this.parameterTypes = parameterTypes;
+    }
+    ifExists() {
+        this.ifExistsFlag = true;
+        return this;
+    }
+    cascade() {
+        this.cascadeFlag = true;
+        return this;
+    }
+    toString() {
+        let sql = 'DROP FUNCTION';
+        if (this.ifExistsFlag) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${pg_format_1.default.ident(this.functionName)}`;
+        if (this.parameterTypes && this.parameterTypes.length > 0) {
+            sql += `(${this.parameterTypes.join(', ')})`;
+        }
+        if (this.cascadeFlag) {
+            sql += ' CASCADE';
+        }
+        return sql;
+    }
+}
+exports.DropFunctionBuilder = DropFunctionBuilder;

package/dist/cjs/function/index.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropFunctionBuilder = exports.CreateFunctionBuilder = void 0;
+var create_function_builder_1 = require("./create-function-builder.cjs");
+Object.defineProperty(exports, "CreateFunctionBuilder", { enumerable: true, get: function () { return create_function_builder_1.CreateFunctionBuilder; } });
+Object.defineProperty(exports, "DropFunctionBuilder", { enumerable: true, get: function () { return create_function_builder_1.DropFunctionBuilder; } });

package/dist/cjs/functions/advanced-functions.cjs

@@ -0,0 +1,241 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Conditional = exports.Aggregate = exports.Jsonb = exports.Array = exports.ConditionalFunctions = exports.AggregateFunctions = exports.JsonbFunctions = exports.ArrayFunctions = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const sql_functions_1 = require("./sql-functions.cjs");
+class ArrayFunctions {
+    static array_length(array, dimension = 1) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_length(%I, %s)', array, dimension));
+    }
+    static array_append(array, element) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_append(%I, %L)', array, element));
+    }
+    static array_prepend(element, array) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_prepend(%L, %I)', element, array));
+    }
+    static array_cat(array1, array2) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_cat(%I, %I)', array1, array2));
+    }
+    static array_remove(array, element) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_remove(%I, %L)', array, element));
+    }
+    static array_replace(array, from, to) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_replace(%I, %L, %L)', array, from, to));
+    }
+    static array_position(array, element) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_position(%I, %L)', array, element));
+    }
+    static array_positions(array, element) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_positions(%I, %L)', array, element));
+    }
+    static array_dims(array) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_dims(%I)', array));
+    }
+    static array_lower(array, dimension) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_lower(%I, %s)', array, dimension));
+    }
+    static array_upper(array, dimension) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_upper(%I, %s)', array, dimension));
+    }
+    static cardinality(array) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('cardinality(%I)', array));
+    }
+    static array_to_string(array, delimiter, nullString) {
+        if (nullString !== undefined) {
+            return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_to_string(%I, %L, %L)', array, delimiter, nullString));
+        }
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_to_string(%I, %L)', array, delimiter));
+    }
+    static string_to_array(str, delimiter, nullString) {
+        if (nullString !== undefined) {
+            return new sql_functions_1.SqlFunction((0, pg_format_1.default)('string_to_array(%I, %L, %L)', str, delimiter, nullString));
+        }
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('string_to_array(%I, %L)', str, delimiter));
+    }
+    static unnest(array) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('unnest(%I)', array));
+    }
+    static array_fill(value, dimensions) {
+        const dims = (0, pg_format_1.default)('%L', dimensions);
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_fill(%L, %s)', value, dims));
+    }
+    static array_agg(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_agg(%I)', expression));
+    }
+    static array_agg_order(expression, orderBy, direction = 'ASC') {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('array_agg(%I ORDER BY %I %s)', expression, orderBy, direction));
+    }
+}
+exports.ArrayFunctions = ArrayFunctions;
+exports.Array = ArrayFunctions;
+class JsonbFunctions {
+    static jsonb_array_length(jsonb) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_array_length(%I)', jsonb));
+    }
+    static jsonb_each(jsonb) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_each(%I)', jsonb));
+    }
+    static jsonb_each_text(jsonb) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_each_text(%I)', jsonb));
+    }
+    static jsonb_object_keys(jsonb) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_object_keys(%I)', jsonb));
+    }
+    static jsonb_array_elements(jsonb) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_array_elements(%I)', jsonb));
+    }
+    static jsonb_array_elements_text(jsonb) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_array_elements_text(%I)', jsonb));
+    }
+    static jsonb_typeof(jsonb) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_typeof(%I)', jsonb));
+    }
+    static jsonb_strip_nulls(jsonb) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_strip_nulls(%I)', jsonb));
+    }
+    static jsonb_pretty(jsonb) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_pretty(%I)', jsonb));
+    }
+    static jsonb_set(target, path, newValue, createMissing = true) {
+        const pathStr = (0, pg_format_1.default)('%L', `{${path.join(',')}}`);
+        const valueStr = (0, pg_format_1.default)('%L', JSON.stringify(newValue));
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_set(%I, %s, %s, %s)', target, pathStr, valueStr, createMissing));
+    }
+    static jsonb_insert(target, path, newValue, insertAfter = false) {
+        const pathStr = (0, pg_format_1.default)('%L', `{${path.join(',')}}`);
+        const valueStr = (0, pg_format_1.default)('%L', JSON.stringify(newValue));
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_insert(%I, %s, %s, %s)', target, pathStr, valueStr, insertAfter));
+    }
+    static jsonb_build_object(...keyValuePairs) {
+        const args = keyValuePairs.map((v, idx) => idx % 2 === 0
+            ? (0, pg_format_1.default)('%L', v)
+            : (typeof v === 'string' && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(v))
+                ? pg_format_1.default.ident(v)
+                : (0, pg_format_1.default)('%L', v)).join(', ');
+        return new sql_functions_1.SqlFunction(`jsonb_build_object(${args})`);
+    }
+    static jsonb_build_array(...values) {
+        const args = values.map(v => typeof v === 'string' && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(v)
+            ? pg_format_1.default.ident(v)
+            : (0, pg_format_1.default)('%L', v)).join(', ');
+        return new sql_functions_1.SqlFunction(`jsonb_build_array(${args})`);
+    }
+    static jsonb_to_text(jsonb) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('%I::text', jsonb));
+    }
+    static text_to_jsonb(text) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('%I::jsonb', text));
+    }
+    static jsonb_agg(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_agg(%I)', expression));
+    }
+    static jsonb_object_agg(keys, values) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('jsonb_object_agg(%I, %I)', keys, values));
+    }
+}
+exports.JsonbFunctions = JsonbFunctions;
+exports.Jsonb = JsonbFunctions;
+class AggregateFunctions {
+    static count(expression = '*') {
+        if (expression === '*') {
+            return new sql_functions_1.SqlFunction('COUNT(*)');
+        }
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('COUNT(%I)', expression));
+    }
+    static count_distinct(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('COUNT(DISTINCT %I)', expression));
+    }
+    static sum(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('SUM(%I)', expression));
+    }
+    static avg(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('AVG(%I)', expression));
+    }
+    static min(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('MIN(%I)', expression));
+    }
+    static max(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('MAX(%I)', expression));
+    }
+    static string_agg(expression, delimiter) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('string_agg(%I, %L)', expression, delimiter));
+    }
+    static string_agg_order(expression, delimiter, orderBy, direction = 'ASC') {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('string_agg(%I, %L ORDER BY %I %s)', expression, delimiter, orderBy, direction));
+    }
+    static bool_and(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('bool_and(%I)', expression));
+    }
+    static bool_or(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('bool_or(%I)', expression));
+    }
+    static every(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('every(%I)', expression));
+    }
+    static bit_and(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('bit_and(%I)', expression));
+    }
+    static bit_or(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('bit_or(%I)', expression));
+    }
+    static stddev_pop(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('stddev_pop(%I)', expression));
+    }
+    static stddev_samp(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('stddev_samp(%I)', expression));
+    }
+    static stddev(expression) {
+        return this.stddev_samp(expression);
+    }
+    static var_pop(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('var_pop(%I)', expression));
+    }
+    static var_samp(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('var_samp(%I)', expression));
+    }
+    static variance(expression) {
+        return this.var_samp(expression);
+    }
+    static corr(y, x) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('corr(%I, %I)', y, x));
+    }
+    static covar_pop(y, x) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('covar_pop(%I, %I)', y, x));
+    }
+    static covar_samp(y, x) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('covar_samp(%I, %I)', y, x));
+    }
+    static percentile_cont(percentile, expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('percentile_cont(%s) WITHIN GROUP (ORDER BY %I)', percentile, expression));
+    }
+    static percentile_disc(percentile, expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('percentile_disc(%s) WITHIN GROUP (ORDER BY %I)', percentile, expression));
+    }
+    static mode(expression) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('mode() WITHIN GROUP (ORDER BY %I)', expression));
+    }
+}
+exports.AggregateFunctions = AggregateFunctions;
+exports.Aggregate = AggregateFunctions;
+class ConditionalFunctions {
+    static coalesce(...values) {
+        const args = values.map(v => typeof v === 'string' && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(v)
+            ? pg_format_1.default.ident(v)
+            : (0, pg_format_1.default)('%L', v)).join(', ');
+        return new sql_functions_1.SqlFunction(`COALESCE(${args})`);
+    }
+    static nullif(value1, value2) {
+        const arg1 = typeof value1 === 'string' && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value1)
+            ? pg_format_1.default.ident(value1)
+            : (0, pg_format_1.default)('%L', value1);
+        const arg2 = typeof value2 === 'string' && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value2)
+            ? pg_format_1.default.ident(value2)
+            : (0, pg_format_1.default)('%L', value2);
+        return new sql_functions_1.SqlFunction(`NULLIF(${arg1}, ${arg2})`);
+    }
+}
+exports.ConditionalFunctions = ConditionalFunctions;
+exports.Conditional = ConditionalFunctions;

package/dist/cjs/functions/case-builder.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaseBuilder = void 0;
+exports.Case = Case;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+class CaseBuilder {
+    expression;
+    whenClauses = [];
+    elseResult;
+    constructor(expression) {
+        this.expression = expression;
+    }
+    when(condition, result) {
+        this.whenClauses.push({
+            condition: String(condition),
+            result
+        });
+        return this;
+    }
+    else(result) {
+        this.elseResult = result;
+        return this;
+    }
+    build() {
+        let sql = 'CASE';
+        if (this.expression) {
+            sql += ` ${pg_format_1.default.ident(this.expression)}`;
+        }
+        for (const clause of this.whenClauses) {
+            if (this.expression) {
+                sql += ` WHEN ${(0, pg_format_1.default)('%L', clause.condition)} THEN ${this.formatValue(clause.result)}`;
+            }
+            else {
+                sql += ` WHEN ${clause.condition} THEN ${this.formatValue(clause.result)}`;
+            }
+        }
+        if (this.elseResult !== undefined) {
+            sql += ` ELSE ${this.formatValue(this.elseResult)}`;
+        }
+        sql += ' END';
+        return sql;
+    }
+    as(alias) {
+        return `${this.build()} AS ${pg_format_1.default.ident(alias)}`;
+    }
+    toString() {
+        return this.build();
+    }
+    formatValue(value) {
+        if (value === null) {
+            return 'NULL';
+        }
+        if (typeof value === 'string' && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {
+            return pg_format_1.default.ident(value);
+        }
+        return (0, pg_format_1.default)('%L', value);
+    }
+}
+exports.CaseBuilder = CaseBuilder;
+function Case(expression) {
+    return new CaseBuilder(expression);
+}
+exports.default = Case;

package/dist/cjs/functions/geometric-functions.cjs

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometricFunctions = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const sql_functions_1 = require("./sql-functions.cjs");
+class GeometricFunctions {
+    static area(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('area(%I)', column));
+    }
+    static center(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('center(%I)', column));
+    }
+    static diameter(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('diameter(%I)', column));
+    }
+    static height(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('height(%I)', column));
+    }
+    static width(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('width(%I)', column));
+    }
+    static geoLength(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('length(%I)', column));
+    }
+    static npoints(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('npoints(%I)', column));
+    }
+    static isclosed(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('isclosed(%I)', column));
+    }
+    static isopen(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('isopen(%I)', column));
+    }
+    static pclose(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('pclose(%I)', column));
+    }
+    static popen(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('popen(%I)', column));
+    }
+    static radius(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('radius(%I)', column));
+    }
+    static slope(point1, point2) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('slope(%I, %I)', point1, point2));
+    }
+    static distance(column, value) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('%I <-> %L', column, value));
+    }
+    static toBox(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('box(%I)', column));
+    }
+    static toCircle(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('circle(%I)', column));
+    }
+    static toLine(point1, point2) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('line(%I, %I)', point1, point2));
+    }
+    static toLseg(point1, point2) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('lseg(%I, %I)', point1, point2));
+    }
+    static toPath(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('path(%I)', column));
+    }
+    static toPoint(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('point(%I)', column));
+    }
+    static toPolygon(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('polygon(%I)', column));
+    }
+    static point(x, y) {
+        if (typeof x === 'string' && typeof y === 'string') {
+            return new sql_functions_1.SqlFunction((0, pg_format_1.default)('point(%I, %I)', x, y));
+        }
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('point(%s, %s)', x, y));
+    }
+    static box(point1, point2) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('box(%I, %I)', point1, point2));
+    }
+    static circle(center, radius) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('circle(%I, %s)', center, radius));
+    }
+    static translate(column, offset) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('%I + point %L', column, offset));
+    }
+    static scale(column, factor) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('%I * point %L', column, factor));
+    }
+    static rotate(column, rotation) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('%I / point %L', column, rotation));
+    }
+    static intersection(line1, line2) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('%I # %I', line1, line2));
+    }
+    static closestPoint(lseg, point) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('%I ## %I', lseg, point));
+    }
+    static boundingBox(column) {
+        return new sql_functions_1.SqlFunction((0, pg_format_1.default)('box(%I)', column));
+    }
+}
+exports.GeometricFunctions = GeometricFunctions;