happy-sql 2.3.0 → 2.4.0

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

@@ -1,20 +1,54 @@
-export const createIndex = (path, {write, traverse}) => {
-    const args = path.get('arguments');
+import {types} from '@putout/babel';
+
+const {isCallExpression} = types;
+
+const isConcurrently = (arg) => isCallExpression(arg.node) && arg.node.callee.name === 'concurrently';
+const isIfNotExists = (arg) => isCallExpression(arg.node) && arg.node.callee.name === 'ifNotExists';
+const isWhere = (arg) => isCallExpression(arg.node) && arg.node.callee.name === 'where';
+const isAccessMethod = (arg) => isCallExpression(arg.node) && arg.node.callee.name === 'accessMethod';
+const isCol = (arg) => !isConcurrently(arg) && !isIfNotExists(arg) && !isWhere(arg) && !isAccessMethod(arg);
+
+export const printIndexBody = (path, {write, traverse}) => {
+    const [name, table, ...rest] = path.get('arguments');
+    const cols = rest.filter(isCol);
+    const hasIfNotExists = rest.some(isIfNotExists);
+    const hasConcurrently = rest.some(isConcurrently);
+    const whereArg = rest.find(isWhere);
+    const accessMethod = rest.find(isAccessMethod);
     
-    write('CREATE INDEX ');
-    traverse(args[0]);
+    if (hasIfNotExists)
+        write('IF NOT EXISTS ');
+    
+    if (hasConcurrently)
+        write('CONCURRENTLY ');
+    
+    traverse(name);
     write(' ON ');
-    traverse(args[1]);
+    traverse(table);
+    
+    if (accessMethod) {
+        write(' USING ');
+        traverse(accessMethod.get('arguments.0'));
+    }
+    
     write(' (');
     
-    for (const [i, arg] of args
-        .slice(2)
-        .entries()) {
+    for (const [i, col] of cols.entries()) {
         if (i > 0)
             write(', ');
         
-        traverse(arg);
+        traverse(col);
     }
     
     write(')');
+    
+    if (whereArg) {
+        write.newline();
+        traverse(whereArg);
+    }
+};
+
+export const createIndex = (path, printer) => {
+    printer.write('CREATE INDEX ');
+    printIndexBody(path, printer);
 };

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

@@ -1,20 +1,6 @@
-export const createUniqueIndex = (path, {write, traverse}) => {
-    const args = path.get('arguments');
-    
-    write('CREATE UNIQUE INDEX ');
-    traverse(args[0]);
-    write(' ON ');
-    traverse(args[1]);
-    write(' (');
-    
-    for (const [i, arg] of args
-        .slice(2)
-        .entries()) {
-        if (i > 0)
-            write(', ');
-        
-        traverse(arg);
-    }
-    
-    write(')');
+import {printIndexBody} from './create-index.js';
+
+export const createUniqueIndex = (path, printer) => {
+    printer.write('CREATE UNIQUE INDEX ');
+    printIndexBody(path, printer);
 };

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

@@ -0,0 +1,8 @@
+export const createMaterializedView = (path, {write, traverse}) => {
+    const [name, stmt] = path.get('arguments');
+    
+    write('CREATE MATERIALIZED VIEW ');
+    traverse(name);
+    write(' AS ');
+    traverse(stmt);
+};

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

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

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

@@ -1,3 +1,7 @@
+import {types} from '@putout/babel';
+
+const {isCallExpression} = types;
+
 export const printTableBody = (path, {write, traverse}) => {
     const [name, columns] = path.get('arguments');
     
@@ -7,9 +11,17 @@ export const printTableBody = (path, {write, traverse}) => {
     write.newline();
     
     const elements = columns.get('elements');
+    let wroteRowid = false;
     
     for (const [i, element] of elements.entries()) {
-        if (i > 0) {
+        const isRowid = isCallExpression(element.node) && element.node.callee.name === 'withoutRowid';
+        
+        if (isRowid) {
+            wroteRowid = true;
+            continue;
+        }
+        
+        if (i > 0 && !wroteRowid) {
             write(',');
             write.newline();
         }
@@ -18,6 +30,9 @@ export const printTableBody = (path, {write, traverse}) => {
     }
     
     write(')');
+    
+    if (wroteRowid)
+        write(' WITHOUT ROWID');
 };
 
 export const createTable = (path, printer) => {

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

@@ -0,0 +1,8 @@
+export const createTableAs = (path, {write, traverse}) => {
+    const [name, stmt] = path.get('arguments');
+    
+    write('CREATE TABLE ');
+    traverse(name);
+    write(' AS ');
+    traverse(stmt);
+};

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

@@ -0,0 +1,11 @@
+import {printTableBody} from '../create-table/create-table.js';
+
+export const createTempTable = (path, printer) => {
+    printer.write('CREATE TEMP TABLE ');
+    printTableBody(path, printer);
+};
+
+export const createTempTableIfNotExists = (path, printer) => {
+    printer.write('CREATE TEMP TABLE IF NOT EXISTS ');
+    printTableBody(path, printer);
+};

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

@@ -0,0 +1,8 @@
+export const createView = (path, {write, traverse}) => {
+    const [name, stmt] = path.get('arguments');
+    
+    write('CREATE VIEW ');
+    traverse(name);
+    write(' AS ');
+    traverse(stmt);
+};

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

@@ -0,0 +1,8 @@
+export const createVirtualTable = (path, {write, traverse}) => {
+    const [name, module] = path.get('arguments');
+    
+    write('CREATE VIRTUAL TABLE ');
+    traverse(name);
+    write(' USING ');
+    traverse(module);
+};

package/lib/printer/visitors/call-expression/clauses/{nextval/nextval.js → default-nextval/default-nextval.js}

@@ -1,4 +1,5 @@
-export const nextval = (path, {write}) => {
+export const defaultNextval = (path, {write}) => {
     const [seq] = path.node.arguments;
+    
     write(`DEFAULT nextval('${seq.name}')`);
 };

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

@@ -0,0 +1,3 @@
+export const defaultValues = (path, {write}) => {
+    write('DEFAULT VALUES');
+};

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

@@ -0,0 +1,6 @@
+export const detach = (path, {write, traverse}) => {
+    const [schema] = path.get('arguments');
+    
+    write('DETACH DATABASE ');
+    traverse(schema);
+};

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

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

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

@@ -0,0 +1,5 @@
+export const doBlock = (path, {write}) => {
+    const [arg] = path.get('arguments');
+    
+    write(`DO $$${arg.node.value}$$`);
+};

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

@@ -1,9 +1,21 @@
+import {types} from '@putout/babel';
+
+const {isCallExpression} = types;
+
+const isIfExists = (arg) => isCallExpression(arg.node) && arg.node.callee.name === 'ifExists';
+
 export const dropIndex = (path, {write, traverse}) => {
     const args = path.get('arguments');
+    let rest = args;
     
     write('DROP INDEX ');
     
-    for (const [i, arg] of args.entries()) {
+    if (args.length > 0 && isIfExists(args[0])) {
+        write('IF EXISTS ');
+        rest = args.slice(1);
+    }
+    
+    for (const [i, arg] of rest.entries()) {
         if (i > 0)
             write(', ');
         

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

@@ -0,0 +1,24 @@
+import {types} from '@putout/babel';
+
+const {isCallExpression} = types;
+
+const isIfExists = (arg) => isCallExpression(arg.node) && arg.node.callee.name === 'ifExists';
+
+export const dropView = (path, {write, traverse}) => {
+    const args = path.get('arguments');
+    let rest = args;
+    
+    write('DROP VIEW ');
+    
+    if (args.length > 0 && isIfExists(args[0])) {
+        write('IF EXISTS ');
+        rest = args.slice(1);
+    }
+    
+    for (const [i, arg] of rest.entries()) {
+        if (i > 0)
+            write(', ');
+        
+        traverse(arg);
+    }
+};

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

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

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

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

package/lib/printer/visitors/call-expression/clauses/explain-query-plan/explain-query-plan.js

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

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

@@ -0,0 +1,5 @@
+export const fetchFirst = (path, {write, traverse}) => {
+    write('FETCH FIRST ');
+    traverse(path.get('arguments')[0]);
+    write(' ROWS ONLY');
+};

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

@@ -0,0 +1,8 @@
+export const filter = (path, {write, traverse}) => {
+    const [fn, condition] = path.get('arguments');
+    
+    traverse(fn);
+    write(' FILTER (WHERE ');
+    traverse(condition);
+    write(')');
+};

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

@@ -0,0 +1,3 @@
+export const forUpdate = (path, {write}) => {
+    write('FOR UPDATE');
+};

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,17 @@ 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) => ALL_CAPS_RE.test(name) ? name : 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()) {

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,11 +1,39 @@
+import {types} from '@putout/babel';
+
+const {isTSAsExpression} = 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') {

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

@@ -6,6 +6,7 @@ const JSON_OPS = new Set([
     '?',
     '?|',
     '?&',
+    '??',
     '@>',
     '<@',
 ]);

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,17 @@
+const isWhereArg = ({node}) => node.type === 'CallExpression' && 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,6 +27,11 @@ export const onConflict = (path, {write, traverse}) => {
         write(')');
     }
     
+    if (whereArg) {
+        write(' ');
+        traverse(whereArg);
+    }
+    
     write(' DO ');
     
     if (action.node.type === 'Identifier' && action.node.name === 'nothing') {