happy-sql 2.1.0 → 2.2.0

package/lib/parser/visitors/clause/from/fixture/subquery-fix.js

@@ -0,0 +1,15 @@
+[
+    select(
+        '*',
+        from(
+            subquery(
+                select(
+                    id,
+                    from(
+                        t,
+                    ),
+                ),
+            ) as 'sub',
+        ),
+    ),
+];

package/lib/parser/visitors/clause/from/fixture/subquery.sql

@@ -0,0 +1 @@
+SELECT * FROM (SELECT id FROM t) sub

package/lib/parser/visitors/clause/from/fixture/unnest-fix.js

@@ -0,0 +1,10 @@
+[
+    select(
+        '*',
+        from(
+            unnest(
+                arr,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/from/fixture/unnest.sql

@@ -0,0 +1 @@
+SELECT * FROM unnest(arr)

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

@@ -1,106 +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';
-
-const isString = (a) => typeof a === 'string';
+import {convertOrderBy} from './order-by.js';
+import {convertLimit} from './limit.js';
+import {convertTableFunc} from './table-func.js';
 
 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);
+    
+    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 (op === 'IN') {
-        const items = node.right.expr.items.map(convertOperand);
+    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)));
     }
     
-    const jsOp = SQL_TO_JS_OP[op] ?? '===';
+    if (isParenExpr(node.expr)) {
+        const inner = node.expr.expr;
+        const aliasName = node.alias.name;
+        
+        return tsAsExpression(callExpression(identifier('subquery'), [
+            convertClause(inner),
+        ]), tsLiteralType(stringLiteral(aliasName)));
+    }
     
-    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];
     
-    return convertBinary(node);
+    const parts = [];
+    
+    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;
     }
@@ -110,7 +163,7 @@ const flattenJoins = (node, joins = []) => {
     return joins;
 };
 
-export const convertFrom = ({expr, whereClause, groupByClause, havingClause}) => {
+export const convertFrom = ({expr, whereClause, groupByClause, havingClause, orderByClause, limitClause}) => {
     const fromArgs = [];
     
     if (whereClause)
@@ -124,6 +177,12 @@ export const convertFrom = ({expr, whereClause, groupByClause, havingClause}) =>
     if (havingClause)
         fromArgs.push(convertHaving(havingClause));
     
+    if (orderByClause)
+        fromArgs.push(convertOrderBy(orderByClause));
+    
+    if (limitClause)
+        fromArgs.push(convertLimit(limitClause));
+    
     if (expr.type === 'join_expr') {
         const parts = flattenJoins(expr);
         return callExpression(identifier('from'), parts);
@@ -135,6 +194,12 @@ export const convertFrom = ({expr, whereClause, groupByClause, havingClause}) =>
             ...fromArgs,
         ]);
     
+    if (expr.type === 'func_call')
+        return callExpression(identifier('from'), [
+            convertTableFunc(expr),
+            ...fromArgs,
+        ]);
+    
     return callExpression(identifier('from'), [
         identifier(expr.name),
         ...fromArgs,

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

@@ -0,0 +1,18 @@
+import {types} from '@putout/babel';
+
+const {
+    callExpression,
+    identifier,
+    numericLiteral,
+} = types;
+
+export const convertLimit = (limitClause) => {
+    const args = [
+        numericLiteral(limitClause.count.value),
+    ];
+    
+    if (limitClause.offset)
+        args.push(numericLiteral(limitClause.offset.value));
+    
+    return callExpression(identifier('limit'), args);
+};

package/lib/parser/visitors/clause/from/order-by.js

@@ -0,0 +1,20 @@
+import {types} from '@putout/babel';
+import {convertOperand} from '#parser/clause/operand';
+
+const {callExpression, identifier} = types;
+
+const convertOrderItem = (item) => {
+    if (item.type !== 'sort_specification')
+        return convertOperand(item);
+    
+    const col = convertOperand(item.expr);
+    const {direction} = item;
+    
+    if (direction.type === 'sort_direction_desc')
+        return callExpression(identifier('desc'), [col]);
+    
+    // ASC is default — no wrapper
+    return col;
+};
+
+export const convertOrderBy = (clause) => callExpression(identifier('orderBy'), clause.specifications.items.map(convertOrderItem));

package/lib/parser/visitors/clause/from/table-func.js

@@ -0,0 +1,28 @@
+import {types} from '@putout/babel';
+
+const {
+    callExpression,
+    identifier,
+    numericLiteral,
+    stringLiteral,
+} = types;
+
+const SNAKE_RE = /_([a-z])/g;
+const toCamel = (s) => s.replace(SNAKE_RE, (_, c) => c.toUpperCase());
+
+const convertArg = (arg) => {
+    if (arg.type === 'number_literal')
+        return numericLiteral(arg.value);
+    
+    if (arg.type === 'string_literal')
+        return stringLiteral(arg.value);
+    
+    return identifier(arg.name);
+};
+
+export const convertTableFunc = (expr) => {
+    const name = toCamel(expr.name.name);
+    const args = expr.args.expr.args.items.map(convertArg);
+    
+    return callExpression(identifier(name), args);
+};

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/fixture/insert-multi-row-fix.js

@@ -0,0 +1,19 @@
+[
+    insert(
+        into(
+            t,
+            id,
+            values(
+                row(
+                    1,
+                ),
+                row(
+                    2,
+                ),
+                row(
+                    3,
+                ),
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/insert/fixture/insert-multi-row.sql

@@ -0,0 +1 @@
+INSERT INTO t (id) VALUES (1), (2), (3)

package/lib/parser/visitors/clause/insert/fixture/insert-or-ignore-fix.js

@@ -0,0 +1,12 @@
+[
+    insert(
+        orIgnore(),
+        into(
+            t,
+            id,
+            values(
+                1,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/insert/fixture/insert-or-ignore.sql

@@ -0,0 +1 @@
+INSERT OR IGNORE INTO t (id) VALUES (1)

package/lib/parser/visitors/clause/insert/fixture/insert-or-replace-fix.js

@@ -0,0 +1,12 @@
+[
+    insert(
+        orReplace(),
+        into(
+            t,
+            id,
+            values(
+                1,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/insert/fixture/insert-or-replace.sql

@@ -0,0 +1 @@
+INSERT OR REPLACE INTO t (id) VALUES (1)

package/lib/parser/visitors/clause/insert/fixture/insert-returning-star-fix.js

@@ -0,0 +1,14 @@
+[
+    insert(
+        into(
+            t,
+            name,
+            values(
+                'test',
+            ),
+        ),
+        returning(
+            '*',
+        ),
+    ),
+];

package/lib/parser/visitors/clause/insert/fixture/insert-returning-star.sql

@@ -0,0 +1 @@
+INSERT INTO t (name) VALUES ('test') RETURNING *

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,
@@ -8,14 +10,72 @@ const {
     booleanLiteral,
     nullLiteral,
     memberExpression,
+    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);
     
+    if (isFuncCall(node)) {
+        const lower = node.name.name.toLowerCase();
+        const {items} = node.args.expr.args;
+        
+        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/fixture/pragma-table-info-fix.js

@@ -0,0 +1,6 @@
+[
+    pragma(
+        table_info,
+        users,
+    ),
+];

package/lib/parser/visitors/clause/pragma/fixture/pragma-table-info.sql

@@ -0,0 +1 @@
+PRAGMA table_info(users)

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()),
+    ]);
+};