happy-sql 2.1.1 → 2.2.1

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

@@ -1,122 +1,159 @@
 import {types} from '@putout/babel';
-import {convertOperand} from '#parser/clause/operand';
 import {convertBetween} from '#parser/clause/where';
+import {convertClause} from '#parser/clause';
+import {convertBinary} from '#parser/clause/binary';
 import {convertGroupBy} from './group-by.js';
 import {convertHaving} from './having.js';
 import {convertOrderBy} from './order-by.js';
 import {convertLimit} from './limit.js';
 import {convertTableFunc} from './table-func.js';
 
-const isString = (a) => typeof a === 'string';
-
 const {
     identifier,
     callExpression,
-    binaryExpression,
     logicalExpression,
     stringLiteral,
     tsAsExpression,
     tsLiteralType,
 } = types;
 
-const opName = (op) => {
-    if (Array.isArray(op))
-        return op
-            .map((k) => k.name)
-            .join(' ');
+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';
+
+const convertCondition = (node) => {
+    if (node.operator && node.operator.name === 'AND')
+        return logicalExpression('&&', convertCondition(node.left), convertCondition(node.right));
     
-    if (isString(op))
-        return op;
+    if (node.operator && node.operator.name === 'OR')
+        return logicalExpression('||', convertCondition(node.left), convertCondition(node.right));
     
-    return op?.name ?? '';
-};
-
-const SQL_TO_JS_OP = {
-    '=': '===',
-    '!=': '!==',
-    '>=': '>=',
-    '<=': '<=',
-    '>': '>',
-    '<': '<',
-};
-
-const convertBinary = (node) => {
-    const op = opName(node.operator);
+    if (node.type === 'between_expr')
+        return convertBetween(node);
     
-    if (op === 'LIKE')
-        return callExpression(identifier('like'), [
-            convertOperand(node.left),
-            convertOperand(node.right),
+    if (isNotExists(node))
+        return callExpression(identifier('notExists'), [
+            convertClause(node.expr.expr.expr),
         ]);
     
-    if (op === 'IS')
-        return callExpression(identifier('isNull'), [
-            convertOperand(node.left),
+    if (isExists(node))
+        return callExpression(identifier('exists'), [
+            convertClause(node.expr.expr),
         ]);
     
-    if (op === 'IS NOT')
-        return callExpression(identifier('isNotNull'), [
-            convertOperand(node.left),
-        ]);
+    if (isParenExpr(node))
+        return convertCondition(node.expr);
     
-    if (op === 'IN') {
-        const items = node.right.expr.items.map(convertOperand);
+    return convertBinary(node);
+};
+
+const convertOn = (spec) => callExpression(identifier('on'), [
+    convertCondition(spec.expr),
+]);
+
+const convertAlias = (node) => {
+    if (node.type !== 'alias')
+        return identifier(node.name);
+    
+    const isLateral = ({type}) => type === 'lateral_derived_table';
+    
+    if (isLateral(node.expr)) {
+        const inner = node.expr.expr.expr;
+        const aliasName = node.alias.name;
         
-        return callExpression(identifier('inList'), [
-            convertOperand(node.left),
-            ...items,
-        ]);
+        return tsAsExpression(callExpression(identifier('lateralSubquery'), [
+            convertClause(inner),
+        ]), tsLiteralType(stringLiteral(aliasName)));
     }
     
-    if (op === 'NOT IN') {
-        const items = node.right.expr.items.map(convertOperand);
+    if (isParenExpr(node.expr)) {
+        const inner = node.expr.expr;
+        const aliasName = node.alias.name;
         
-        return callExpression(identifier('notInList'), [
-            convertOperand(node.left),
-            ...items,
-        ]);
+        return tsAsExpression(callExpression(identifier('subquery'), [
+            convertClause(inner),
+        ]), tsLiteralType(stringLiteral(aliasName)));
     }
     
-    const jsOp = SQL_TO_JS_OP[op] ?? '===';
-    
-    return binaryExpression(
-        jsOp,
-        convertOperand(node.left),
-        convertOperand(node.right),
-    );
+    return tsAsExpression(identifier(node.expr.name), tsLiteralType(stringLiteral(node.alias.name)));
 };
 
-const convertCondition = (node) => {
-    if (node.operator?.name === 'AND')
-        return logicalExpression('&&', convertCondition(node.left), convertCondition(node.right));
+const joinTypeParts = (operator) => {
+    if (!operator)
+        return [];
     
-    if (node.operator?.name === 'OR')
-        return logicalExpression('||', convertCondition(node.left), convertCondition(node.right));
+    if (!Array.isArray(operator))
+        return [operator.name];
     
-    if (node.type === 'between_expr')
-        return convertBetween(node);
+    const parts = [];
     
-    return convertBinary(node);
+    for (const kw of operator)
+        parts.push(kw.name);
+    
+    return parts;
 };
 
-const convertOn = (spec) => callExpression(identifier('on'), [
-    convertCondition(spec.expr),
+const convertJoinType = (operator) => {
+    const parts = joinTypeParts(operator);
+    
+    // drop the trailing JOIN keyword — gives us LEFT, RIGHT, INNER, LEFT OUTER
+    parts.pop();
+    
+    if (!parts.length)
+        return 'join';
+    
+    // 'LEFT OUTER' → 'leftOuter' → 'leftOuterJoin'
+    const camel = parts[0].toLowerCase() +
+        parts
+            .slice(1)
+            .map((s) => s[0].toUpperCase() +
+            s
+                .slice(1)
+                .toLowerCase())
+            .join('');
+    
+    return `${camel}Join`;
+};
+
+const isNaturalJoin = (node) => joinTypeParts(node.operator).includes('NATURAL');
+
+const isCommaJoin = (node) => node.operator === ',';
+
+const isLateralAlias = ({expr}) => expr && expr.type === 'lateral_derived_table';
+
+const isCrossJoin = (node) => !node.specification && !isNaturalJoin(node);
+
+const convertCrossJoin = (node) => callExpression(identifier('crossJoin'), [
+    convertAlias(node.right),
 ]);
 
-const convertAlias = (node) => {
-    if (node.type === 'alias')
-        return tsAsExpression(identifier(node.expr.name), tsLiteralType(stringLiteral(node.alias.name)));
-    
-    return identifier(node.name);
-};
+const convertNaturalJoin = (node, fnName) => callExpression(identifier(fnName), [
+    convertAlias(node.right),
+]);
 
 const flattenJoins = (node, joins = []) => {
     if (node.type === 'join_expr') {
         flattenJoins(node.left, joins);
-        joins.push(callExpression(identifier('join'), [
-            convertAlias(node.right),
-            convertOn(node.specification),
-        ]));
+        
+        if (isCommaJoin(node) && isLateralAlias(node.right)) {
+            joins.push(callExpression(identifier('lateralJoin'), [
+                convertAlias(node.right),
+            ]));
+            
+            return joins;
+        }
+        
+        const fnName = convertJoinType(node.operator);
+        
+        if (isCrossJoin(node))
+            joins.push(convertCrossJoin(node));
+        else if (isNaturalJoin(node))
+            joins.push(convertNaturalJoin(node, fnName));
+        else
+            joins.push(callExpression(identifier(fnName), [
+                convertAlias(node.right),
+                convertOn(node.specification),
+            ]));
         
         return joins;
     }

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

@@ -1,12 +1,27 @@
+import {types} from '@putout/babel';
 import {convertSelect} from '#parser/clause/select';
 import {convertInsert} from '#parser/clause/insert';
 import {convertUpdate} from '#parser/clause/update';
 import {convertDelete} from '#parser/clause/delete';
 import {convertWithNamed} from '#parser/clause/with-named';
 import {convertCreateTable} from '#parser/clause/create-table';
+import {convertCreateIndex} from '#parser/clause/create-index';
 import {convertCreateSequence} from '#parser/clause/create-sequence';
-import {convertUnionAll} from '#parser/clause/union';
+import {convertAlterTable} from '#parser/clause/alter-table';
+import {convertDropTable} from '#parser/clause/drop-table';
+import {convertDropIndex} from '#parser/clause/drop-index';
+import {convertPragma} from '#parser/clause/pragma';
+import {convertAttach} from '#parser/clause/attach';
+import {convertUnion} from '#parser/clause/union';
 import {findClause} from '#parser/clause/find';
+import {
+    convertBegin,
+    convertCommit,
+    convertRollback,
+    convertSavepoint,
+} from '#parser/clause/transaction';
+
+const {identifier, callExpression} = types;
 
 export const convertClause = (stmt) => {
     const {type} = stmt;
@@ -43,5 +58,16 @@ const clauseVisitors = {
     delete_stmt: convertDelete,
     create_table_stmt: convertCreateTable,
     create_sequence_stmt: convertCreateSequence,
-    compound_select_stmt: convertUnionAll,
+    alter_table_stmt: convertAlterTable,
+    start_transaction_stmt: convertBegin,
+    commit_transaction_stmt: convertCommit,
+    rollback_transaction_stmt: convertRollback,
+    savepoint_stmt: convertSavepoint,
+    compound_select_stmt: convertUnion,
+    drop_table_stmt: convertDropTable,
+    drop_index_stmt: convertDropIndex,
+    pragma_stmt: convertPragma,
+    attach_database_stmt: convertAttach,
+    create_index_stmt: convertCreateIndex,
+    vacuum_stmt: () => callExpression(identifier('vacuum'), []),
 };

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

@@ -2,45 +2,51 @@ import {types} from '@putout/babel';
 import {convertOperand} from '#parser/clause/operand';
 import {convertSet} from '#parser/clause/set';
 import {convertSelect} from '#parser/clause/select';
+import {convertReturning} from '#parser/clause/returning';
 import {findClause} from '#parser/clause/find';
 
 const {
     identifier,
     callExpression,
     arrayExpression,
-    stringLiteral,
-    tsAsExpression,
-    tsLiteralType,
 } = types;
 
 const convertExprToIdentifier = ({expr}) => identifier(expr.name);
 const convertColToIdentifier = ({name}) => identifier(name);
 
-const convertReturningItem = (item) => {
-    if (item.type === 'alias') {
-        const {name} = item.expr;
-        const aliasName = item.alias.name;
-        
-        return tsAsExpression(identifier(name), tsLiteralType(stringLiteral(aliasName)));
-    }
-    
-    return identifier(item.name);
+const OR_ACTION_MAP = {
+    REPLACE: 'orReplace',
+    IGNORE: 'orIgnore',
 };
 
-const convertReturning = (returningClause) => {
-    const args = returningClause.columns.items.map(convertReturningItem);
+const convertOrAction = ({actionKw}) => callExpression(identifier(OR_ACTION_MAP[actionKw.name]), []);
+
+const convertRowItems = (paren) => {
+    const args = [];
     
-    return callExpression(identifier('returning'), args);
+    for (const item of paren.expr.items)
+        args.push(convertOperand(item));
+    
+    return args;
 };
 
+const convertRow = (paren) => callExpression(identifier('row'), convertRowItems(paren));
+
 const convertSource = (vc) => {
     if (vc.type === 'select_stmt')
         return convertSelect(vc);
     
-    const vals = vc.values.items[0].expr.items;
-    const valArgs = vals.map(convertOperand);
+    const rows = vc.values.items;
+    
+    if (rows.length === 1)
+        return callExpression(identifier('values'), convertRowItems(rows[0]));
+    
+    const rowArgs = [];
+    
+    for (const row of rows)
+        rowArgs.push(convertRow(row));
     
-    return callExpression(identifier('values'), valArgs);
+    return callExpression(identifier('values'), rowArgs);
 };
 
 const convertUpsert = (upsertClause) => {
@@ -64,6 +70,7 @@ export const convertInsert = ({clauses}) => {
     const source = convertSource(vc);
     
     const args = [
+        ic.orAction && convertOrAction(ic.orAction),
         callExpression(identifier('into'), [
             identifier(ic.table.name),
             colArg,

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

@@ -1,5 +1,7 @@
 import {types} from '@putout/babel';
 import {convertCount, isCount} from '#parser/clause/count';
+import {convertCaseWhen} from '#parser/clause/case-when';
+import {convertClause} from '#parser/clause';
 
 const {
     identifier,
@@ -11,8 +13,35 @@ const {
     callExpression,
 } = types;
 
+export const convertMemberExpr = (node) => {
+    const object = identifier(node.object.name);
+    
+    if (node.property.type === 'all_columns')
+        return memberExpression(object, stringLiteral('*'), true);
+    
+    return memberExpression(object, identifier(node.property.name));
+};
+
 const isFuncCall = ({type}) => type === 'func_call';
 
+const convertQuantifier = (node) => {
+    const {name} = node.quantifierKw;
+    const inner = node.expr.expr;
+    
+    if (inner.type === 'select_stmt')
+        return callExpression(identifier(name), [
+            convertClause(inner),
+        ]);
+    
+    const items = inner.items || [inner];
+    const args = [];
+    
+    for (const item of items)
+        args.push(convertOperand(item));
+    
+    return callExpression(identifier(name), args);
+};
+
 export const convertOperand = (node) => {
     if (isCount(node))
         return convertCount(node);
@@ -24,8 +53,29 @@ export const convertOperand = (node) => {
         return callExpression(identifier(lower), items.map(convertOperand));
     }
     
+    if (node.type === 'case_expr')
+        return convertCaseWhen(node);
+    
     if (node.type === 'member_expr')
-        return memberExpression(identifier(node.object.name), identifier(node.property.name));
+        return convertMemberExpr(node);
+    
+    if (node.type === 'array_literal_expr') {
+        const args = [];
+        
+        for (const item of node.expr.expr.items)
+            args.push(convertOperand(item));
+        
+        return callExpression(identifier('array'), args);
+    }
+    
+    if (node.type === 'quantifier_expr')
+        return convertQuantifier(node);
+    
+    if (node.type === 'cast_operator_expr')
+        return callExpression(identifier('pgCast'), [
+            convertOperand(node.left),
+            identifier(node.right.name),
+        ]);
     
     if (node.type === 'parameter')
         return stringLiteral(node.text);

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

@@ -0,0 +1,12 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+export const convertPragma = ({pragma}) => {
+    const arg = pragma.args.expr;
+    
+    return callExpression(identifier('pragma'), [
+        identifier(pragma.name.name),
+        identifier(arg.name.toLowerCase()),
+    ]);
+};

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

@@ -0,0 +1,32 @@
+import {types} from '@putout/babel';
+
+const {
+    identifier,
+    callExpression,
+    stringLiteral,
+    tsAsExpression,
+    tsLiteralType,
+} = types;
+
+const convertReturningItem = (item) => {
+    if (item.type === 'all_columns')
+        return stringLiteral('*');
+    
+    if (item.type === 'alias') {
+        const {name} = item.expr;
+        const aliasName = item.alias.name;
+        
+        return tsAsExpression(identifier(name), tsLiteralType(stringLiteral(aliasName)));
+    }
+    
+    return identifier(item.name);
+};
+
+export const convertReturning = (returningClause) => {
+    const args = [];
+    
+    for (const item of returningClause.columns.items)
+        args.push(convertReturningItem(item));
+    
+    return callExpression(identifier('returning'), args);
+};

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

@@ -1,8 +1,16 @@
 import {types} from '@putout/babel';
-import {convertOperand} from '#parser/clause/operand';
+import {
+    convertOperand,
+    convertMemberExpr,
+} from '#parser/clause/operand';
 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 {findClause} from '#parser/clause/find';
+import {convertOrderBy} from '../from/order-by.js';
+
+const isString = (a) => typeof a === 'string';
 
 const {
     identifier,
@@ -10,11 +18,36 @@ const {
     tsAsExpression,
     tsLiteralType,
     callExpression,
-    memberExpression,
     numericLiteral,
-    binaryExpression,
+    booleanLiteral,
+    nullLiteral,
 } = types;
 
+const getTypeName = ({name}) => {
+    if (isString(name))
+        return name;
+    
+    return name.name;
+};
+
+const convertCast = (column) => {
+    const {expr, dataType} = column.args.expr;
+    
+    return callExpression(identifier('cast'), [
+        convertOperand(expr),
+        identifier(getTypeName(dataType)),
+    ]);
+};
+
+const convertExtract = (column) => {
+    const {unit, expr} = column.args.expr;
+    
+    return callExpression(identifier('extract'), [
+        identifier(unit.unitKw.name),
+        convertOperand(expr),
+    ]);
+};
+
 const convertColumn = (column) => {
     if (isCount(column))
         return convertCount(column);
@@ -22,6 +55,15 @@ const convertColumn = (column) => {
     if (column.type === 'func_call')
         return convertFuncCall(column);
     
+    if (column.type === 'cast_expr')
+        return convertCast(column);
+    
+    if (column.type === 'extract_expr')
+        return convertExtract(column);
+    
+    if (column.type === 'case_expr')
+        return convertCaseWhen(column);
+    
     if (column.type === 'alias')
         return tsAsExpression(convertOperand(column.expr), tsLiteralType(stringLiteral(column.alias.name)));
     
@@ -29,7 +71,7 @@ const convertColumn = (column) => {
         return stringLiteral(column.value);
     
     if (column.type === 'member_expr')
-        return memberExpression(identifier(column.object.name), identifier(column.property.name));
+        return convertMemberExpr(column);
     
     if (column.type === 'parameter')
         return stringLiteral(column.text);
@@ -37,41 +79,73 @@ const convertColumn = (column) => {
     if (column.type === 'number_literal')
         return numericLiteral(column.value);
     
+    if (column.type === 'null_literal')
+        return nullLiteral();
+    
+    if (column.type === 'boolean_literal')
+        return booleanLiteral(column.value);
+    
     if (column.type === 'binary_expr')
-        return binaryExpression(
-            column.operator,
-            convertOperand(column.left),
-            convertOperand(column.right),
-        );
+        return convertBinary(column);
+    
+    if (column.type === 'array_literal_expr')
+        return convertOperand(column);
     
     return identifier(column.name);
 };
 
-const AGGREGATE_NAMES = new Set([
+const convertOverClause = (over) => {
+    const result = [];
+    const {partitionBy, orderBy} = over.window.expr;
+    
+    if (partitionBy)
+        result.push(callExpression(identifier('partitionBy'), partitionBy.specifications.items.map(convertOperand)));
+    
+    if (orderBy)
+        result.push(convertOrderBy(orderBy));
+    
+    return result;
+};
+
+const convertOver = (column, fnNode) => callExpression(identifier('over'), [
+    fnNode,
+    ...convertOverClause(column.over),
+]);
+
+const LOWERCASE_FUNCS = new Set([
     'sum',
     'avg',
     'min',
     'max',
+    'count',
+    'last_insert_rowid',
+    'lastval',
 ]);
 
 const convertFuncCall = (column) => {
     const {name} = column.name;
     const lower = name.toLowerCase();
     
-    if (name === 'last_insert_rowid')
+    if (lower === 'last_insert_rowid')
         return callExpression(identifier('lastInsertRowid'), []);
     
-    if (name === 'lastval')
+    if (lower === 'lastval')
         return callExpression(identifier('lastval'), []);
     
-    if (AGGREGATE_NAMES.has(lower)) {
-        const {items} = column.args.expr.args;
-        const args = items.map(convertOperand);
-        
+    const {items} = column.args.expr.args;
+    const args = [];
+    
+    for (const item of items)
+        args.push(convertOperand(item));
+    
+    if (column.over)
+        return convertOver(column, callExpression(identifier(LOWERCASE_FUNCS.has(lower) ? lower : name), args));
+    
+    if (LOWERCASE_FUNCS.has(lower))
         return callExpression(identifier(lower), args);
-    }
     
-    return callExpression(identifier(name), []);
+    // preserve original casing (RANK, LAG, LEAD, UPPER, etc.)
+    return callExpression(identifier(name), args);
 };
 
 const convertColumns = (columns) => {

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

@@ -0,0 +1,20 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+export const convertBegin = () => callExpression(identifier('begin'), []);
+
+export const convertCommit = () => callExpression(identifier('commit'), []);
+
+export const convertRollback = (stmt) => {
+    if (stmt.savepoint)
+        return callExpression(identifier('rollbackTo'), [
+            identifier(stmt.savepoint.savepoint.name),
+        ]);
+    
+    return callExpression(identifier('rollback'), []);
+};
+
+export const convertSavepoint = (stmt) => callExpression(identifier('savepoint'), [
+    identifier(stmt.savepoint.name),
+]);