relq 1.0.0

package/dist/esm/functions/advanced-functions.js

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

package/dist/esm/functions/case-builder.js

@@ -0,0 +1,58 @@
+import format from "../../addons/pg-format.js";
+export 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 += ` ${format.ident(this.expression)}`;
+        }
+        for (const clause of this.whenClauses) {
+            if (this.expression) {
+                sql += ` WHEN ${format('%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 ${format.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 format.ident(value);
+        }
+        return format('%L', value);
+    }
+}
+export function Case(expression) {
+    return new CaseBuilder(expression);
+}
+export default Case;

package/dist/esm/functions/geometric-functions.js

@@ -0,0 +1,97 @@
+import format from "../../addons/pg-format.js";
+import { SqlFunction } from "./sql-functions.js";
+export class GeometricFunctions {
+    static area(column) {
+        return new SqlFunction(format('area(%I)', column));
+    }
+    static center(column) {
+        return new SqlFunction(format('center(%I)', column));
+    }
+    static diameter(column) {
+        return new SqlFunction(format('diameter(%I)', column));
+    }
+    static height(column) {
+        return new SqlFunction(format('height(%I)', column));
+    }
+    static width(column) {
+        return new SqlFunction(format('width(%I)', column));
+    }
+    static geoLength(column) {
+        return new SqlFunction(format('length(%I)', column));
+    }
+    static npoints(column) {
+        return new SqlFunction(format('npoints(%I)', column));
+    }
+    static isclosed(column) {
+        return new SqlFunction(format('isclosed(%I)', column));
+    }
+    static isopen(column) {
+        return new SqlFunction(format('isopen(%I)', column));
+    }
+    static pclose(column) {
+        return new SqlFunction(format('pclose(%I)', column));
+    }
+    static popen(column) {
+        return new SqlFunction(format('popen(%I)', column));
+    }
+    static radius(column) {
+        return new SqlFunction(format('radius(%I)', column));
+    }
+    static slope(point1, point2) {
+        return new SqlFunction(format('slope(%I, %I)', point1, point2));
+    }
+    static distance(column, value) {
+        return new SqlFunction(format('%I <-> %L', column, value));
+    }
+    static toBox(column) {
+        return new SqlFunction(format('box(%I)', column));
+    }
+    static toCircle(column) {
+        return new SqlFunction(format('circle(%I)', column));
+    }
+    static toLine(point1, point2) {
+        return new SqlFunction(format('line(%I, %I)', point1, point2));
+    }
+    static toLseg(point1, point2) {
+        return new SqlFunction(format('lseg(%I, %I)', point1, point2));
+    }
+    static toPath(column) {
+        return new SqlFunction(format('path(%I)', column));
+    }
+    static toPoint(column) {
+        return new SqlFunction(format('point(%I)', column));
+    }
+    static toPolygon(column) {
+        return new SqlFunction(format('polygon(%I)', column));
+    }
+    static point(x, y) {
+        if (typeof x === 'string' && typeof y === 'string') {
+            return new SqlFunction(format('point(%I, %I)', x, y));
+        }
+        return new SqlFunction(format('point(%s, %s)', x, y));
+    }
+    static box(point1, point2) {
+        return new SqlFunction(format('box(%I, %I)', point1, point2));
+    }
+    static circle(center, radius) {
+        return new SqlFunction(format('circle(%I, %s)', center, radius));
+    }
+    static translate(column, offset) {
+        return new SqlFunction(format('%I + point %L', column, offset));
+    }
+    static scale(column, factor) {
+        return new SqlFunction(format('%I * point %L', column, factor));
+    }
+    static rotate(column, rotation) {
+        return new SqlFunction(format('%I / point %L', column, rotation));
+    }
+    static intersection(line1, line2) {
+        return new SqlFunction(format('%I # %I', line1, line2));
+    }
+    static closestPoint(lseg, point) {
+        return new SqlFunction(format('%I ## %I', lseg, point));
+    }
+    static boundingBox(column) {
+        return new SqlFunction(format('box(%I)', column));
+    }
+}

package/dist/esm/functions/index.js

@@ -0,0 +1,171 @@
+export { SqlFunction } from "./sql-functions.js";
+import { StringFunctions, DateTimeFunctions, MathFunctions } from "./sql-functions.js";
+import { ArrayFunctions, JsonbFunctions, AggregateFunctions, ConditionalFunctions } from "./advanced-functions.js";
+import { GeometricFunctions } from "./geometric-functions.js";
+import { NetworkFunctions } from "./network-functions.js";
+export class F {
+    static concat = StringFunctions.concat;
+    static concat_ws = StringFunctions.concat_ws;
+    static lower = StringFunctions.lower;
+    static upper = StringFunctions.upper;
+    static initcap = StringFunctions.initcap;
+    static substring = StringFunctions.substring;
+    static substr = StringFunctions.substr;
+    static strLength = StringFunctions.length;
+    static char_length = StringFunctions.char_length;
+    static octet_length = StringFunctions.octet_length;
+    static bit_length = StringFunctions.bit_length;
+    static trim = StringFunctions.trim;
+    static ltrim = StringFunctions.ltrim;
+    static rtrim = StringFunctions.rtrim;
+    static btrim = StringFunctions.btrim;
+    static position = StringFunctions.position;
+    static strpos = StringFunctions.strpos;
+    static replace = StringFunctions.replace;
+    static translate = StringFunctions.translate;
+    static repeat = StringFunctions.repeat;
+    static lpad = StringFunctions.lpad;
+    static rpad = StringFunctions.rpad;
+    static reverse = StringFunctions.reverse;
+    static split_part = StringFunctions.split_part;
+    static regexp_match = StringFunctions.regexp_match;
+    static regexp_matches = StringFunctions.regexp_matches;
+    static regexp_replace = StringFunctions.regexp_replace;
+    static regexp_split_to_array = StringFunctions.regexp_split_to_array;
+    static regexp_split_to_table = StringFunctions.regexp_split_to_table;
+    static encode = StringFunctions.encode;
+    static decode = StringFunctions.decode;
+    static md5 = StringFunctions.md5;
+    static ascii = StringFunctions.ascii;
+    static chr = StringFunctions.chr;
+    static to_hex = StringFunctions.to_hex;
+    static lpad_zero = StringFunctions.lpad_zero;
+    static format = StringFunctions.format;
+    static quote_ident = StringFunctions.quote_ident;
+    static quote_literal = StringFunctions.quote_literal;
+    static quote_nullable = StringFunctions.quote_nullable;
+    static now = DateTimeFunctions.now;
+    static current_date = DateTimeFunctions.current_date;
+    static current_time = DateTimeFunctions.current_time;
+    static current_timestamp = DateTimeFunctions.current_timestamp;
+    static transaction_timestamp = DateTimeFunctions.transaction_timestamp;
+    static statement_timestamp = DateTimeFunctions.statement_timestamp;
+    static clock_timestamp = DateTimeFunctions.clock_timestamp;
+    static localtimestamp = DateTimeFunctions.localtimestamp;
+    static date_trunc = DateTimeFunctions.date_trunc;
+    static extract = DateTimeFunctions.extract;
+    static date_part = DateTimeFunctions.date_part;
+    static age = DateTimeFunctions.age;
+    static make_date = DateTimeFunctions.make_date;
+    static make_time = DateTimeFunctions.make_time;
+    static make_timestamp = DateTimeFunctions.make_timestamp;
+    static make_interval = DateTimeFunctions.make_interval;
+    static to_timestamp = DateTimeFunctions.to_timestamp;
+    static to_timestamp_format = DateTimeFunctions.to_timestamp_format;
+    static to_date = DateTimeFunctions.to_date;
+    static to_char = DateTimeFunctions.to_char;
+    static timezone = DateTimeFunctions.timezone;
+    static justify_days = DateTimeFunctions.justify_days;
+    static justify_hours = DateTimeFunctions.justify_hours;
+    static justify_interval = DateTimeFunctions.justify_interval;
+    static isfinite = DateTimeFunctions.isfinite;
+    static abs = MathFunctions.abs;
+    static sign = MathFunctions.sign;
+    static ceil = MathFunctions.ceil;
+    static ceiling = MathFunctions.ceiling;
+    static floor = MathFunctions.floor;
+    static round = MathFunctions.round;
+    static trunc = MathFunctions.trunc;
+    static mod = MathFunctions.mod;
+    static div = MathFunctions.div;
+    static power = MathFunctions.power;
+    static sqrt = MathFunctions.sqrt;
+    static cbrt = MathFunctions.cbrt;
+    static exp = MathFunctions.exp;
+    static ln = MathFunctions.ln;
+    static log10 = MathFunctions.log10;
+    static log = MathFunctions.log;
+    static pi = MathFunctions.pi;
+    static degrees = MathFunctions.degrees;
+    static radians = MathFunctions.radians;
+    static sin = MathFunctions.sin;
+    static cos = MathFunctions.cos;
+    static tan = MathFunctions.tan;
+    static asin = MathFunctions.asin;
+    static acos = MathFunctions.acos;
+    static atan = MathFunctions.atan;
+    static atan2 = MathFunctions.atan2;
+    static random = MathFunctions.random;
+    static setseed = MathFunctions.setseed;
+    static gcd = MathFunctions.gcd;
+    static lcm = MathFunctions.lcm;
+    static factorial = MathFunctions.factorial;
+    static greatest = MathFunctions.greatest;
+    static least = MathFunctions.least;
+    static width_bucket = MathFunctions.width_bucket;
+    static array_length = ArrayFunctions.array_length;
+    static array_append = ArrayFunctions.array_append;
+    static array_prepend = ArrayFunctions.array_prepend;
+    static array_cat = ArrayFunctions.array_cat;
+    static array_remove = ArrayFunctions.array_remove;
+    static array_replace = ArrayFunctions.array_replace;
+    static array_position = ArrayFunctions.array_position;
+    static array_positions = ArrayFunctions.array_positions;
+    static array_dims = ArrayFunctions.array_dims;
+    static array_lower = ArrayFunctions.array_lower;
+    static array_upper = ArrayFunctions.array_upper;
+    static cardinality = ArrayFunctions.cardinality;
+    static array_to_string = ArrayFunctions.array_to_string;
+    static string_to_array = ArrayFunctions.string_to_array;
+    static unnest = ArrayFunctions.unnest;
+    static array_fill = ArrayFunctions.array_fill;
+    static array_agg = ArrayFunctions.array_agg;
+    static array_agg_order = ArrayFunctions.array_agg_order;
+    static jsonb_array_length = JsonbFunctions.jsonb_array_length;
+    static jsonb_each = JsonbFunctions.jsonb_each;
+    static jsonb_each_text = JsonbFunctions.jsonb_each_text;
+    static jsonb_object_keys = JsonbFunctions.jsonb_object_keys;
+    static jsonb_array_elements = JsonbFunctions.jsonb_array_elements;
+    static jsonb_array_elements_text = JsonbFunctions.jsonb_array_elements_text;
+    static jsonb_typeof = JsonbFunctions.jsonb_typeof;
+    static jsonb_strip_nulls = JsonbFunctions.jsonb_strip_nulls;
+    static jsonb_pretty = JsonbFunctions.jsonb_pretty;
+    static jsonb_set = JsonbFunctions.jsonb_set;
+    static jsonb_insert = JsonbFunctions.jsonb_insert;
+    static jsonb_build_object = JsonbFunctions.jsonb_build_object;
+    static jsonb_build_array = JsonbFunctions.jsonb_build_array;
+    static jsonb_to_text = JsonbFunctions.jsonb_to_text;
+    static text_to_jsonb = JsonbFunctions.text_to_jsonb;
+    static jsonb_agg = JsonbFunctions.jsonb_agg;
+    static jsonb_object_agg = JsonbFunctions.jsonb_object_agg;
+    static count = AggregateFunctions.count;
+    static count_distinct = AggregateFunctions.count_distinct;
+    static sum = AggregateFunctions.sum;
+    static avg = AggregateFunctions.avg;
+    static min = AggregateFunctions.min;
+    static max = AggregateFunctions.max;
+    static string_agg = AggregateFunctions.string_agg;
+    static string_agg_order = AggregateFunctions.string_agg_order;
+    static bool_and = AggregateFunctions.bool_and;
+    static bool_or = AggregateFunctions.bool_or;
+    static every = AggregateFunctions.every;
+    static bit_and = AggregateFunctions.bit_and;
+    static bit_or = AggregateFunctions.bit_or;
+    static stddev_pop = AggregateFunctions.stddev_pop;
+    static stddev_samp = AggregateFunctions.stddev_samp;
+    static stddev = AggregateFunctions.stddev;
+    static var_pop = AggregateFunctions.var_pop;
+    static var_samp = AggregateFunctions.var_samp;
+    static variance = AggregateFunctions.variance;
+    static corr = AggregateFunctions.corr;
+    static covar_pop = AggregateFunctions.covar_pop;
+    static covar_samp = AggregateFunctions.covar_samp;
+    static percentile_cont = AggregateFunctions.percentile_cont;
+    static percentile_disc = AggregateFunctions.percentile_disc;
+    static mode = AggregateFunctions.mode;
+    static coalesce = ConditionalFunctions.coalesce;
+    static nullif = ConditionalFunctions.nullif;
+    static geometric = GeometricFunctions;
+    static network = NetworkFunctions;
+}
+export { StringFunctions, DateTimeFunctions, MathFunctions, ArrayFunctions, JsonbFunctions, AggregateFunctions, ConditionalFunctions, GeometricFunctions, NetworkFunctions };

package/dist/esm/functions/network-functions.js

@@ -0,0 +1,79 @@
+import format from "../../addons/pg-format.js";
+import { SqlFunction } from "./sql-functions.js";
+export class NetworkFunctions {
+    static abbrev(column) {
+        return new SqlFunction(format('abbrev(%I)', column));
+    }
+    static broadcast(column) {
+        return new SqlFunction(format('broadcast(%I)', column));
+    }
+    static family(column) {
+        return new SqlFunction(format('family(%I)', column));
+    }
+    static host(column) {
+        return new SqlFunction(format('host(%I)', column));
+    }
+    static hostmask(column) {
+        return new SqlFunction(format('hostmask(%I)', column));
+    }
+    static inetMerge(column1, column2) {
+        return new SqlFunction(format('inet_merge(%I, %I)', column1, column2));
+    }
+    static inetMergeValue(column, value) {
+        return new SqlFunction(format('inet_merge(%I, inet %L)', column, value));
+    }
+    static inetSameFamily(column1, column2) {
+        return new SqlFunction(format('inet_same_family(%I, %I)', column1, column2));
+    }
+    static masklen(column) {
+        return new SqlFunction(format('masklen(%I)', column));
+    }
+    static netmask(column) {
+        return new SqlFunction(format('netmask(%I)', column));
+    }
+    static network(column) {
+        return new SqlFunction(format('network(%I)', column));
+    }
+    static setMasklen(column, length) {
+        return new SqlFunction(format('set_masklen(%I, %s)', column, length));
+    }
+    static setCidrMasklen(column, length) {
+        return new SqlFunction(format('set_masklen(%I, %s)', column, length));
+    }
+    static text(column) {
+        return new SqlFunction(format('text(%I)', column));
+    }
+    static trunc(column) {
+        return new SqlFunction(format('trunc(%I)', column));
+    }
+    static macaddr8(column) {
+        return new SqlFunction(format('macaddr8(%I)', column));
+    }
+    static bitwiseNot(column) {
+        return new SqlFunction(format('~ %I', column));
+    }
+    static bitwiseAnd(column, value) {
+        return new SqlFunction(format('%I & inet %L', column, value));
+    }
+    static bitwiseOr(column, value) {
+        return new SqlFunction(format('%I | inet %L', column, value));
+    }
+    static add(column, offset) {
+        return new SqlFunction(format('%I + %s', column, offset));
+    }
+    static subtract(column, offset) {
+        return new SqlFunction(format('%I - %s', column, offset));
+    }
+    static difference(column1, column2) {
+        return new SqlFunction(format('%I - %I', column1, column2));
+    }
+    static inet(value) {
+        return new SqlFunction(format('inet %L', value));
+    }
+    static cidr(value) {
+        return new SqlFunction(format('cidr %L', value));
+    }
+    static macaddr(value) {
+        return new SqlFunction(format('macaddr %L', value));
+    }
+}