taon-type-sql 18.0.9

package/websql/fesm2022/taon-type-sql.mjs

@@ -0,0 +1,877 @@
+import { Log } from 'ng2-logger/websql';
+
+class QueryCondition {
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/condition/query-condition.ts
+
+class QueryConditionChain extends QueryCondition {
+    constructor(sibling, child, chainType) {
+        super();
+        this._parenthesis = false;
+        this._negation = false;
+        this._sibling = sibling;
+        this._child = child;
+        this._chainType = chainType;
+    }
+    $() {
+        this._parenthesis = true;
+        return this;
+    }
+    not() {
+        this._negation = true;
+        return this;
+    }
+    and(condition) {
+        return new QueryConditionChain(this, condition, 'and');
+    }
+    or(condition) {
+        return new QueryConditionChain(this, condition, 'or');
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/condition/query-condition-chain.ts
+
+class QueryColumnCondition extends QueryCondition {
+    constructor(column, type, ...values) {
+        super();
+        this._column = column;
+        this._type = type;
+        this._values = values;
+    }
+    and(condition) {
+        return new QueryConditionChain(this, condition, 'and');
+    }
+    or(condition) {
+        return new QueryConditionChain(this, condition, 'or');
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/condition/query-column-condition.ts
+
+class QueryColumn {
+    constructor(_table, _name, _modifiers = []) {
+        this._table = _table;
+        this._name = _name;
+        this._modifiers = _modifiers;
+    }
+    as(alias) {
+        return new this.constructor(this._table, this._name, this._modifiers.concat({ name: 'as', params: alias }));
+    }
+    isNull() {
+        return new QueryColumnCondition(this, 'is-null');
+    }
+    isNotNull() {
+        return new QueryColumnCondition(this, 'is-not-null');
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/column/query-column.ts
+
+class QueryOrdering {
+    constructor(column, direction) {
+        this._column = column;
+        this._direction = direction;
+    }
+    nullsFirst() {
+        this._nullsPosition = 'FIRST';
+        return this;
+    }
+    nullsLast() {
+        this._nullsPosition = 'LAST';
+        return this;
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/other/query-ordering.ts
+
+class QueryJoinCondition extends QueryCondition {
+    constructor(column, type, otherColumn) {
+        super();
+        this._column = column;
+        this._type = type;
+        this._otherColumn = otherColumn;
+    }
+    and(condition) {
+        return new QueryConditionChain(this, condition, 'and');
+    }
+    or(condition) {
+        return new QueryConditionChain(this, condition, 'or');
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/condition/query-join-condition.ts
+
+class ValueColumn extends QueryColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+    }
+    asc() {
+        return new QueryOrdering(this, 'ASC');
+    }
+    desc() {
+        return new QueryOrdering(this, 'DESC');
+    }
+    eq(value) {
+        if (value instanceof QueryColumn) {
+            return new QueryJoinCondition(this, 'eq', value);
+        }
+        else {
+            return new QueryColumnCondition(this, 'eq', value);
+        }
+    }
+    ne(value) {
+        return new QueryColumnCondition(this, 'ne', value);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/column/value-column.ts
+
+class ComparableColumn extends ValueColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+    }
+    lt(value) {
+        return new QueryColumnCondition(this, 'lt', value);
+    }
+    gt(value) {
+        return new QueryColumnCondition(this, 'gt', value);
+    }
+    lte(value) {
+        return new QueryColumnCondition(this, 'lte', value);
+    }
+    gte(value) {
+        return new QueryColumnCondition(this, 'gte', value);
+    }
+    in(values) {
+        return new QueryColumnCondition(this, 'in', ...values);
+    }
+    notIn(values) {
+        return new QueryColumnCondition(this, 'not-in', ...values);
+    }
+    between(value1, value2) {
+        return new QueryColumnCondition(this, 'between', value1, value2);
+    }
+    notBetween(value1, value2) {
+        return new QueryColumnCondition(this, 'not-between', value1, value2);
+    }
+    min() {
+        return new this.constructor(this._table, this._name, this._modifiers.concat({ name: 'min' }));
+    }
+    max() {
+        return new this.constructor(this._table, this._name, this._modifiers.concat({ name: 'max' }));
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/column/comparable-column.ts
+
+class NumberColumn extends ComparableColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+        this._type = 'number';
+    }
+    count() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+    sum() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'sum' }));
+    }
+    avg() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'avg' }));
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/column/number-column.ts
+
+class BasicColumn extends QueryColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+    }
+    count() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/column/basic-column.ts
+
+class BooleanColumn extends ValueColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+        this._type = 'boolean';
+    }
+    count() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/column/boolean-column.ts
+
+class DateColumn extends ComparableColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+        this._type = 'date';
+    }
+    count() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/column/date-column.ts
+
+class StringColumn extends ComparableColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+        this._type = 'string';
+    }
+    count() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+    lower() {
+        return new this.constructor(this._table, this._name, this._modifiers.concat({ name: 'lower' }));
+    }
+    upper() {
+        return new this.constructor(this._table, this._name, this._modifiers.concat({ name: 'upper' }));
+    }
+    contains(value) {
+        return this.like('%' + value + '%');
+    }
+    startsWith(value) {
+        return this.like(value + '%');
+    }
+    endsWith(value) {
+        return this.like('%' + value);
+    }
+    like(value) {
+        return new QueryColumnCondition(this, 'like', value);
+    }
+    notLike(value) {
+        return new QueryColumnCondition(this, 'not-like', value);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/column/string-column.ts
+
+class JoinedTablesChain {
+    constructor(_table, _modifier, _parent) {
+        this._table = _table;
+        this._modifier = _modifier;
+        this._parent = _parent;
+    }
+    on(condition) {
+        return new JoinedTables(condition, this);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/join/joined-tables-chain.ts
+
+class JoinedTables {
+    constructor(_condition, _parent) {
+        this._condition = _condition;
+        this._parent = _parent;
+    }
+    innerJoin(table) {
+        return new JoinedTablesChain(table, 'inner', this);
+    }
+    leftJoin(table) {
+        return new JoinedTablesChain(table, 'left', this);
+    }
+    rightJoin(table) {
+        return new JoinedTablesChain(table, 'right', this);
+    }
+    fullJoin(table) {
+        return new JoinedTablesChain(table, 'full', this);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/join/joined-tables.ts
+
+class SelectQuery {
+    constructor(_queryProcessor, _tables) {
+        this._queryProcessor = _queryProcessor;
+        this._tables = _tables;
+        this._distinct = false;
+        this._conditions = [];
+        this._groupBy = [];
+        this._having = [];
+        this._orderings = [];
+        this._columns = [];
+    }
+    offset(offset) {
+        this._offset = offset;
+        return this;
+    }
+    limit(limit) {
+        this._limit = limit;
+        return this;
+    }
+    distinct() {
+        this._distinct = true;
+        return this;
+    }
+    where(...conditions) {
+        this._conditions = conditions;
+        return this;
+    }
+    groupBy(...columns) {
+        this._groupBy = columns;
+        return this;
+    }
+    having(...conditions) {
+        this._having = conditions;
+        return this;
+    }
+    orderBy(...orderings) {
+        this._orderings = orderings;
+        return this;
+    }
+    select(...columns) {
+        this._columns = columns;
+        this._action = 'select';
+        return this._queryProcessor(this);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/query/select-query.ts
+
+class TableConditionQuery {
+    constructor(_queryProcessor, _table, _conditions) {
+        this._queryProcessor = _queryProcessor;
+        this._table = _table;
+        this._conditions = _conditions;
+        this._columns = [];
+    }
+    update(entity) {
+        this._entity = entity;
+        this._action = 'update';
+        return this._queryProcessor(this);
+    }
+    delete() {
+        this._action = 'delete';
+        return this._queryProcessor(this);
+    }
+    count() {
+        this._columns = [this._table.$all.count()];
+        this._action = 'select';
+        return this._queryProcessor(this).then((rows) => rows[0]);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/query/table-condition-query.ts
+
+class TableQuery {
+    constructor(_queryProcessor, _table) {
+        this._queryProcessor = _queryProcessor;
+        this._table = _table;
+        this._columns = [];
+    }
+    where(...conditions) {
+        return new TableConditionQuery(this._queryProcessor, this._table, conditions);
+    }
+    insert(param) {
+        this._entity = param;
+        this._action = 'insert';
+        return this._queryProcessor(this);
+    }
+    deleteAll() {
+        this._action = 'delete';
+        return this._queryProcessor(this);
+    }
+    updateAll(entity) {
+        this._entity = entity;
+        this._action = 'update';
+        return this._queryProcessor(this);
+    }
+    countAll() {
+        this._columns = [this._table.$all.count()];
+        this._action = 'select';
+        return this._queryProcessor(this).then((rows) => rows[0]);
+    }
+    delete(id) {
+        return this._whereId(id).delete().then(count => count > 0);
+    }
+    update(id, entity) {
+        return this._whereId(id).update(entity).then(count => count > 0);
+    }
+    get(id) {
+        let query = this._whereId(id);
+        return this._queryProcessor({ _action: 'select', ...query })
+            .then((rows) => rows[0]);
+    }
+    _whereId(id) {
+        let $id = this._table.$id;
+        if ($id instanceof ValueColumn) {
+            return this.where($id.eq(id));
+        }
+        else {
+            return this.where(...Object.keys($id).map(key => this._table[key].eq(id[key])));
+        }
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/query/table-query.ts
+
+class QuerySource {
+    constructor(_queryProcessor) {
+        this._queryProcessor = _queryProcessor;
+    }
+    from(table1, table2, table3) {
+        if (table3 != null)
+            return new SelectQuery(this._queryProcessor, [table1, table2, table3]);
+        else if (table2 != null)
+            return new SelectQuery(this._queryProcessor, [table1, table2]);
+        return new SelectQuery(this._queryProcessor, [table1]);
+    }
+    table(table) {
+        return new TableQuery(this._queryProcessor, table);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/query-source.ts
+
+class QueryTable {
+    constructor(_$name) {
+        this._$name = _$name;
+        this.$all = new BasicColumn(this, '*');
+    }
+    innerJoin(table) {
+        return new JoinedTablesChain(table, 'inner', this);
+    }
+    leftJoin(table) {
+        return new JoinedTablesChain(table, 'left', this);
+    }
+    rightJoin(table) {
+        return new JoinedTablesChain(table, 'right', this);
+    }
+    fullJoin(table) {
+        return new JoinedTablesChain(table, 'full', this);
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/builder/query-table.ts
+
+function number(param) {
+    let result = Number(param);
+    if (Number.isNaN(result))
+        throw new Error('Invalid number parameter in SQL query: ' + param);
+    return result;
+}
+function boolean(param) {
+    if (typeof param === 'boolean')
+        return param;
+    if (param instanceof Boolean)
+        return param.valueOf();
+    if (param === 'true')
+        return true;
+    if (param === 'false')
+        return false;
+    throw new Error('Invalid boolean parameter in SQL query: ' + param);
+}
+function date(param) {
+    if (param instanceof Date)
+        return param; // @ts-ignore
+    if (typeof param === 'number' || param instanceof Number)
+        return new Date(param);
+    if (typeof param === 'string' || param instanceof String) {
+        if (Number.isNaN(Date.parse(String(param))))
+            throw new Error('Invalid date parameter in SQL query: ' + param); // @ts-ignore
+        return new Date(param);
+    }
+    throw new Error('Invalid date parameter in SQL query: ' + param);
+}
+function string(param) {
+    if (typeof param === 'string')
+        return param;
+    if (param instanceof String)
+        return param.valueOf();
+    throw new Error('Invalid string parameter in SQL query: ' + param);
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/converter/type-converter.ts
+
+function createQueryConverter(paramConverter, options, engine) {
+    return convertQuery;
+    function convertQuery(query) {
+        if (query._action === 'select')
+            return convertSelectQuery(query);
+        if (query._action === 'delete')
+            return convertDeleteQuery(query);
+        if (query._action === 'update')
+            return convertUpdateQuery(query);
+        if (query._action === 'insert')
+            return convertInsertQuery(query);
+        throw new Error('Unknown query type:' + query._action);
+    }
+    function convertDeleteQuery(query) {
+        let s = 'DELETE FROM ' + convertTable(query._table);
+        s += convertConditions(query._conditions);
+        return s;
+    }
+    function convertUpdateQuery(query) {
+        let s = 'UPDATE ' + convertTable(query._table) + ' SET ';
+        s += convertUpdateSetters(query._table, query._entity);
+        s += convertConditions(query._conditions);
+        return s;
+    }
+    function convertUpdateSetters(table, entity) {
+        return Object.keys(entity).sort().map(key => {
+            let value = entity[key];
+            let column = table[key];
+            return convertColumnName(column) + ' = ' + convertParam(column, value);
+        }).join(', ');
+    }
+    function convertInsertQuery(query) {
+        let items = Array.isArray(query._entity) ? query._entity : [query._entity];
+        let keySet = items.reduce((set, item) => {
+            Object.keys(item).forEach(key => set.add(key));
+            return set;
+        }, new Set());
+        let keys = Array.from(keySet).sort();
+        let s = 'INSERT INTO ' + convertTable(query._table) + ' ';
+        s += '(' + keys.map(key => convertColumnName(query._table[key])).join(', ') + ')';
+        s += options.lineBreak + 'VALUES ';
+        s += items.map(item => convertInsertItem(query._table, item, keys))
+            .map((row) => '(' + row + ')').join(', ');
+        s += getPgInsertReturningIfNeeded(query);
+        return s;
+    }
+    function getPgInsertReturningIfNeeded(query) {
+        if (engine === 'pg' && query._action === 'insert' && !Array.isArray(query._entity) &&
+            query._table.$id && query._table.$id._table && query._table.$id._name) {
+            return ' RETURNING ' + convertColumnName(query._table.$id);
+        }
+        return '';
+    }
+    function convertInsertItem(table, entity, keys) {
+        return keys.map(key => {
+            let value = entity[key];
+            let column = table[key];
+            return convertParam(column, value);
+        }).join(', ');
+    }
+    function convertSelectQuery(query) {
+        let s = 'SELECT ';
+        if (query._distinct) {
+            s += 'DISTINCT ';
+        }
+        if (query._columns == null || query._columns.length === 0) {
+            s += '*';
+        }
+        else {
+            s += query._columns.map((column) => convertColumn(column)).join(', ');
+        }
+        s += options.lineBreak + 'FROM ';
+        if (query._tables) {
+            s += query._tables.map((table) => table._parent ? convertJoin(table) : convertTable(table)).join(', ');
+        }
+        else {
+            s += convertTable(query._table);
+        }
+        s += convertConditions(query._conditions);
+        if (query._groupBy && query._groupBy.length > 0) {
+            s += options.lineBreak + 'GROUP BY ';
+            s += query._groupBy.map((column) => convertColumn(column)).join(', ');
+        }
+        s += convertConditions(query._having, 'HAVING');
+        if (query._orderings && query._orderings.length > 0) {
+            s += options.lineBreak + 'ORDER BY ';
+            s += query._orderings.map((ordering) => convertOrdering(ordering)).join(', ');
+        }
+        if (query._limit != null) {
+            s += options.lineBreak + 'LIMIT ' + number(query._limit);
+        }
+        if (query._offset != null) {
+            s += options.lineBreak + 'OFFSET ' + number(query._offset);
+        }
+        return s;
+    }
+    function convertConditions(conditions, keyword = 'WHERE') {
+        let s = '';
+        if (conditions && conditions.length > 0) {
+            s += options.lineBreak + keyword + ' ';
+            preprocessConditions(conditions);
+            s += conditions.map(condition => convertCondition(condition, true)).join(' AND ');
+        }
+        return s;
+    }
+    function convertJoin(joinChain) {
+        let items = [];
+        while (joinChain) {
+            items.push(joinChain);
+            joinChain = joinChain._parent;
+        }
+        let root = items[items.length - 1];
+        let s = convertTable(root);
+        for (let i = items.length - 2; i >= 0; i -= 2) {
+            let table = items[i]._table;
+            let modifier = items[i]._modifier;
+            let condition = items[i - 1]._condition;
+            let param = convertColumn(condition._otherColumn);
+            s += ' ' + modifier.toUpperCase() + ' JOIN ' + convertTable(table) + ' ON ' +
+                convertColumnCondition(condition, param);
+        }
+        return s;
+    }
+    function convertOrdering(ordering) {
+        if (ordering._column) {
+            let s = convertColumn(ordering._column);
+            if (ordering._nullsPosition != null) { // "NULLS FIRST" only exists in PG, this is the general solution
+                s += ' IS NULL ' + (ordering._nullsPosition === 'FIRST' ? 'DESC' : 'ASC') + ', ' + s;
+            }
+            if (ordering._direction === 'ASC')
+                s += ' ASC';
+            if (ordering._direction === 'DESC')
+                s += ' DESC';
+            return s;
+        }
+        else {
+            return convertColumn(ordering);
+        }
+    }
+    function convertTable(table) {
+        return options.nameEscape + table._$name + options.nameEscape;
+    }
+    function convertColumn(column) {
+        let s = '';
+        if (!(column._name === '*' && column._modifiers.length > 0 && column._modifiers[0].name === 'count')) {
+            s += convertTable(column._table) + '.';
+        }
+        s += convertColumnName(column);
+        return convertColumnModifiers(s, column);
+    }
+    function convertColumnModifiers(s, column) {
+        if (column._modifiers) {
+            column._modifiers.forEach((modifier) => {
+                let name = modifier.name;
+                if (name === 'lower')
+                    s = 'LOWER(' + s + ')';
+                else if (name === 'upper')
+                    s = 'UPPER(' + s + ')';
+                else if (name === 'count')
+                    s = 'COUNT(' + s + ')';
+                else if (name === 'sum')
+                    s = 'SUM(' + s + ')';
+                else if (name === 'avg')
+                    s = 'AVG(' + s + ')';
+                else if (name === 'min')
+                    s = 'MIN(' + s + ')';
+                else if (name === 'max')
+                    s = 'MAX(' + s + ')';
+                else if (name === 'as')
+                    s = s + ' AS ' + options.nameEscape + modifier.params + options.nameEscape;
+            });
+        }
+        return s + '';
+    }
+    function convertColumnName(column) {
+        if (column._name === '*')
+            return column._name;
+        let name = typeof column._name === 'string' ? column._name : column._name.name;
+        return options.nameEscape + name + options.nameEscape;
+    }
+    function preprocessConditions(conditions) {
+        conditions.forEach(condition => {
+            if (conditions.length > 1 && condition._sibling) {
+                condition._parenthesis = true;
+            }
+            preprocessParams(condition);
+        });
+    }
+    function preprocessParams(condition) {
+        if (condition._sibling) {
+            preprocessParams(condition._sibling);
+        }
+        if (!condition._sibling && !condition._child) {
+            condition.__param = getConditionParam(condition);
+        }
+        if (condition._child) {
+            preprocessParams(condition._child);
+        }
+    }
+    function convertCondition(condition, root = false) {
+        if (!condition._sibling && !condition._child) {
+            return convertColumnCondition(condition, condition.__param);
+        }
+        let s = '';
+        if (condition._child) {
+            s += convertCondition(condition._child);
+        }
+        if (condition._sibling) {
+            s = convertCondition(condition._sibling, root) + ' ' + condition._chainType.toUpperCase() + ' ' + s;
+        }
+        if (condition._parenthesis || ((!root || condition._negation) && condition._child)) {
+            s = '( ' + s + ' )';
+        }
+        if (condition._negation) {
+            s = 'NOT ' + s;
+        }
+        return s;
+    }
+    function convertColumnCondition(condition, param) {
+        let s = convertColumn(condition._column);
+        s += getConditionString(condition, param);
+        return s;
+    }
+    function getConditionString(condition, param) {
+        switch (condition._type) {
+            case 'eq': return ' = ' + param;
+            case 'ne': return ' <> ' + param;
+            case 'lt': return ' < ' + param;
+            case 'gt': return ' > ' + param;
+            case 'lte': return ' <= ' + param;
+            case 'gte': return ' >= ' + param;
+            case 'is-null': return ' IS NULL';
+            case 'is-not-null': return ' IS NOT NULL';
+            case 'like': return ' LIKE ' + param;
+            case 'not-like': return ' NOT LIKE ' + param;
+            case 'in': return ' IN (' + param + ')';
+            case 'not-in': return ' NOT IN (' + param + ')';
+            case 'between': return ' BETWEEN ' + param;
+            case 'not-between': return ' NOT BETWEEN ' + param;
+            default: return '';
+        }
+    }
+    function getConditionParam(condition) {
+        let param = '';
+        if (condition._otherColumn) {
+            param = convertColumn(condition._otherColumn);
+        }
+        else {
+            let _convertParam = (param) => convertParam(condition._column, param);
+            if (condition._type === 'in' || condition._type === 'not-in') {
+                param = condition._values.map((value) => _convertParam(value)).join(', ');
+            }
+            else if (condition._type === 'between' || condition._type === 'not-between') {
+                param = _convertParam(condition._values[0]) + ' AND ' + _convertParam(condition._values[1]);
+            }
+            else if (condition._type !== 'is-null' && condition._type !== 'is-not-null') {
+                param = _convertParam(condition._values[0]);
+            }
+        }
+        return param;
+    }
+    function convertParam(column, param) {
+        if (param == null)
+            return 'NULL';
+        return paramConverter(getTypedParam(column._type, param));
+    }
+    function getTypedParam(type, param) {
+        if (type === 'number')
+            return number(param);
+        else if (type === 'boolean')
+            return boolean(param);
+        else if (type === 'date')
+            return date(param);
+        else if (type === 'string')
+            return string(param);
+        return param;
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/converter/query-converter.ts
+
+function convertSubstitutionParam(param) {
+    if (param == null)
+        return 'NULL';
+    if (typeof param === 'string' || param instanceof String) {
+        return `'${String(param)}'`;
+    }
+    else if (typeof param === 'boolean' || param instanceof Boolean) {
+        return String(param).toUpperCase();
+    }
+    else if (param instanceof Date) {
+        return `'${param.toISOString()}'`;
+    }
+    else if (typeof param === 'number' || param instanceof Number) {
+        return String(param);
+    }
+    return `'${JSON.stringify(param)}'`;
+}
+function convertEscapedParam(param) {
+    if (typeof param === 'object' && !(param == null || param instanceof String || param instanceof Number ||
+        param instanceof Boolean || param instanceof Date)) {
+        return JSON.stringify(param);
+    }
+    return param;
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/converter/param-converter.ts
+
+let pgParamConverter = (index) => '$' + index;
+let mySqlParamConverter = (index) => '?';
+function convertSingleParam(param, params, paramConverter) {
+    params.push(convertEscapedParam(param));
+    return paramConverter(params.length);
+}
+function convertQueryToParameterizedSQL(query, options, engine) {
+    let params = [];
+    let paramConverter = engine === 'mysql' ? mySqlParamConverter : pgParamConverter;
+    let sql = createQueryConverter((param) => convertSingleParam(param, params, paramConverter), options, engine)(query);
+    return { sql, params };
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/converter/parameterized-converter.ts
+
+function convertQueryToSQL(query, options, engine) {
+    return createQueryConverter((param) => convertSubstitutionParam(param), options, engine)(query);
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/converter/sql-converter.ts
+
+const log = Log.create('query processor');
+const DEFAULT_OPTIONS = {
+    lineBreaks: false,
+    parameterized: true,
+    logging: true,
+    identifierQuote: '"'
+};
+function mySqlTypeCast(field, next) {
+    if (field.type == 'TINY' && field.length == 1) { // Boolean
+        let value = field.string();
+        if (value == '1')
+            return true;
+        if (value == '0')
+            return false;
+        return null;
+    }
+    else if (field.type == 'JSON') {
+        let value = field.string();
+        return value == null ? null : JSON.parse(value);
+    }
+    return next();
+}
+function createQueryProcessor(client, _options = {}, engine = 'pg') {
+    let options = Object.assign({}, DEFAULT_OPTIONS, _options);
+    let queryOptions = {
+        lineBreak: options.lineBreaks ? '\n' : ' ',
+        nameEscape: _options.identifierQuote || (engine === 'mysql' ? '`' : '"')
+    };
+    return (query) => {
+        if (options.parameterized) {
+            let { sql, params } = convertQueryToParameterizedSQL(query, queryOptions, engine);
+            return client.query(sql, params);
+        }
+        else {
+            let sql = convertQueryToSQL(query, queryOptions, engine);
+            return client.query(sql, undefined);
+        }
+    };
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/client/query-processor.ts
+
+class MySqlQuerySource extends QuerySource {
+    constructor(client, options = {}) {
+        super(createQueryProcessor(client, options, 'mysql'));
+    }
+}
+;
+({}); // @--end-of-file-for-module=taon-type-sql lib/client/mysql.ts
+
+({}); // @--end-of-file-for-module=taon-type-sql lib/index.ts
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BasicColumn, BooleanColumn, ComparableColumn, DateColumn, JoinedTables, JoinedTablesChain, MySqlQuerySource, NumberColumn, QueryColumn, QueryColumnCondition, QueryCondition, QueryConditionChain, QueryJoinCondition, QueryOrdering, QuerySource, QueryTable, SelectQuery, StringColumn, TableConditionQuery, TableQuery, ValueColumn };
+//# sourceMappingURL=taon-type-sql.mjs.map