happy-sql 2.3.0 → 2.4.0

package/lib/parser/visitors/clause/select/select.js

@@ -7,8 +7,18 @@ import {convertFrom} from '#parser/clause/from';
 import {convertCount, isCount} from '#parser/clause/count';
 import {convertCaseWhen} from '#parser/clause/case-when';
 import {convertBinary} from '#parser/clause/binary';
+import {
+    convertCondition,
+    convertBetween,
+} from '#parser/clause/where';
 import {findClause} from '#parser/clause/find';
 import {convertOrderBy} from '../from/order-by.js';
+import {
+    convertLimit,
+    convertOffset,
+    convertFetch,
+    convertForUpdate,
+} from '../from/limit.js';
 
 const isString = (a) => typeof a === 'string';
 
@@ -48,16 +58,29 @@ const convertExtract = (column) => {
     ]);
 };
 
+const convertFilter = (column, fn) => {
+    if (!column.filter)
+        return fn;
+    
+    const {where} = column.filter;
+    const condition = convertCondition(where.expr.expr);
+    
+    return callExpression(identifier('filter'), [fn, condition]);
+};
+
 const convertColumn = (column) => {
     if (isCount(column))
-        return convertCount(column);
+        return convertOverIfPresent(column, convertFilter(column, convertCount(column)));
     
     if (column.type === 'func_call')
-        return convertFuncCall(column);
+        return convertFilter(column, convertFuncCall(column));
     
     if (column.type === 'cast_expr')
         return convertCast(column);
     
+    if (column.type === 'cast_operator_expr')
+        return convertOperand(column);
+    
     if (column.type === 'extract_expr')
         return convertExtract(column);
     
@@ -91,12 +114,63 @@ const convertColumn = (column) => {
     if (column.type === 'array_literal_expr')
         return convertOperand(column);
     
+    if (column.type === 'prefix_op_expr')
+        return convertOperand(column);
+    
+    if (column.type === 'postfix_op_expr')
+        return convertCondition(column);
+    
+    if (column.type === 'between_expr')
+        return convertBetween(column);
+    
+    // quoted identifier like "weird col" — keep original text
+    if (isString(column.text) && column.text.startsWith('"'))
+        return stringLiteral(column.text);
+    
     return identifier(column.name);
 };
 
+const convertOverIfPresent = (column, fn) => {
+    if (!column.over)
+        return fn;
+    
+    return convertOver(column, fn);
+};
+
+const isWindowRef = (over) => over.window.type === 'identifier';
+
+const convertFrameBound = (bound) => {
+    if (bound.type === 'frame_bound_current_row')
+        return callExpression(identifier('currentRow'), []);
+    
+    const name = bound.type === 'frame_bound_preceding' ? 'preceding' : 'following';
+    
+    const isUnbounded = bound.expr?.type === 'frame_unbounded';
+    const args = !isUnbounded && bound.expr ? [
+        numericLiteral(bound.expr.value),
+    ] : [];
+    
+    return callExpression(identifier(name), args);
+};
+
+const convertFrame = ({extent}) => callExpression(identifier('rowsBetween'), [
+    convertFrameBound(extent.begin),
+    convertFrameBound(extent.end),
+]);
+
 const convertOverClause = (over) => {
+    if (isWindowRef(over))
+        return [
+            identifier(over.window.name),
+        ];
+    
     const result = [];
-    const {partitionBy, orderBy} = over.window.expr;
+    
+    const {
+        partitionBy,
+        orderBy,
+        frame,
+    } = over.window.expr;
     
     if (partitionBy)
         result.push(callExpression(identifier('partitionBy'), partitionBy.specifications.items.map(convertOperand)));
@@ -104,6 +178,9 @@ const convertOverClause = (over) => {
     if (orderBy)
         result.push(convertOrderBy(orderBy));
     
+    if (frame)
+        result.push(convertFrame(frame));
+    
     return result;
 };
 
@@ -159,19 +236,57 @@ const convertColumns = (columns) => {
 
 const isDistinct = (selectClause) => selectClause.modifiers.some(({type}) => type === 'select_distinct');
 
+const convertDistinctOn = ({modifiers}) => {
+    if (!modifiers.some(({type}) => type === 'select_distinct_on'))
+        return null;
+    
+    const modifier = modifiers.find(({type}) => type === 'select_distinct_on');
+    const onCols = [];
+    
+    for (const item of modifier.columns.expr.items) {
+        onCols.push(identifier(item.name));
+    }
+    
+    return callExpression(identifier('distinctOn'), onCols);
+};
+
+const convertValuesRow = (node) => {
+    const {items} = node.expr;
+    
+    return callExpression(identifier('row'), items.map(convertOperand));
+};
+
+const convertValuesClause = (clause) => callExpression(identifier('values'), clause.values.items.map(convertValuesRow));
+
 export const convertSelect = ({clauses}) => {
     const selectClause = findClause(clauses, 'select_clause');
+    const valuesClause = findClause(clauses, 'values_clause');
+    
+    if (!selectClause && valuesClause)
+        return convertValuesClause(valuesClause);
+    
     const fromClause = findClause(clauses, 'from_clause');
     const whereClause = findClause(clauses, 'where_clause');
     const groupByClause = findClause(clauses, 'group_by_clause');
     const havingClause = findClause(clauses, 'having_clause');
     const orderByClause = findClause(clauses, 'order_by_clause');
+    const windowClause = findClause(clauses, 'window_clause');
     const limitClause = findClause(clauses, 'limit_clause');
+    const offsetClause = findClause(clauses, 'offset_clause');
+    const fetchClause = findClause(clauses, 'fetch_clause');
+    const forClause = findClause(clauses, 'for_clause');
     
     const cols = convertColumns(selectClause.columns);
-    const selectArgs = isDistinct(selectClause) ? [
-        callExpression(identifier('distinct'), cols),
-    ] : cols;
+    const distinctOn = convertDistinctOn(selectClause);
+    const selectArgs = [];
+    
+    if (distinctOn)
+        selectArgs.push(distinctOn);
+    
+    if (isDistinct(selectClause))
+        selectArgs.push(callExpression(identifier('distinct'), cols));
+    else
+        selectArgs.push(...cols);
     
     const args = [
         ...selectArgs,
@@ -181,9 +296,27 @@ export const convertSelect = ({clauses}) => {
             groupByClause,
             havingClause,
             orderByClause,
+            windowClause,
             limitClause,
+            offsetClause,
+            fetchClause,
+            forClause,
         }),
     ].filter(Boolean);
     
+    if (!fromClause) {
+        if (limitClause)
+            args.push(convertLimit(limitClause));
+        
+        if (offsetClause)
+            args.push(convertOffset(offsetClause));
+        
+        if (fetchClause)
+            args.push(convertFetch(fetchClause));
+        
+        if (forClause)
+            args.push(convertForUpdate());
+    }
+    
     return callExpression(identifier('select'), args);
 };

package/lib/parser/visitors/clause/set-param/set-param.js

@@ -0,0 +1,19 @@
+import {types} from '@putout/babel';
+import {convertOperand} from '#parser/clause/operand';
+
+const {identifier, callExpression} = types;
+
+export const convertSetParam = (stmt) => {
+    const args = [
+        identifier(stmt.name.name),
+    ];
+    
+    for (const item of stmt.value.items)
+        args.push(convertOperand(item));
+    
+    return callExpression(identifier('setParam'), args);
+};
+
+export const convertShowParam = (stmt) => callExpression(identifier('showParam'), [
+    identifier(stmt.name.name),
+]);

package/lib/parser/visitors/clause/table-constraint.js

@@ -0,0 +1,27 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+export const convertConstraintColumn = (item) => {
+    if (item.expr)
+        return identifier(item.expr.name);
+    
+    return identifier(item.name);
+};
+
+const convertConstraintColumns = ({columns}) => columns.expr.items.map(convertConstraintColumn);
+
+export const TABLE_CONSTRAINTS = {
+    constraint_primary_key: (item) => callExpression(identifier('tablePrimaryKey'), convertConstraintColumns(item)),
+    constraint_unique: (item) => callExpression(identifier('tableUnique'), convertConstraintColumns(item)),
+};
+
+export const convertTableConstraint = (item) => {
+    if (item.type === 'constraint')
+        return callExpression(identifier('constraint'), [
+            identifier(item.name.name.name),
+            convertTableConstraint(item.constraint),
+        ]);
+    
+    return TABLE_CONSTRAINTS[item.type](item);
+};

package/lib/parser/visitors/clause/update/update.js

@@ -10,6 +10,20 @@ const {
     callExpression,
 } = types;
 
+const OR_ACTION_MAP = {
+    REPLACE: () => callExpression(identifier('orReplace'), []),
+    IGNORE: () => callExpression(identifier('orIgnore'), []),
+    ABORT: () => callExpression(identifier('orAbort'), []),
+    FAIL: () => callExpression(identifier('orFail'), []),
+};
+
+const convertOrAction = (orAction) => {
+    if (!orAction)
+        return null;
+    
+    return OR_ACTION_MAP[orAction.actionKw.name]();
+};
+
 export const convertUpdate = ({clauses}) => {
     const updateClause = findClause(clauses, 'update_clause');
     const setClause = findClause(clauses, 'set_clause');
@@ -26,7 +40,10 @@ export const convertUpdate = ({clauses}) => {
     
     const setCall = callExpression(identifier('set'), setArgs);
     
+    const orAction = convertOrAction(updateClause.orAction);
+    
     const args = [
+        orAction,
         table,
         setCall,
         fromClause && convertFromClause(fromClause),

package/lib/parser/visitors/clause/where/where.js

@@ -31,6 +31,20 @@ const isExists = (node) => node.type === 'prefix_op_expr' && node.operator.name
 const isNotExists = (node) => node.type === 'prefix_op_expr' && node.operator.name === 'NOT' && isExists(node.expr);
 const isParenExpr = (node) => node.type === 'paren_expr';
 
+const POSTFIX_OP = {
+    ISNULL: 'isNull',
+    NOTNULL: 'isNotNull',
+};
+
+const convertPostfix = (node) => {
+    const {name} = node.operator;
+    const fn = POSTFIX_OP[name];
+    
+    return callExpression(identifier(fn), [
+        convertOperand(node.expr),
+    ]);
+};
+
 export const convertCondition = (node) => {
     if (node.operator && node.operator.name === 'AND')
         return convertAnd(node);
@@ -41,6 +55,9 @@ export const convertCondition = (node) => {
     if (node.type === 'between_expr')
         return convertBetween(node);
     
+    if (node.type === 'postfix_op_expr')
+        return convertPostfix(node);
+    
     if (isNotExists(node))
         return callExpression(identifier('notExists'), [
             convertClause(node.expr.expr.expr),

package/lib/printer/visitors/call-expression/clauses/access-method/access-method.js

@@ -0,0 +1,4 @@
+export const accessMethod = (path, {write, traverse}) => {
+    write('USING ');
+    traverse(path.get('arguments.0'));
+};

package/lib/printer/visitors/call-expression/clauses/analyze/analyze.js

@@ -0,0 +1,10 @@
+export const analyze = (path, {write, traverse}) => {
+    const args = path.get('arguments');
+    
+    write('ANALYZE');
+    
+    if (args.length) {
+        write.space();
+        traverse(args[0]);
+    }
+};

package/lib/printer/visitors/call-expression/clauses/array-type/array-type.js

@@ -0,0 +1,4 @@
+export const arrayType = (path, {write, traverse}) => {
+    traverse(path.get('arguments')[0]);
+    write('[]');
+};

package/lib/printer/visitors/call-expression/clauses/clauses.js

@@ -36,7 +36,9 @@ import {max} from './max/max.js';
 import {orderBy} from './order-by/order-by.js';
 import {desc} from './desc/desc.js';
 import {limit} from './limit/limit.js';
+import {namedWindow} from './named-window/named-window.js';
 import {distinct} from './distinct/distinct.js';
+import {distinctOn} from './distinct-on/distinct-on.js';
 import {notInList} from './not-in-list/not-in-list.js';
 import {between} from './between/between.js';
 import {notBetween} from './not-between/not-between.js';
@@ -52,7 +54,31 @@ import {lateralJoin} from './lateral-join/lateral-join.js';
 import {lateralSubquery} from './lateral-subquery/lateral-subquery.js';
 import {createIndex} from './create-index/create-index.js';
 import {createUniqueIndex} from './create-index/create-unique-index.js';
+import {concurrently} from './concurrently/concurrently.js';
+import {ifNotExists} from './if-not-exists/if-not-exists.js';
+import {explain} from './explain/explain.js';
+import {explainAnalyze} from './explain-analyze/explain-analyze.js';
+import {explainQueryPlan} from './explain-query-plan/explain-query-plan.js';
+import {setParam} from './set-param/set-param.js';
+import {showParam} from './show-param/show-param.js';
+import {createView} from './create-view/create-view.js';
+import {createMaterializedView} from './create-materialized-view/create-materialized-view.js';
+import {dropView} from './drop-view/drop-view.js';
+import {createExtension} from './create-extension/create-extension.js';
+import {createSchema} from './create-schema/create-schema.js';
+import {grant} from './grant/grant.js';
+import {privilege} from './privilege/privilege.js';
+import {grantOn} from './grant-on/grant-on.js';
+import {to} from './to/to.js';
+import {indexedBy} from './indexed-by/indexed-by.js';
+import {notIndexed} from './not-indexed/not-indexed.js';
+import {createVirtualTable} from './create-virtual-table/create-virtual-table.js';
+import {reindex} from './reindex/reindex.js';
+import {analyze} from './analyze/analyze.js';
+import {releaseSavepoint} from './release-savepoint/release-savepoint.js';
+import {doBlock} from './do-block/do-block.js';
 import {vacuum} from './vacuum/vacuum.js';
+import {truncate} from './truncate/truncate.js';
 import {row} from './row/row.js';
 import {notNull} from './not-null/not-null.js';
 import {default_} from './default/default.js';
@@ -65,8 +91,21 @@ import {leftJoin} from './left-join/left-join.js';
 import {rightJoin} from './right-join/right-join.js';
 import {innerJoin} from './inner-join/inner-join.js';
 import {leftOuterJoin} from './left-outer-join/left-outer-join.js';
+import {rightOuterJoin} from './right-outer-join/right-outer-join.js';
 import {crossJoin} from './cross-join/cross-join.js';
 import {createTable} from './create-table/create-table.js';
+import {
+    limitAll,
+    offset,
+    fetchFirst,
+    forUpdate,
+} from './limit-clauses.js';
+import {
+    createTempTable,
+    createTempTableIfNotExists,
+} from './create-temp-table/create-temp-table.js';
+import {withoutRowid} from './without-rowid/without-rowid.js';
+import {createTableAs} from './create-table-as/create-table-as.js';
 import {alterTable} from './alter-table/alter-table.js';
 import {addColumn} from './add-column/add-column.js';
 import {dropColumn} from './drop-column/drop-column.js';
@@ -80,6 +119,7 @@ import {savepoint} from './savepoint/savepoint.js';
 import {createSequence} from './create-sequence/create-sequence.js';
 import {extract} from './extract/extract.js';
 import {concat} from './concat/concat.js';
+import {filter} from './filter/filter.js';
 import {array} from './array/array.js';
 import {over} from './over/over.js';
 import {partitionBy} from './partition-by/partition-by.js';
@@ -88,13 +128,14 @@ import {dropTable} from './drop-table/drop-table.js';
 import {dropIndex} from './drop-index/drop-index.js';
 import {pragma} from './pragma/pragma.js';
 import {attach} from './attach/attach.js';
+import {detach} from './detach/detach.js';
 import {column} from './column/column.js';
 import {autoIncrement} from './auto-increment/auto-increment.js';
 import {serial} from './serial/serial.js';
 import {primaryKey} from './primary-key/primary-key.js';
 import {lastInsertRowid} from './last-insert-rowid/last-insert-rowid.js';
 import {lastval} from './lastval/lastval.js';
-import {nextval} from './nextval/nextval.js';
+import {defaultNextval} from './default-nextval/default-nextval.js';
 import {like} from './like/like.js';
 import {isNull, isNotNull} from './is-null/is-null.js';
 import {orReplace} from './or-replace/or-replace.js';
@@ -104,6 +145,33 @@ import {
     identity,
     identityByDefault,
 } from './identity/identity.js';
+import {not} from './not/not.js';
+import {unaryMinus} from './unary-minus/unary-minus.js';
+import {arrayType} from './array-type/array-type.js';
+import {using} from './using/using.js';
+import {defaultValues} from './default-values/default-values.js';
+import {tablePrimaryKey} from './table-primary-key/table-primary-key.js';
+import {tableUnique} from './table-unique/table-unique.js';
+import {constraint} from './constraint/constraint.js';
+import {renameTable} from './rename-table/rename-table.js';
+import {
+    enableRowLevelSecurity,
+    disableRowLevelSecurity,
+} from './row-level-security/row-level-security.js';
+import {nullsFirst, nullsLast} from './nulls-order/nulls-order.js';
+import {orAbort} from './or-abort/or-abort.js';
+import {orFail} from './or-fail/or-fail.js';
+import {countDistinct} from './count-distinct/count-distinct.js';
+import {generatedAlwaysAs} from './generated-always-as/generated-always-as.js';
+import {accessMethod} from './access-method/access-method.js';
+import {onDelete, onUpdate} from './on-delete/on-delete.js';
+import {collate} from './collate/collate.js';
+import {
+    rowsBetween,
+    preceding,
+    following,
+    currentRow,
+} from './window-frame/window-frame.js';
 
 export const clauses = {
     join,
@@ -124,7 +192,31 @@ export const clauses = {
     lateralSubquery,
     createIndex,
     createUniqueIndex,
+    concurrently,
+    ifNotExists,
+    explain,
+    explainAnalyze,
+    explainQueryPlan,
+    setParam,
+    showParam,
+    createView,
+    createMaterializedView,
+    dropView,
+    createExtension,
+    createSchema,
+    grant,
+    privilege,
+    grantOn,
+    to,
+    indexedBy,
+    notIndexed,
+    createVirtualTable,
+    reindex,
+    analyze,
+    releaseSavepoint,
+    doBlock,
     vacuum,
+    truncate,
     row,
     notNull,
     default_,
@@ -155,7 +247,13 @@ export const clauses = {
     orderBy,
     desc,
     limit,
+    limitAll,
+    offset,
+    fetchFirst,
+    forUpdate,
+    namedWindow,
     distinct,
+    distinctOn,
     notInList,
     notBetween,
     between,
@@ -169,10 +267,15 @@ export const clauses = {
     rightJoin,
     innerJoin,
     leftOuterJoin,
+    rightOuterJoin,
     fullOuterJoin,
     naturalJoin,
     crossJoin,
     createTable,
+    createTempTable,
+    createTempTableIfNotExists,
+    withoutRowid,
+    createTableAs,
     alterTable,
     addColumn,
     dropColumn,
@@ -186,6 +289,7 @@ export const clauses = {
     createSequence,
     extract,
     concat,
+    filter,
     array,
     over,
     partitionBy,
@@ -194,21 +298,47 @@ export const clauses = {
     dropIndex,
     pragma,
     attach,
+    detach,
     column,
     autoIncrement,
     serial,
     primaryKey,
     lastInsertRowid,
     lastval,
-    nextval,
+    defaultNextval,
     like,
     notLike,
     ilike,
     similarTo,
     isDistinctFrom,
+    collate,
     isNull,
     isNotNull,
     inList,
     identity,
     identityByDefault,
+    not,
+    unaryMinus,
+    arrayType,
+    using,
+    defaultValues,
+    tablePrimaryKey,
+    tableUnique,
+    constraint,
+    renameTable,
+    enableRowLevelSecurity,
+    disableRowLevelSecurity,
+    nullsFirst,
+    nullsLast,
+    orAbort,
+    orFail,
+    countDistinct,
+    generatedAlwaysAs,
+    accessMethod,
+    onDelete,
+    onUpdate,
+    rowsBetween,
+    preceding,
+    following,
+    currentRow,
 };

package/lib/printer/visitors/call-expression/clauses/collate/collate.js

@@ -0,0 +1,7 @@
+export const collate = (path, {write, traverse}) => {
+    const [left, right] = path.get('arguments');
+    
+    traverse(left);
+    write(' COLLATE ');
+    traverse(right);
+};

package/lib/printer/visitors/call-expression/clauses/concurrently/concurrently.js

@@ -0,0 +1,2 @@
+// sentinel — consumed by createIndex/createUniqueIndex printer, never called
+export const concurrently = null;

package/lib/printer/visitors/call-expression/clauses/constraint/constraint.js

@@ -0,0 +1,11 @@
+export const constraint = (path, {write, traverse}) => {
+    write('CONSTRAINT ');
+    const args = path.get('arguments');
+    
+    for (const [i, arg] of args.entries()) {
+        if (i)
+            write(' ');
+        
+        traverse(arg);
+    }
+};

package/lib/printer/visitors/call-expression/clauses/count-distinct/count-distinct.js

@@ -0,0 +1,13 @@
+export const countDistinct = (path, {write, traverse}) => {
+    write('COUNT(DISTINCT ');
+    const args = path.get('arguments');
+    
+    for (const [i, arg] of args.entries()) {
+        if (i)
+            write(', ');
+        
+        traverse(arg);
+    }
+    
+    write(')');
+};

package/lib/printer/visitors/call-expression/clauses/create-extension/create-extension.js

@@ -0,0 +1,4 @@
+export const createExtension = (path, {write, traverse}) => {
+    write('CREATE EXTENSION ');
+    traverse(path.get('arguments')[0]);
+};