@jrrd/postgresjs 0.0.4

package/dist/index.js

@@ -0,0 +1,1735 @@
+'use strict';
+
+var pg = require('pg');
+
+class ColumnLike {
+    #alias
+    #cast
+
+    constructor() {
+        this.#alias = undefined;
+        this.#cast = undefined;
+    }
+
+    as(name) {
+        this.#alias = name;
+
+        return this
+    }
+
+    cast(type) {
+        this.#cast = type;
+
+        return this
+    }
+
+    toString() {
+        return (this.#cast ? `::${this.#cast}` : '') + (this.#alias ? ` AS "${this.#alias}"` : '')
+    }
+}
+
+class SqlColumn extends ColumnLike {
+    #name
+
+    /**
+     * @param {string} name
+     */
+    constructor(name) {
+        super();
+        this.#name = name;
+    }
+
+
+    toString() {
+        return this.#name.split('.').map(token => `"${token}"`).join('.') + super.toString()
+    }
+}
+
+class SqlCase extends ColumnLike {
+    #caseWhen = []
+    #caseElse
+
+    /**
+     * @param {ConditionLike} condition
+     * @param {*} value
+     */
+    when(condition, value) {
+        this.#caseWhen.push([condition, typeof value === 'string' ? new SqlColumn(value) : value]);
+
+        return this
+    }
+
+    else(value) {
+        this.#caseElse = typeof value === 'string' ? new SqlColumn(value) : value;
+
+        return this
+    }
+
+    toString() {
+        return `${this.#caseWhen.map(([condition, value]) => `WHEN ${condition} THEN ${value}`).join('\n')}` +
+            `\n${this.#caseElse}` +
+            `\nEND${super.toString()}`
+    }
+}
+
+class SqlCoalesce extends ColumnLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        super();
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `COALESCE(${this.#left}, ${this.#right})${super.toString()}`
+    }
+}
+
+class SqlConcat extends ColumnLike {
+    #columns
+
+    /**
+     * @param  {...ColumnLike} columns
+     */
+    constructor(...columns) {
+        super();
+        this.#columns = columns.map(column => typeof column === 'string' ? new SqlColumn(column) : column);
+    }
+
+    toString() {
+        return `CONCAT(${this.#columns.join(', ')})${super.toString()}`
+    }
+}
+
+class SqlDateInterval extends ColumnLike {
+    #unit
+    #value
+
+    /**
+     * @param {number} value
+     * @param {string} unit
+     */
+    constructor(value, unit) {
+        this.#value = value;
+        this.#unit = unit;
+    }
+    toString() {
+        return `${this.#value > 0 ? '+' : '-'} interval '${Math.abs(this.#value)} ${this.#unit}${Math.abs(this.#value) === 1 ? '' : 's'}'`
+    }
+}
+
+class SqlDatePart extends ColumnLike {
+    #part
+    #column
+
+    /**
+     * @param {string} part
+     * @param {ColumnLike} column
+     */
+    constructor(part, column) {
+        super();
+        this.#part = part;
+        this.#column = typeof column === 'string' ? new SqlColumn(column) : column;
+    }
+
+    toString() {
+        return `date_part('${this.#part}', ${this.#column})${super.toString()}`
+    }
+}
+
+class SqlDateTrunc extends ColumnLike {
+    #part
+    #column
+
+    constructor(part, column) {
+        super();
+        this.#part = part;
+        this.#column = typeof column === 'string' ? new SqlColumn(column) : column;
+    }
+
+    toString() {
+        return `date_trunc('${this.#part}', ${this.#column})${super.toString()}`
+    }
+}
+
+class SqlString extends ColumnLike {
+    #value
+
+    /**
+     * @param {string} value
+     */
+    constructor(value) {
+        super();
+        this.#value = value;
+    }
+
+    toString() {
+        return `'${this.#value}'${super.toString()}`
+    }
+}
+
+class SqlLPad extends ColumnLike {
+    #column
+    #length
+    #fill
+
+    /**
+     * @param {ColumnLike} column
+     * @param {number} length
+     * @param {string} fill
+     */
+    constructor(column ,length, fill) {
+        super();
+        this.#column = typeof column === 'string' ? new SqlColumn(column) : column;
+        this.#length = length;
+        this.#fill = typeof fill === 'string' ? new SqlString(fill) : fill;
+    }
+
+    toString() {
+        return `lpad(${this.#column}, ${this.#length}, ${this.#fill})${super.toString()}`
+    }
+}
+
+class SqlMax extends ColumnLike {
+    #column
+
+    /**
+     * @param {ColumnLike} column
+     */
+    constructor(column) {
+        super();
+        this.#column = typeof column === 'string' ? new SqlColumn(column) : column;
+    }
+
+    toString() {
+        return `max(${this.#column})${super.toString()}`
+    }
+}
+
+class SqlParameter extends ColumnLike {
+    #number
+
+    /**
+     * @param {number} number
+     */
+    constructor(number) {
+        super();
+        this.#number = number;
+    }
+
+    toString() {
+        return `$${this.#number}${super.toString()}`
+    }
+}
+
+class SqlRPad extends ColumnLike {
+    #column
+    #length
+    #fill
+
+    /**
+     * @param {ColumnLike} column
+     * @param {number} length
+     * @param {string} fill
+     */
+    constructor(column ,length, fill) {
+        super();
+        this.#column = typeof column === 'string' ? new SqlColumn(column) : column;
+        this.#length = length;
+        this.#fill = typeof fill === 'string' ? new SqlString(fill) : fill;
+    }
+
+    toString() {
+        return `rpad(${this.#column}, ${this.#length}, ${this.#fill})${super.toString()}`
+    }
+}
+
+class SqlStringAgg extends ColumnLike {
+    #column
+    #separator
+    #distinct
+
+    /**
+     * @param {ColumnLike} column
+     * @param {string} separator
+     * @param {boolean} distinct
+     */
+    constructor(column, separator, distinct=true) {
+        super();
+        this.#column = typeof column === 'string' ? new SqlColumn(column) : column;
+        this.#separator = typeof separator === 'string' ? new SqlString(separator) : separator;
+        this.#distinct = distinct;
+    }
+
+    toString() {
+        return `string_agg(${this.#distinct ? 'DISTINCT ' : ''}${this.#column}, ${this.#separator})${super.toString()}`
+    }
+}
+
+class SqlStringToArray extends ColumnLike {
+    #column
+    #separator
+    #replace
+
+    /**
+     * @param {ColumnLike} column
+     * @param {string} separator
+     * @param {string=} replace
+     */
+    constructor(column, separator, replace) {
+        this.#column = typeof column === 'string' ? new SqlColumn(column) : column;
+        this.#separator = typeof separator === 'string' ? new SqlString(separator) : separator;
+        this.#replace = replace;
+    }
+
+    toString() {
+        return `string_to_array(${this.#column}, ${this.#separator}${this.#replace ? `, ${this.replace}` : ''})${super.toString()}`
+    }
+}
+
+class SqlSubString extends ColumnLike {
+    #column
+    #pattern
+
+    /**
+     * @param {ColumnLike} column
+     * @param {string} pattern
+     */
+    constructor(column, pattern) {
+        super();
+        this.#column = typeof column === 'string' ? new SqlColumn(column) : column;
+        this.#pattern = typeof pattern === 'string' ? new SqlString(pattern) : pattern;
+    }
+
+    toString() {
+        return `substring(${this.#column}, ${this.#pattern})${super.toString()}`
+    }
+}
+
+class ConditionLike {
+
+}
+
+class SqlAnd extends ConditionLike {
+    #conditions
+
+    /**
+     * @param  {...ConditionLike} conditions
+     */
+    constructor(...conditions) {
+        super();
+        this.#conditions = conditions;
+    }
+
+    toString() {
+        return this.#conditions.map(condition => `(${condition})`).join(' AND ')
+    }
+}
+
+class SqlEqual extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        super();
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} = ${this.#right}`
+    }
+}
+
+class SqlGreaterThan extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        super();
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} > ${this.#right}`
+    }
+}
+
+class SqlGreaterThanOrEqual extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        super();
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} >= ${this.#right}`
+    }
+}
+
+class SqlILike extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        super();
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} ILIKE ${this.#right}`
+    }
+}
+
+class SqlIsNotNull extends ConditionLike {
+    #column
+
+    /**
+     * @param {ColumnLike} column
+     */
+    constructor(column) {
+        super();
+        this.#column = typeof column === 'string' ? new SqlColumn(column) : column;
+    }
+
+    toString() {
+        return `${this.#column} IS NOT NULL`
+    }
+}
+
+class SqlIsNull extends ConditionLike {
+    #column
+
+    /**
+     * @param {ColumnLike} column
+     */
+    constructor(column) {
+        super();
+        this.#column = typeof column === 'string' ? new SqlColumn(column) : column;
+    }
+
+    toString() {
+        return `${this.#column} IS NULL`
+    }
+}
+
+class SqlLessThan extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} < ${this.#right}`
+    }
+}
+
+class SqlLessThanOrEqual extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} <= ${this.#right}`
+    }
+}
+
+class SqlLike extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} LIKE ${this.#right}`
+    }
+}
+
+class SqlMatch extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} ~ ${this.#right}`
+    }
+}
+
+class SqlNotEqual extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        super();
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} != ${this.#right}`
+    }
+}
+
+class SqlNotILike extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} NOT ILIKE ${this.#right}`
+    }
+}
+
+class SqlNotLike extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} NOT LIKE ${this.#right}`
+    }
+}
+
+class SqlNotMatch extends ConditionLike {
+    #left
+    #right
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    constructor(left, right) {
+        this.#left = typeof left === 'string' ? new SqlColumn(left) : left;
+        this.#right = typeof right === 'string' ? new SqlColumn(right) : right;
+    }
+
+    toString() {
+        return `${this.#left} !~ ${this.#right}`
+    }
+}
+
+class SqlOr extends ConditionLike {
+    #conditions
+
+    /**
+     * @param  {...ConditionLike} conditions
+     */
+    constructor(...conditions) {
+        this.#conditions = conditions;
+    }
+
+    toString() {
+        return this.#conditions.map(condition => `(${condition})`).join(' OR ')
+    }
+}
+
+class TableLike {
+
+}
+
+class SqlTable extends TableLike {
+    #name
+
+    constructor(name) {
+        super();
+        this.#name = name;
+    }
+
+    toString() {
+        return `"${this.#name}"`
+    }
+}
+
+class SqlQuery {
+    /**
+     * @param {PostgreSQL} pgsql
+     */
+    constructor(pgsql) {
+        /**
+         * @type {PostgreSQL}
+         */
+        this.pgsql = pgsql;
+    }
+
+    async invoke(...values) {
+        const query = this.toString();
+        return await this.pgsql.pool.query(query, values)
+    }
+}
+
+class SqlInsert extends SqlQuery {
+    #columns
+    #into
+    #values
+
+    /**
+     * @param {PostgreSQL} pgsql
+     * @param {...ColumnLike} columns
+     */
+    constructor(pgsql, ...columns) {
+        super(pgsql);
+
+        this.#columns = columns.map(column => typeof column === 'string' ? new SqlColumn(column) : column);
+        this.#values = [];
+    }
+
+    /**
+     * @param {string} table
+     */
+    into(table) {
+        this.#into = typeof table === 'string' ? new SqlTable(table) : table;
+
+        return this
+    }
+
+    values(...values) {
+        this.#values = values;
+
+        return this
+    }
+
+    toString() {
+        return `INSERT INTO ${this.#into} (${this.#columns.join(', ')}) VALUES (${this.#values.join(', ')})`
+    }
+}
+
+class SqlFrom {
+    #table
+    #alias
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    constructor(table, alias) {
+        this.#table = typeof table === 'string' ? new SqlTable(table) : table;
+        this.#alias = alias;
+    }
+
+    toString() {
+        return this.#alias ?  `FROM (${this.#table}) AS ${this.#alias}` : `FROM ${this.#table}`
+    }
+}
+
+class SqlGroupBy {
+    #columns
+
+    /**
+     * @param  {...ColumnLike} columns
+     */
+    constructor(...columns) {
+        this.#columns = columns.map(column => typeof column === 'string' ? new SqlColumn(column) : column);
+    }
+
+    toString() {
+        return `GROUP BY ${this.#columns.join(', ')}`
+    }
+}
+
+class SqlJoin {
+    #table
+    #condition
+
+    /**
+     * @param {TableLike} table
+     * @param {ConditionLike} condition
+     */
+    constructor(table, condition) {
+        this.#table = typeof table === 'string' ? new SqlTable(table) : table;
+        this.#condition = condition;
+    }
+
+    toString() {
+        return `JOIN ${this.#table} ON ${this.#condition}`
+    }
+}
+
+class SqlJoinInnerLateral {
+    #table
+    #alias
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    constructor(table, alias) {
+        this.#table = typeof table === 'string' ? new SqlTable(table) : table;
+        this.#alias = alias;
+    }
+
+    toString() {
+        return `INNER JOIN LATERAL (\n${this.#table}\n) ${this.#alias} ON TRUE`
+    }
+}
+
+class SqlJoinLeft {
+    #table
+    #condition
+
+    /**
+     * @param {TableLike} table
+     * @param {ConditionLike} condition
+     */
+    constructor(table, condition) {
+        this.#table = typeof table === 'string' ? new SqlTable(table) : table;
+        this.#condition = condition;
+    }
+
+    toString() {
+        return `LEFT JOIN ${this.#table} ON ${this.#condition}`
+    }
+}
+
+class SqlJoinLeftLateral {
+    #table
+    #alias
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    constructor(table, alias) {
+        this.#table = typeof table === 'string' ? new SqlTable(table) : table;
+        this.#alias = alias;
+    }
+
+    toString() {
+        return `LEFT JOIN LATERAL (\n${this.#table}\n) ${this.#alias} ON TRUE`
+    }
+}
+
+class SqlLimit {
+    #count
+
+    /**
+     * @param {number} count
+     */
+    constructor(count) {
+        this.count = count;
+    }
+
+    toString() {
+        return `LIMIT ${this.#count}`
+    }
+}
+
+class SqlOrderBy {
+    #columns
+
+    /**
+     * @param {...ColumnLike} columns
+     */
+    constructor(...columns) {
+        this.#columns = columns.map(column => typeof column === 'string' ? new SqlColumn(column) : column);
+    }
+
+    toString() {
+        return `ORDER BY ${this.#columns.join(', ')}`
+    }
+}
+
+class SqlWhere {
+    #condition
+
+    /**
+     * @param {ConditionLike} condition
+     */
+    constructor(condition) {
+        this.#condition = condition;
+    }
+
+    toString() {
+        return `WHERE ${this.#condition}`
+    }
+}
+
+class SqlSelect extends SqlQuery {
+    /**
+     * @type {ColumnLike[]}
+     */
+    #columns
+
+    /**
+     * @type {SqlFrom}
+     */
+    #from
+
+    /**
+     * @type {SqlGroupBy}
+     */
+    #groupby
+
+    /**
+     * @type {SqlJoin[]}
+     */
+    #join
+
+    /**
+     * @type {SqlLimit}
+     */
+    #limit
+
+    /**
+     * @type {SqlOrderBy}
+     */
+    #orderby
+
+    /**
+     * @type {SqlWhere}
+     */
+    #where
+
+    /**
+     * @param {PostgreSQL} pgsql
+     * @param {...ColumnLike} columns
+     */
+    constructor(pgsql, ...columns) {
+        super(pgsql);
+
+        this.#columns = columns.map(column => typeof column === 'string' ? new SqlColumn(column) : column);
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    from(table, alias) {
+        this.#from = new SqlFrom(table, alias);
+
+        return this
+    }
+
+    /**
+     * @param  {...ColumnLike} columns
+     */
+    groupby(...columns) {
+        this.#groupby = new SqlGroupBy(...columns);
+
+        return this
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {SqlToken} condition
+     */
+    join(table, condition) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoin(table, condition));
+
+        return this
+    }
+
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    joinInnerLateral(table, alias) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoinInnerLateral(table, alias));
+
+        return this
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {SqlToken} condition
+     */
+    joinLeft(table, condition) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoinLeft(table, condition));
+
+        return this
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    joinLeftLateral(table, alias) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoinLeftLateral(table, alias));
+
+        return this
+    }
+
+    /**
+     * @param {number} count
+     */
+    limit(count) {
+        this.#limit = new SqlLimit(count);
+    }
+
+    /**
+     * @param  {...ColumnLike} columns
+     */
+    orderby(...columns) {
+        this.orderby = new SqlOrderBy(...columns);
+
+        return this
+    }
+
+    /**
+     * @param {SqlToken} condition
+     */
+    where(condition) {
+        this.#where = new SqlWhere(condition);
+
+        return this
+    }
+
+    toString() {
+        return `SELECT ${this.#columns.length === 0 ? '*' : this.#columns.join(',\n')}` +
+            `\n${this.#from}` +
+            (this.#join ? `\n${this.#join.join('\n')}` : '') +
+            (this.#where ? `\n${this.#where}` : '') +
+            (this.#orderby ? `\n${this.#orderby}` : '') +
+            (this.#groupby ? `\n${this.#groupby}` : '') +
+            (this.#limit ? `\n${this.#limit}` : '')
+    }
+}
+
+class SqlSelectDistinct extends SqlQuery {
+    /**
+     * @type {SqlToken[]}
+     */
+    #distinct
+
+    /**
+     * @type {SqlToken}
+     */
+    #from
+
+    /**
+     * @type {SqlGroupBy}
+     */
+    #groupby
+
+    /**
+     * @type {SqlToken[]}
+     */
+    #join
+
+    /**
+     * @type {SqlToken}
+     */
+    #limit
+
+    /**
+     * @type {SqlToken}
+     */
+    #where
+
+    /**
+     * @type {SqlToken}
+     */
+    #orderby
+
+    /**
+     * @param {PostgreSQL} pgsql
+     * @param {...ColumnLike} columns
+     */
+    constructor(pgsql, ...columns) {
+        super(pgsql);
+
+        this.#distinct = columns.map(column => typeof column === 'string' ? new SqlColumn(column) : column);
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    from(table, alias) {
+        this.#from = new SqlFrom(table, alias);
+
+        return this
+    }
+
+    /**
+     * @param  {...ColumnLike} columns
+     */
+    groupby(...columns) {
+        this.#groupby = new SqlGroupBy(...columns);
+
+        return this
+    }
+
+    /**
+     * @param {string|SqlToken} table
+     * @param {SqlToken} condition
+     */
+    join(table, condition) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoin(table, condition));
+
+        return this
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    joinInnerLateral(table, alias) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoinInnerLateral(table, alias));
+
+        return this
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {SqlToken} condition
+     */
+    joinLeft(table, condition) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoinLeft(table, condition));
+
+        return this
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    joinLeftLateral(table, alias) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoinLeftLateral(table, alias));
+
+        return this
+    }
+
+    /**
+     * @param {number} count
+     */
+    limit(count) {
+        this.#limit = new SqlLimit(count);
+    }
+
+    /**
+     * @param  {...ColumnLike} columns
+     */
+    orderby(...columns) {
+        this.orderby = new SqlOrderBy(...columns);
+
+        return this
+    }
+
+    /**
+     * @param {ConditionLike} condition
+     */
+    where(condition) {
+        this.#where = SqlWhere(condition);
+
+        return this
+    }
+
+    toString() {
+        return `SELECT DISTINCT ${this.#distinct.length === 0 ? '*' : this.#distinct.join(',\n')}` +
+            `\n${this.#from}` +
+            (this.#join ? `\n${this.#join.join('\n')}` : '') +
+            (this.#where ? `\n${this.#where}` : '') +
+            (this.#orderby ? `\n${this.#orderby}` : '') +
+            (this.#groupby ? `\n${this.#groupby}` : '') +
+            (this.#limit ? `\n${this.#limit}` : '')
+    }
+}
+
+class SqlSelectDistinctOn extends SqlQuery {
+    /**
+     * @type {SqlToken[]}
+     */
+    #distinct
+
+    /**
+     * @type {SqlToken[]}
+     */
+    #columns
+
+    /**
+     * @type {SqlToken}
+     */
+    #from
+
+    /**
+     * @type {SqlGroupBy}
+     */
+    #groupby
+
+    /**
+     * @type {SqlToken[]}
+     */
+    #join
+
+    /**
+     * @type {SqlToken}
+     */
+    #limit
+
+    /**
+     * @type {SqlToken}
+     */
+    #orderby
+
+    /**
+     * @type {SqlToken}
+     */
+    #where
+
+    /**
+     * @param {PostgreSQL} pgsql
+     * @param {...ColumnLike} columns
+     */
+    constructor(pgsql, ...columns) {
+        super(pgsql);
+
+        this.#distinct = columns.map(column => typeof column === 'string' ? new SqlColumn(column) : column);
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    from(table, alias) {
+        this.#from = new SqlFrom(table, alias);
+
+        return this
+    }
+
+    /**
+     * @param  {...ColumnLike} columns
+     */
+    groupby(...columns) {
+        this.#groupby = new SqlGroupBy(...columns);
+
+        return this
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {ConditionLike} condition
+     */
+    join(table, condition) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoin(table, condition));
+
+        return this
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    joinInnerLateral(table, alias) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoinInnerLateral(table, alias));
+
+        return this
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {SqlToken} condition
+     */
+    joinLeft(table, condition) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoinLeft(table, condition));
+
+        return this
+    }
+
+    /**
+     * @param {TableLike} table
+     * @param {string} alias
+     */
+    joinLeftLateral(table, alias) {
+        if (!this.#join) {
+            this.#join = [];
+        }
+        this.#join.push(new SqlJoinLeftLateral(table, alias));
+
+        return this
+    }
+
+    /**
+     * @param {number} count
+     */
+    limit(count) {
+        this.#limit = new SqlLimit(count);
+    }
+
+    /**
+     * @param  {...ColumnLike} columns
+     */
+    orderby(...columns) {
+        this.orderby = new SqlOrderBy(...columns);
+
+        return this
+    }
+
+    /**
+     * @param  {...ColumnLike} columns
+     */
+    select(...columns) {
+        this.#columns = columns.map(column => typeof column === 'string' ? new SqlColumn(column) : column);
+    }
+
+    /**
+     * @param {SqlToken} condition
+     */
+    where(condition) {
+        this.#where = new SqlWhere(condition);
+
+        return this
+    }
+
+    toString() {
+        return `SELECT DISTINCT ON (${this.#distinct.join(',')})\n ${this.#columns.length === 0 ? '*' : this.#columns.join(',\n')}` +
+            `\n${this.#from}` +
+            (this.#join ? `\n${this.#join.join('\n')}` : '') +
+            (this.#where ? `\n${this.#where}` : '') +
+            (this.#orderby ? `\n${this.#orderby}` : '') +
+            (this.#groupby ? `\n${this.#groupby}` : '') +
+            (this.#limit ? `\n${this.#limit}` : '')
+    }
+}
+
+class SqlUnion {
+    #statements
+
+    /**
+     * @param {...SqlQuery} statements
+     */
+    constructor(...statements) {
+        this.#statements = statements;
+    }
+
+    toString() {
+        return this.#statements.map(statement => `(\n${statement}\n)`).join('\nUNION\n')
+    }
+}
+
+class ValueLike {
+
+}
+
+class SqlAll extends ValueLike {
+    #statement
+
+    /**
+     * @param {StatementLike} statement
+     */
+    constructor(statement) {
+        super();
+        this.#statement = statement;
+    }
+
+    toString() {
+        return `ALL(${this.#statement})`
+    }
+}
+
+class SqlAny extends ValueLike {
+    #statement
+
+    /**
+     * @param {StatementLike} statement
+     */
+    constructor(statement) {
+        super();
+        this.#statement = statement;
+    }
+
+    toString() {
+        return `ANY(${this.#statement})`
+    }
+}
+
+class SqlConstant extends ValueLike {
+    #name
+
+    /**
+     * @param {string} name
+     */
+    constructor(name) {
+        super();
+        this.#name = name;
+    }
+
+    toString() {
+        return this.#name
+    }
+}
+
+class PostgreSQL {
+    /**
+     * @param {pg.PoolConfig} options
+     */
+    constructor(options) {
+        /**
+         * @type {pg.Pool}
+         */
+        this.pool = new pg.Pool(options);
+    }
+
+
+    // #region Queries
+
+
+    /**
+     * @param {...ColumnLike=} columns
+     */
+    insert(...columns) {
+        return new SqlInsert(this, ...columns)
+    }
+
+
+    /**
+     * @param {...ColumnLike=} columns
+     */
+    select(...columns) {
+        return new SqlSelect(this, ...columns)
+    }
+
+
+    /**
+     * @param {...ColumnLike=} columns
+     */
+    selectDistinct(...columns) {
+        return new SqlSelectDistinct(this, ...columns)
+    }
+
+
+    /**
+     * @param {...ColumnLike} columns
+     */
+    selectDistinctOn(...columns) {
+        return new SqlSelectDistinctOn(this, ...columns)
+    }
+
+
+    /**
+     * @param {...SqlQuery} statements
+     */
+    union(...statements) {
+        return new SqlUnion(...statements)
+    }
+
+
+    // #endregion
+
+
+    // #region Constants
+
+
+    CURRENT_DATE = new SqlConstant('CURRENT_DATE')
+
+    FALSE = new SqlConstant('FALSE')
+
+    NULL = new SqlConstant('NULL')
+
+    TRUE = new SqlConstant('TRUE')
+
+    // #endregion
+
+
+    // #region Column-like
+
+
+    case() {
+        return new SqlCase()
+    }
+
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    coalese(left, right) {
+        return new SqlCoalesce(left, right)
+    }
+
+
+    /**
+     * @param {string} name
+     */
+    column(name) {
+        return new SqlColumn(name)
+    }
+
+
+    /**
+     * @param {...ColumnLike} columns
+     */
+    concat(...columns) {
+        return new SqlConcat(...columns)
+    }
+
+
+    /**
+     * @param {number} value
+     * @param {string} unit
+     */
+    dateinterval(value, unit) {
+        return new SqlDateInterval(value, unit)
+    }
+
+
+    /**
+     * @param {string} part
+     * @param {ColumnLike} column
+     */
+    datepart(part, column) {
+        return new SqlDatePart(part, column)
+    }
+
+
+    /**
+     * @param {string} part
+     * @param {ColumnLike} column
+     */
+    datetrunc(part, column) {
+        return new SqlDateTrunc(part, column)
+    }
+
+
+    /**
+     * @param {ColumnLike} column
+     * @param {number} length
+     * @param {string} fill
+     */
+    lpad(column, length, fill) {
+        return new SqlLPad(column, length, fill)
+    }
+
+
+    /**
+     * @param {ColumnLike} column
+     */
+    max(column) {
+        return new SqlMax(column)
+    }
+
+
+    /**
+     * @param {number} number
+     */
+    param(number) {
+        return new SqlParameter(number)
+    }
+
+
+    /**
+     * @param {ColumnLike} column
+     * @param {number} length
+     * @param {string} fill
+     */
+    rpad(column, length, fill) {
+        return new SqlRPad(column, length, fill)
+    }
+
+
+    /**
+     * @param {string} value
+     */
+    string(value) {
+        return new SqlString(value)
+    }
+
+
+    /**
+     * @param {ColumnLike} column
+     * @param {string} separator
+     * @param {boolean} distinct
+     */
+    stringagg(column, separator, distinct=true) {
+        return new SqlStringAgg(column, separator, distinct)
+    }
+
+
+    /**
+     * @param {ColumnLike} column
+     * @param {string} separator
+     * @param {string=} replace
+     */
+    stringtoarray(column, separator, replace) {
+        return new SqlStringToArray(column, separator, replace)
+    }
+
+
+    /**
+     * @param {ColumnLike} column
+     * @param {string} pattern
+     */
+    substring(column, pattern) {
+        return new SqlSubString(column, pattern)
+    }
+
+
+    // #endregion
+
+
+    // #region Condition-like
+
+
+    /**
+     * @param {...ConditionLike} conditions
+     */
+    and(...conditions) {
+        return new SqlAnd(...conditions)
+    }
+
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    equal(left, right) {
+        return new SqlEqual(left, right)
+    }
+
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    greaterThan(left, right) {
+        return new SqlGreaterThan(left, right)
+    }
+
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    greaterThanOrEqual(left, right) {
+        return new SqlGreaterThanOrEqual(left, right)
+    }
+
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    ilike(left, right) {
+        return new SqlILike(left, right)
+    }
+
+
+    /**
+     * @param {ColumnLike} column
+     */
+    isNotNull(column) {
+        return new SqlIsNotNull(column)
+    }
+
+
+    /**
+     * @param {ColumnLike} column
+     */
+    isNull(column) {
+        return new SqlIsNull(column)
+    }
+
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    lessThan(left, right) {
+        return new SqlLessThan(left, right)
+    }
+
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    lessThanOrEqual(left, right) {
+        return new SqlLessThanOrEqual(left, right)
+    }
+
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    like(left, right) {
+        return new SqlLike(left, right)
+    }
+
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    match(left, right) {
+        return new SqlMatch(left, right)
+    }
+
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    notEqual(left, right) {
+        return new SqlNotEqual(left, right)
+    }
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    notILike(left, right) {
+        return new SqlNotILike(left, right)
+    }
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    notLike(left, right) {
+        return new SqlNotLike(left, right)
+    }
+
+
+    /**
+     * @param {ColumnLike} left
+     * @param {ColumnLike} right
+     */
+    notMatch(left, right) {
+        return new SqlNotMatch(left, right)
+    }
+
+
+    /**
+     * @param {...ConditionLike} conditions
+     */
+    or(...conditions) {
+        return new SqlOr(...conditions)
+    }
+
+    // #endregion
+
+
+    // #region Value-like
+
+
+    /**
+     * @param {StatementLike} statement
+     */
+    all(statement) {
+        return new SqlAll(statement)
+    }
+
+
+    /**
+     * @param {StatementLike} statement
+     */
+    any(statement) {
+        return new SqlAny(statement)
+    }
+
+
+    // #endregion
+}
+
+exports.PostgreSQL = PostgreSQL;