happy-sql 2.3.0 → 2.4.1

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

@@ -6,16 +6,40 @@ const {
 } = types;
 
 const printAsExpression = (path, {write, traverse}) => {
-    traverse(path.get('expression'));
-    write(` AS ${path.node.typeAnnotation.literal.value}`);
+    const expr = path.get('expression');
+    
+    if (isTableFunc(expr.node))
+        printTableFunc(expr, {
+            write,
+            traverse,
+        });
+    else
+        traverse(expr);
+    
+    if (isSubqueryAlias(path.node.expression))
+        write(' ');
+    else
+        write(' AS ');
+    
+    write(path.node.typeAnnotation.literal.value);
 };
 
+const isSubqueryAlias = (node) => isCallExpression(node) && [
+    'subquery',
+    'lateralSubquery',
+].includes(node.callee.name);
+
 const CLAUSE_NAMES = [
     'where',
     'groupBy',
     'having',
+    'namedWindow',
     'orderBy',
     'limit',
+    'limitAll',
+    'offset',
+    'fetchFirst',
+    'forUpdate',
 ];
 
 const TABLE_ARG_NAMES = [
@@ -23,6 +47,7 @@ const TABLE_ARG_NAMES = [
     'join',
     'leftJoin',
     'rightJoin',
+    'rightOuterJoin',
     'innerJoin',
     'leftOuterJoin',
     'fullOuterJoin',
@@ -32,6 +57,8 @@ const TABLE_ARG_NAMES = [
     'subquery',
     'lateralJoin',
     'lateralSubquery',
+    'indexedBy',
+    'notIndexed',
 ];
 
 const isClause = ({node}) => isCallExpression(node) && CLAUSE_NAMES.includes(node.callee.name);
@@ -39,13 +66,23 @@ const isClause = ({node}) => isCallExpression(node) && CLAUSE_NAMES.includes(nod
 const CAMEL_RE = /([A-Z])/g;
 const toSnake = (a) => a.replace(CAMEL_RE, (_, c) => `_${c.toLowerCase()}`);
 
+// single-word ALL-CAPS functions (UNNEST) keep their casing
+const ALL_CAPS_RE = /^[A-Z]+$/;
+
+const toFuncName = (name) => {
+    if (ALL_CAPS_RE.test(name))
+        return name;
+    
+    return toSnake(name);
+};
+
 const isTableFunc = (node) => isCallExpression(node) && !TABLE_ARG_NAMES.includes(node.callee.name);
 
 const printTableFunc = (path, {write, traverse}) => {
     const {name} = path.node.callee;
     const args = path.get('arguments');
     
-    write(toSnake(name));
+    write(toFuncName(name));
     write('(');
     
     for (const [i, arg] of args.entries()) {
@@ -73,8 +110,15 @@ const printArg = (path, printer) => {
 
 export const from = (path, {write, traverse}) => {
     const args = path.get('arguments');
-    const tableArgs = args.filter((arg) => !isClause(arg));
-    const clauseArgs = args.filter(isClause);
+    const tableArgs = [];
+    const clauseArgs = [];
+    
+    for (const arg of args) {
+        if (isClause(arg))
+            clauseArgs.push(arg);
+        else
+            tableArgs.push(arg);
+    }
     
     write('FROM ');
     printArg(tableArgs[0], {

package/lib/printer/visitors/call-expression/clauses/generated-always-as/generated-always-as.js

@@ -0,0 +1,10 @@
+export const generatedAlwaysAs = (path, {write, traverse}) => {
+    write('GENERATED ALWAYS AS (');
+    traverse(path.get('arguments.0'));
+    write(')');
+    
+    const [stored] = path.get('arguments').slice(1);
+    
+    if (stored.node.value)
+        write(' STORED');
+};

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

@@ -0,0 +1,10 @@
+export const grant = (path, {write, traverse}) => {
+    const [privArg, onArg, toArg] = path.get('arguments');
+    
+    write('GRANT ');
+    traverse(privArg);
+    write(' ON ');
+    traverse(onArg);
+    write(' TO ');
+    traverse(toArg);
+};

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

@@ -0,0 +1,10 @@
+export const grantOn = (path, {write, traverse}) => {
+    const args = path.get('arguments');
+    
+    for (let i = 0; i < args.length; i++) {
+        if (i > 0)
+            write(', ');
+        
+        traverse(args[i]);
+    }
+};

package/lib/printer/visitors/call-expression/clauses/if-not-exists/if-not-exists.js

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

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

@@ -0,0 +1,7 @@
+export const indexedBy = (path, {write, traverse}) => {
+    const [table, index] = path.get('arguments');
+    
+    traverse(table);
+    write(' INDEXED BY ');
+    traverse(index);
+};

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

@@ -1,14 +1,45 @@
+import {types} from '@putout/babel';
+
+const {
+    isTSAsExpression,
+    isArrayExpression,
+} = types;
+
+const printTable = (table, {write, traverse}) => {
+    if (isTSAsExpression(table.node)) {
+        traverse(table.get('expression'));
+        write(` AS ${table.node.typeAnnotation.literal.value}`);
+        
+        return;
+    }
+    
+    traverse(table);
+};
+
 export const into = (path, {write, traverse}) => {
     const args = path.get('arguments');
     const [table] = args;
+    
+    write('INTO ');
+    printTable(table, {
+        write,
+        traverse,
+    });
+    
+    // no column list: INTO t VALUES (...) / INTO t DEFAULT VALUES
+    if (args.length === 2) {
+        write.space();
+        traverse(args[1]);
+        
+        return;
+    }
+    
     const [, columns] = args;
     const values = args[2];
     
-    write('INTO ');
-    traverse(table);
     write(' (');
     
-    if (columns.node.type === 'ArrayExpression') {
+    if (isArrayExpression(columns.node)) {
         const colArgs = columns.get('elements');
         
         for (let i = 0; i < colArgs.length; i++) {

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

@@ -1,3 +1,10 @@
+import {types} from '@putout/babel';
+
+const {
+    isStringLiteral,
+    isArrayExpression,
+} = types;
+
 const JSON_OPS = new Set([
     '->',
     '->>',
@@ -6,11 +13,12 @@ const JSON_OPS = new Set([
     '?',
     '?|',
     '?&',
+    '??',
     '@>',
     '<@',
 ]);
 
-export const isJsonTuple = (node) => node.type === 'ArrayExpression' && node.elements.length === 3 && node.elements[1].type === 'StringLiteral' && JSON_OPS.has(node.elements[1].value);
+export const isJsonTuple = (node) => isArrayExpression(node) && node.elements.length === 3 && isStringLiteral(node.elements[1]) && JSON_OPS.has(node.elements[1].value);
 
 export const printJsonTuple = (path, {write, traverse}) => {
     const elems = path.get('elements');

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

@@ -1,6 +1,27 @@
 import {types} from '@putout/babel';
 
-const {isTSAsExpression} = types;
+const {
+    isTSAsExpression,
+    isCallExpression,
+} = types;
+
+const isSubqueryAlias = (node) => isCallExpression(node) && [
+    'subquery',
+    'lateralSubquery',
+].includes(node.callee.name);
+
+const printAsExpression = (path, {write, traverse}) => {
+    const {expression} = path.node;
+    
+    traverse(path.get('expression'));
+    
+    if (isSubqueryAlias(expression))
+        write(' ');
+    else
+        write(' AS ');
+    
+    write(path.node.typeAnnotation.literal.value);
+};
 
 export const lateralJoin = (path, {write, traverse}) => {
     write(', ');
@@ -9,8 +30,10 @@ export const lateralJoin = (path, {write, traverse}) => {
     const {node} = arg;
     
     if (isTSAsExpression(node)) {
-        traverse(arg.get('expression'));
-        write(` AS ${node.typeAnnotation.literal.value}`);
+        printAsExpression(arg, {
+            write,
+            traverse,
+        });
         
         return;
     }

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

@@ -3,4 +3,11 @@ export const like = (path, {write, traverse}) => {
     traverse(args[0]);
     write(' LIKE ');
     traverse(args[1]);
+    
+    const escape = args[2];
+    
+    if (escape) {
+        write(' ESCAPE ');
+        traverse(escape);
+    }
 };

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

@@ -0,0 +1,3 @@
+export const limitAll = (path, {write}) => {
+    write('LIMIT ALL');
+};

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

@@ -0,0 +1,4 @@
+export {limitAll} from './limit-all/limit-all.js';
+export {offset} from './offset/offset.js';
+export {fetchFirst} from './fetch-first/fetch-first.js';
+export {forUpdate} from './for-update/for-update.js';

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

@@ -0,0 +1,16 @@
+export const namedWindow = (path, {write, traverse}) => {
+    const args = path.get('arguments');
+    
+    write('WINDOW ');
+    traverse(args[0]);
+    write(' AS (');
+    
+    for (let i = 1; i < args.length; i++) {
+        if (i > 1)
+            write(' ');
+        
+        traverse(args[i]);
+    }
+    
+    write(')');
+};

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

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

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

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

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

@@ -0,0 +1,9 @@
+export const nullsFirst = (path, {write, traverse}) => {
+    traverse(path.get('arguments')[0]);
+    write(' NULLS FIRST');
+};
+
+export const nullsLast = (path, {write, traverse}) => {
+    traverse(path.get('arguments')[0]);
+    write(' NULLS LAST');
+};

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

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

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

@@ -1,7 +1,24 @@
+import {types} from '@putout/babel';
+
+const {
+    isIdentifier,
+    isCallExpression,
+} = types;
+
+const isWhereArg = ({node}) => isCallExpression(node) && node.callee.name === 'where';
+
 export const onConflict = (path, {write, traverse}) => {
     const args = path.get('arguments');
     const action = args.at(-1);
-    const targets = args.slice(0, -1);
+    let whereArg = null;
+    let targetCount = args.length - 1;
+    
+    if (targetCount && isWhereArg(args.at(-2))) {
+        whereArg = args.at(-2);
+        --targetCount;
+    }
+    
+    const targets = args.slice(0, targetCount);
     
     write('ON CONFLICT');
     
@@ -17,9 +34,14 @@ export const onConflict = (path, {write, traverse}) => {
         write(')');
     }
     
+    if (whereArg) {
+        write(' ');
+        traverse(whereArg);
+    }
+    
     write(' DO ');
     
-    if (action.node.type === 'Identifier' && action.node.name === 'nothing') {
+    if (isIdentifier(action.node) && action.node.name === 'nothing') {
         write('NOTHING');
         return;
     }

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

@@ -0,0 +1,32 @@
+const ACTION_PRINT = {
+    SET_NULL: 'SET NULL',
+    SET_DEFAULT: 'SET DEFAULT',
+    NO_ACTION: 'NO ACTION',
+};
+
+export const onDelete = (path, {write, traverse}) => {
+    write('ON DELETE ');
+    printAction(path, {
+        write,
+        traverse,
+    });
+};
+
+export const onUpdate = (path, {write, traverse}) => {
+    write('ON UPDATE ');
+    printAction(path, {
+        write,
+        traverse,
+    });
+};
+
+const printAction = (path, printer) => {
+    const {write, traverse} = printer;
+    const arg = path.get('arguments.0');
+    const {name} = arg.node;
+    
+    if (ACTION_PRINT[name])
+        return write(ACTION_PRINT[name]);
+    
+    traverse(arg);
+};

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

@@ -0,0 +1,3 @@
+export const orAbort = (path, {write}) => {
+    write('OR ABORT');
+};

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

@@ -0,0 +1,3 @@
+export const orFail = (path, {write}) => {
+    write('OR FAIL');
+};

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

@@ -1,9 +1,21 @@
+import {types} from '@putout/babel';
+
+const {isIdentifier} = types;
+
 export const over = (path, {write, traverse}) => {
     const args = path.get('arguments');
     const [func] = args;
     const clauses = args.slice(1);
     
     traverse(func);
+    
+    if (clauses.length && isIdentifier(clauses[0].node)) {
+        write(' OVER ');
+        traverse(clauses[0]);
+        
+        return;
+    }
+    
     write(' OVER (');
     
     for (const [i, clause] of clauses.entries()) {

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

@@ -1,9 +1,18 @@
 export const pragma = (path, {write, traverse}) => {
-    const [name, arg] = path.get('arguments');
+    const args = path.get('arguments');
     
     write('PRAGMA ');
-    traverse(name);
-    write('(');
-    traverse(arg);
-    write(')');
+    
+    // func-call form: PRAGMA table_info(users)
+    if (args.length === 2) {
+        traverse(args[0]);
+        write('(');
+        traverse(args[1]);
+        write(')');
+        
+        return;
+    }
+    
+    // no-args, qualified or assignment form
+    traverse(args[0]);
 };

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

@@ -0,0 +1,10 @@
+export const privilege = (path, {write, traverse}) => {
+    const args = path.get('arguments');
+    
+    for (let i = 0; i < args.length; i++) {
+        if (i > 0)
+            write(', ');
+        
+        traverse(args[i]);
+    }
+};

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

@@ -1,17 +1,39 @@
+const getCalleeName = (node) => {
+    if (!node || !node.callee)
+        return null;
+    
+    return node.callee.name;
+};
+
 export const references = (path, {write, traverse}) => {
-    write('REFERENCES ');
     const [first, ...other] = path.get('arguments');
+    const cols = [];
+    const actions = [];
     
-    traverse(first);
+    for (const arg of other) {
+        const name = getCalleeName(arg.node);
+        
+        if (name === 'onDelete' || name === 'onUpdate')
+            actions.push(arg);
+        else
+            cols.push(arg);
+    }
     
+    write('REFERENCES ');
+    traverse(first);
     write('(');
     
-    for (const [i, arg] of other.entries()) {
+    for (const [i, col] of cols.entries()) {
         if (i > 0)
             write(', ');
         
-        traverse(arg);
+        traverse(col);
     }
     
     write(')');
+    
+    for (const action of actions) {
+        write(' ');
+        traverse(action);
+    }
 };

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

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

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

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

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

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

package/lib/printer/visitors/call-expression/clauses/right-outer-join/right-outer-join.js

@@ -0,0 +1,8 @@
+import {printJoinBody} from '../join/join.js';
+
+export const rightOuterJoin = (path, printer) => {
+    const {write} = printer;
+    write.breakline();
+    write('RIGHT OUTER JOIN ');
+    printJoinBody(path, printer);
+};

package/lib/printer/visitors/call-expression/clauses/row-level-security/row-level-security.js

@@ -0,0 +1,7 @@
+export const enableRowLevelSecurity = (path, {write}) => {
+    write('ENABLE ROW LEVEL SECURITY');
+};
+
+export const disableRowLevelSecurity = (path, {write}) => {
+    write('DISABLE ROW LEVEL SECURITY');
+};

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

@@ -1,8 +1,12 @@
+import {types} from '@putout/babel';
+
+const {isArrayExpression} = types;
+
 export const section = (path, {write, traverse}) => {
     const [name, stmt] = path.get('arguments');
     write(`-- ${name.node.value}\n`);
     
-    if (stmt.node.type === 'ArrayExpression') {
+    if (isArrayExpression(stmt.node)) {
         const elements = stmt.get('elements');
         const lastIndex = elements.length - 1;
         

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

@@ -2,7 +2,10 @@ import {types} from '@putout/babel';
 import {createTypeChecker} from '@putout/printer/type-checker';
 import {isJsonTuple, printJsonTuple} from '../json-op.js';
 
-const {isTSAsExpression} = types;
+const {
+    isTSAsExpression,
+    isCallExpression,
+} = types;
 
 const printAsExpression = (path, {write, traverse}) => {
     traverse(path.get('expression'));
@@ -26,24 +29,41 @@ const isFrom = createTypeChecker([
     ['+: node.callee.name', '=', 'from'],
 ]);
 
+const isClauseName = (path) => isCallExpression(path.node) && [
+    'limitAll',
+    'offset',
+    'fetchFirst',
+    'forUpdate',
+].includes(path.node.callee.name);
+
+const isDistinctOn = (path) => isCallExpression(path.node) && path.node.callee.name === 'distinctOn';
+
 export const select = (path, printer) => {
     const {write, traverse} = printer;
-    const [cols, from] = parseCols(path);
+    const [cols, trailing] = parseCols(path);
     
     write('SELECT ');
     
+    let first = 0;
+    
+    if (cols.length && isDistinctOn(cols[0])) {
+        traverse(cols[0]);
+        write(' ');
+        first = 1;
+    }
+    
     const n = cols.length;
     
-    for (const [i, col] of cols.entries()) {
-        if (i && i < n)
+    for (let i = first; i < n; i++) {
+        if (i > first)
             write(', ');
         
-        printItem(col, printer);
+        printItem(cols[i], printer);
     }
     
-    if (isFrom(from)) {
+    for (const clause of trailing) {
         write.breakline();
-        traverse(from);
+        traverse(clause);
     }
 };
 
@@ -54,8 +74,16 @@ function parseCols(path) {
     if (isFrom(from))
         return [
             args.slice(0, -1),
-            from,
+            [from],
         ];
     
-    return [args, null];
+    let i = args.length;
+    
+    while (i && isClauseName(args[i - 1]))
+        --i;
+    
+    return [
+        args.slice(0, i),
+        args.slice(i),
+    ];
 }