happy-sql 2.1.1 → 2.2.1

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

@@ -3,8 +3,25 @@ import {convertClause} from '#parser/clause';
 
 const {callExpression, identifier} = types;
 
-export const convertUnionAll = (stmt) => {
-    return callExpression(identifier('unionAll'), [
+const getOpNames = (operator) => {
+    if (Array.isArray(operator)) {
+        const names = [];
+        
+        for (const kw of operator)
+            names.push(kw.name);
+        
+        return names;
+    }
+    
+    return [operator.name];
+};
+
+export const convertUnion = (stmt) => {
+    const ops = getOpNames(stmt.operator);
+    const isAll = ops.includes('ALL');
+    const name = isAll ? 'unionAll' : 'union';
+    
+    return callExpression(identifier(name), [
         convertClause(stmt.left),
         convertClause(stmt.right),
     ]);

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

@@ -1,6 +1,7 @@
 import {types} from '@putout/babel';
 import {convertWhere} from '#parser/clause/where';
 import {convertOperand} from '#parser/clause/operand';
+import {convertReturning} from '#parser/clause/returning';
 import {findClause} from '#parser/clause/find';
 
 const {
@@ -12,7 +13,9 @@ const {
 export const convertUpdate = ({clauses}) => {
     const updateClause = findClause(clauses, 'update_clause');
     const setClause = findClause(clauses, 'set_clause');
+    const fromClause = findClause(clauses, 'from_clause');
     const whereClause = findClause(clauses, 'where_clause');
+    const returningClause = findClause(clauses, 'returning_clause');
     
     const table = identifier(updateClause.tables.items[0].name);
     const setArgs = [];
@@ -26,8 +29,14 @@ export const convertUpdate = ({clauses}) => {
     const args = [
         table,
         setCall,
+        fromClause && convertFromClause(fromClause),
         whereClause && convertWhere(whereClause),
+        returningClause && convertReturning(returningClause),
     ].filter(Boolean);
     
     return callExpression(identifier('update'), args);
 };
+
+const convertFromClause = (fromClause) => callExpression(identifier('updateFrom'), [
+    identifier(fromClause.expr.name),
+]);

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

@@ -1,101 +1,59 @@
 import {types} from '@putout/babel';
 import {convertOperand} from '#parser/clause/operand';
-
-const isString = (a) => typeof a === 'string';
+import {convertClause} from '#parser/clause';
+import {convertBinary} from '#parser/clause/binary';
 
 const {
     logicalExpression,
     identifier,
     callExpression,
-    binaryExpression,
 } = types;
 
-const opName = (op) => {
-    if (Array.isArray(op))
-        return op
-            .map((k) => k.name)
-            .join(' ');
-    
-    if (isString(op))
-        return op;
-    
-    return op?.name ?? '';
-};
-
-const SQL_TO_JS_OP = {
-    '=': '===',
-    '!=': '!==',
-    '>=': '>=',
-    '<=': '<=',
-    '>': '>',
-    '<': '<',
-};
-
 const convertAnd = (node) => logicalExpression('&&', convertCondition(node.left), convertCondition(node.right));
 const convertOr = (node) => logicalExpression('||', convertCondition(node.left), convertCondition(node.right));
 
-export const convertBetween = (node) => callExpression(identifier('between'), [
-    convertOperand(node.left),
-    convertOperand(node.begin),
-    convertOperand(node.end),
-]);
+const isNotBetween = (node) => Array.isArray(node.betweenKw) && node.betweenKw[0].name === 'NOT';
 
-const convertBinary = (node) => {
-    const op = opName(node.operator);
-    
-    if (op === 'LIKE')
-        return callExpression(identifier('like'), [
-            convertOperand(node.left),
-            convertOperand(node.right),
-        ]);
-    
-    if (op === 'IS')
-        return callExpression(identifier('isNull'), [
-            convertOperand(node.left),
-        ]);
-    
-    if (op === 'IS NOT')
-        return callExpression(identifier('isNotNull'), [
-            convertOperand(node.left),
-        ]);
-    
-    if (op === 'IN') {
-        const items = node.right.expr.items.map(convertOperand);
-        
-        return callExpression(identifier('inList'), [
-            convertOperand(node.left),
-            ...items,
-        ]);
-    }
-    
-    if (op === 'NOT IN') {
-        const items = node.right.expr.items.map(convertOperand);
-        
-        return callExpression(identifier('notInList'), [
-            convertOperand(node.left),
-            ...items,
-        ]);
-    }
+export const convertBetween = (node) => {
+    const args = [
+        convertOperand(node.left),
+        convertOperand(node.begin),
+        convertOperand(node.end),
+    ];
     
-    const jsOp = SQL_TO_JS_OP[op] ?? '===';
+    if (isNotBetween(node))
+        return callExpression(identifier('notBetween'), args);
     
-    return binaryExpression(
-        jsOp,
-        convertOperand(node.left),
-        convertOperand(node.right),
-    );
+    return callExpression(identifier('between'), args);
 };
 
+const isExists = (node) => node.type === 'prefix_op_expr' && node.operator.name === 'EXISTS';
+const isNotExists = (node) => node.type === 'prefix_op_expr' && node.operator.name === 'NOT' && isExists(node.expr);
+const isParenExpr = (node) => node.type === 'paren_expr';
+
 export const convertCondition = (node) => {
-    if (node.operator?.name === 'AND')
+    if (node.operator && node.operator.name === 'AND')
         return convertAnd(node);
     
-    if (node.operator?.name === 'OR')
+    if (node.operator && node.operator.name === 'OR')
         return convertOr(node);
     
     if (node.type === 'between_expr')
         return convertBetween(node);
     
+    if (isNotExists(node))
+        return callExpression(identifier('notExists'), [
+            convertClause(node.expr.expr.expr),
+        ]);
+    
+    if (isExists(node))
+        return callExpression(identifier('exists'), [
+            convertClause(node.expr.expr),
+        ]);
+    
+    if (isParenExpr(node))
+        return convertCondition(node.expr);
+    
     return convertBinary(node);
 };
 

package/lib/printer/visitors/array-expression.js

@@ -1,4 +1,11 @@
-export const ArrayExpression = (path, {write, traverse}) => {
+import {isJsonTuple, printJsonTuple} from './call-expression/clauses/json-op.js';
+
+export const ArrayExpression = (path, printer) => {
+    const {write, traverse} = printer;
+    
+    if (isJsonTuple(path.node))
+        return printJsonTuple(path, printer);
+    
     const elements = path.get('elements');
     const n = elements.length - 1;
     

package/lib/printer/visitors/boolean-literal.js

@@ -0,0 +1,8 @@
+export const BooleanLiteral = (path, {write}) => {
+    const {value} = path.node;
+    
+    if (value)
+        return write('TRUE');
+    
+    write('FALSE');
+};

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

@@ -1,11 +1,28 @@
 import {clauses} from './clauses/clauses.js';
 
+const printGenericCall = (path, {write, traverse}) => {
+    const {name} = path.node.callee;
+    const args = path.get('arguments');
+    
+    write(name);
+    write('(');
+    
+    for (const [i, arg] of args.entries()) {
+        if (i > 0)
+            write(', ');
+        
+        traverse(arg);
+    }
+    
+    write(')');
+};
+
 export const CallExpression = (path, printer) => {
     const {name} = path.node.callee;
     const visit = clauses[name];
     
     if (!visit)
-        throw Error(`${name} not supported yet`);
+        return printGenericCall(path, printer);
     
     visit(path, printer);
 };

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

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

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

@@ -0,0 +1,10 @@
+export const ALL = (path, {write, traverse}) => {
+    write('ALL(');
+    
+    const args = path.get('arguments');
+    
+    for (const arg of args)
+        traverse(arg);
+    
+    write(')');
+};

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

@@ -0,0 +1,8 @@
+export const alterColumnType = (path, {write, traverse}) => {
+    const [col, type] = path.get('arguments');
+    
+    write('ALTER COLUMN ');
+    traverse(col);
+    write(' TYPE ');
+    traverse(type);
+};

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

@@ -0,0 +1,12 @@
+export const alterTable = (path, {write, traverse}) => {
+    const args = path.get('arguments');
+    const [table] = args;
+    
+    write('ALTER TABLE ');
+    traverse(table);
+    
+    for (const arg of args.slice(1)) {
+        write.newline();
+        traverse(arg);
+    }
+};

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

@@ -0,0 +1,10 @@
+export const ANY = (path, {write, traverse}) => {
+    write('ANY(');
+    
+    const args = path.get('arguments');
+    
+    for (const arg of args)
+        traverse(arg);
+    
+    write(')');
+};

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

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

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

@@ -0,0 +1,8 @@
+export const attach = (path, {write, traverse}) => {
+    const [file, schema] = path.get('arguments');
+    
+    write('ATTACH DATABASE ');
+    traverse(file);
+    write(' AS ');
+    traverse(schema);
+};

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

@@ -0,0 +1,3 @@
+export const begin = (path, {write}) => {
+    write('BEGIN');
+};

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

@@ -0,0 +1,33 @@
+const isElseClause = (path) => {
+    const {callee} = path.node;
+    
+    return callee && callee.name === 'else_';
+};
+
+export const caseWhen = (path, printer) => {
+    const {write} = printer;
+    const args = path.get('arguments');
+    const lastArg = args.at(-1);
+    const hasElse = isElseClause(lastArg);
+    
+    write('CASE ');
+    
+    for (let i = 0; i < args.length - 1; i += 2) {
+        write('WHEN ');
+        printer.traverse(args[i]);
+        write(' THEN ');
+        printer.traverse(args[i + 1]);
+        
+        // space between clauses / before ELSE — but not trailing
+        if (i < args.length - 3)
+            write(' ');
+    }
+    
+    if (hasElse) {
+        write(' ');
+        write('ELSE ');
+        printer.traverse(lastArg.get('arguments')[0]);
+    }
+    
+    write(' END');
+};

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

@@ -0,0 +1,9 @@
+export const cast = (path, {write, traverse}) => {
+    const [expr, typeArg] = path.get('arguments');
+    
+    write('CAST(');
+    traverse(expr);
+    write(' AS ');
+    traverse(typeArg);
+    write(')');
+};

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

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

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

@@ -1,4 +1,10 @@
+import {fullOuterJoin} from './full-outer-join/full-outer-join.js';
 import {join} from './join/join.js';
+import {naturalJoin} from './natural-join/natural-join.js';
+import {notLike} from './not-like/not-like.js';
+import {ilike} from './ilike/ilike.js';
+import {similarTo} from './similar-to/similar-to.js';
+import {isDistinctFrom} from './is-distinct-from/is-distinct-from.js';
 import {on} from './on/on.js';
 import {select} from './select/select.js';
 import {from} from './from/from.js';
@@ -8,6 +14,7 @@ import {into} from './into/into.js';
 import {values} from './values/values.js';
 import {onConflict} from './on-conflict/on-conflict.js';
 import {update} from './update/update.js';
+import {updateFrom} from './update-from/update-from.js';
 import {set} from './set/set.js';
 import {deleteFrom} from './delete/delete.js';
 import {section} from './section/section.js';
@@ -16,6 +23,7 @@ import {returning} from './returning/returning.js';
 import {withNamed} from './with-named/with-named.js';
 import {withRecursive} from './with-recursive/with-recursive.js';
 import {unionAll} from './union-all/union-all.js';
+import {union} from './union/union.js';
 import {groupBy} from './group-by/group-by.js';
 import {having} from './having/having.js';
 import {sum} from './sum/sum.js';
@@ -28,8 +36,55 @@ import {limit} from './limit/limit.js';
 import {distinct} from './distinct/distinct.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';
+import {subquery} from './subquery/subquery.js';
+import {inQuery} from './in-query/in-query.js';
+import {exists} from './exists/exists.js';
+import {notExists} from './not-exists/not-exists.js';
+import {cast} from './cast/cast.js';
+import {pgCast} from './pg-cast/pg-cast.js';
+import {ANY} from './any/any.js';
+import {ALL} from './all/all.js';
+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 {vacuum} from './vacuum/vacuum.js';
+import {row} from './row/row.js';
+import {notNull} from './not-null/not-null.js';
+import {default_} from './default/default.js';
+import {unique} from './unique/unique.js';
+import {check} from './check/check.js';
+import {references} from './references/references.js';
+import {createTableIfNotExists} from './create-table-if-not-exists/create-table-if-not-exists.js';
+import {caseWhen} from './case-when/case-when.js';
+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 {crossJoin} from './cross-join/cross-join.js';
 import {createTable} from './create-table/create-table.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';
+import {renameColumn} from './rename-column/rename-column.js';
+import {alterColumnType} from './alter-column-type/alter-column-type.js';
+import {begin} from './begin/begin.js';
+import {commit} from './commit/commit.js';
+import {rollback} from './rollback/rollback.js';
+import {rollbackTo} from './rollback-to/rollback-to.js';
+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 {array} from './array/array.js';
+import {over} from './over/over.js';
+import {partitionBy} from './partition-by/partition-by.js';
+import {rowNumber} from './row-number/row-number.js';
+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 {column} from './column/column.js';
 import {autoIncrement} from './auto-increment/auto-increment.js';
 import {serial} from './serial/serial.js';
@@ -39,6 +94,8 @@ import {lastval} from './lastval/lastval.js';
 import {nextval} from './nextval/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';
+import {orIgnore} from './or-ignore/or-ignore.js';
 import {inList} from './in-list/in-list.js';
 import {
     identity,
@@ -54,9 +111,27 @@ export const clauses = {
     where,
     insert,
     into,
+    orReplace,
+    orIgnore,
+    pgCast,
+    ANY,
+    ALL,
+    lateralJoin,
+    lateralSubquery,
+    createIndex,
+    createUniqueIndex,
+    vacuum,
+    row,
+    notNull,
+    default_,
+    unique,
+    check,
+    references,
+    createTableIfNotExists,
     values,
     onConflict,
     update,
+    updateFrom,
     set,
     deleteFrom,
     section,
@@ -64,6 +139,7 @@ export const clauses = {
     withNamed,
     withRecursive,
     unionAll,
+    union,
     groupBy,
     having,
     sum,
@@ -75,9 +151,43 @@ export const clauses = {
     limit,
     distinct,
     notInList,
+    notBetween,
     between,
+    subquery,
+    inQuery,
+    exists,
+    notExists,
+    cast,
+    caseWhen,
+    leftJoin,
+    rightJoin,
+    innerJoin,
+    leftOuterJoin,
+    fullOuterJoin,
+    naturalJoin,
+    crossJoin,
     createTable,
+    alterTable,
+    addColumn,
+    dropColumn,
+    renameColumn,
+    alterColumnType,
+    begin,
+    commit,
+    rollback,
+    rollbackTo,
+    savepoint,
     createSequence,
+    extract,
+    concat,
+    array,
+    over,
+    partitionBy,
+    rowNumber,
+    dropTable,
+    dropIndex,
+    pragma,
+    attach,
     column,
     autoIncrement,
     serial,
@@ -86,6 +196,10 @@ export const clauses = {
     lastval,
     nextval,
     like,
+    notLike,
+    ilike,
+    similarTo,
+    isDistinctFrom,
     isNull,
     isNotNull,
     inList,

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

@@ -0,0 +1,3 @@
+export const commit = (path, {write}) => {
+    write('COMMIT');
+};

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

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

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

@@ -0,0 +1,20 @@
+export const createIndex = (path, {write, traverse}) => {
+    const args = path.get('arguments');
+    
+    write('CREATE 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(')');
+};

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

@@ -0,0 +1,20 @@
+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(')');
+};

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

@@ -1,7 +1,6 @@
-export const createTable = (path, {write, traverse}) => {
+export const printTableBody = (path, {write, traverse}) => {
     const [name, columns] = path.get('arguments');
     
-    write('CREATE TABLE ');
     traverse(name);
     write.space();
     write('(');
@@ -20,3 +19,8 @@ export const createTable = (path, {write, traverse}) => {
     
     write(')');
 };
+
+export const createTable = (path, printer) => {
+    printer.write('CREATE TABLE ');
+    printTableBody(path, printer);
+};

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

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

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

@@ -0,0 +1,9 @@
+import {printTable} from '../join/join.js';
+
+export const crossJoin = (path, printer) => {
+    const {write} = printer;
+    
+    write.breakline();
+    write('CROSS JOIN ');
+    printTable(path.get('arguments')[0], printer);
+};

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

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