happy-sql 2.0.8 → 2.1.1

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

@@ -11,6 +11,8 @@ const {
     tsLiteralType,
     callExpression,
     memberExpression,
+    numericLiteral,
+    binaryExpression,
 } = types;
 
 const convertColumn = (column) => {
@@ -32,16 +34,44 @@ const convertColumn = (column) => {
     if (column.type === 'parameter')
         return stringLiteral(column.text);
     
+    if (column.type === 'number_literal')
+        return numericLiteral(column.value);
+    
+    if (column.type === 'binary_expr')
+        return binaryExpression(
+            column.operator,
+            convertOperand(column.left),
+            convertOperand(column.right),
+        );
+    
     return identifier(column.name);
 };
 
+const AGGREGATE_NAMES = new Set([
+    'sum',
+    'avg',
+    'min',
+    'max',
+]);
+
 const convertFuncCall = (column) => {
     const {name} = column.name;
+    const lower = name.toLowerCase();
     
     if (name === 'last_insert_rowid')
         return callExpression(identifier('lastInsertRowid'), []);
     
-    return callExpression(identifier('lastval'), []);
+    if (name === 'lastval')
+        return callExpression(identifier('lastval'), []);
+    
+    if (AGGREGATE_NAMES.has(lower)) {
+        const {items} = column.args.expr.args;
+        const args = items.map(convertOperand);
+        
+        return callExpression(identifier(lower), args);
+    }
+    
+    return callExpression(identifier(name), []);
 };
 
 const convertColumns = (columns) => {
@@ -53,16 +83,31 @@ const convertColumns = (columns) => {
     return columns.items.map(convertColumn);
 };
 
+const isDistinct = (selectClause) => selectClause.modifiers.some(({type}) => type === 'select_distinct');
+
 export const convertSelect = ({clauses}) => {
     const selectClause = findClause(clauses, 'select_clause');
     const fromClause = findClause(clauses, 'from_clause');
     const whereClause = findClause(clauses, 'where_clause');
+    const groupByClause = findClause(clauses, 'group_by_clause');
+    const havingClause = findClause(clauses, 'having_clause');
+    const orderByClause = findClause(clauses, 'order_by_clause');
+    const limitClause = findClause(clauses, 'limit_clause');
+    
+    const cols = convertColumns(selectClause.columns);
+    const selectArgs = isDistinct(selectClause) ? [
+        callExpression(identifier('distinct'), cols),
+    ] : cols;
     
     const args = [
-        ...convertColumns(selectClause.columns),
+        ...selectArgs,
         fromClause && convertFrom({
             expr: fromClause.expr,
             whereClause,
+            groupByClause,
+            havingClause,
+            orderByClause,
+            limitClause,
         }),
     ].filter(Boolean);
     

package/lib/parser/visitors/clause/union/fixture/union-all-fix.js

@@ -0,0 +1,10 @@
+[
+    unionAll(
+        select(
+            1,
+        ),
+        select(
+            2,
+        ),
+    ),
+];

package/lib/parser/visitors/clause/union/fixture/union-all.sql

@@ -0,0 +1 @@
+SELECT 1 UNION ALL SELECT 2

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

@@ -0,0 +1,11 @@
+import {types} from '@putout/babel';
+import {convertClause} from '#parser/clause';
+
+const {callExpression, identifier} = types;
+
+export const convertUnionAll = (stmt) => {
+    return callExpression(identifier('unionAll'), [
+        convertClause(stmt.left),
+        convertClause(stmt.right),
+    ]);
+};

package/lib/parser/visitors/clause/update/fixture/update-where-not-in-fix.js

@@ -0,0 +1,16 @@
+[
+    update(
+        t,
+        set(
+            x === 1,
+        ),
+        where(
+            notInList(
+                y,
+                1,
+                2,
+                3,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/update/fixture/update-where-not-in.sql

@@ -0,0 +1 @@
+UPDATE t SET x = 1 WHERE y NOT IN (1, 2, 3)

package/lib/parser/visitors/clause/where/fixture/where-between-fix.js

@@ -0,0 +1,15 @@
+[
+    select(
+        '*',
+        from(
+            users,
+            where(
+                between(
+                    age,
+                    18,
+                    65,
+                ),
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/where/fixture/where-between.sql

@@ -0,0 +1 @@
+SELECT * FROM users WHERE age BETWEEN 18 AND 65

package/lib/parser/visitors/clause/where/fixture/where-not-in-fix.js

@@ -0,0 +1,16 @@
+[
+    select(
+        '*',
+        from(
+            users,
+            where(
+                notInList(
+                    id,
+                    1,
+                    2,
+                    3,
+                ),
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/where/fixture/where-not-in.sql

@@ -0,0 +1 @@
+SELECT * FROM users WHERE id NOT IN (1, 2, 3)

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

@@ -34,6 +34,12 @@ 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 convertBinary = (node) => {
     const op = opName(node.operator);
     
@@ -62,6 +68,15 @@ const convertBinary = (node) => {
         ]);
     }
     
+    if (op === 'NOT IN') {
+        const items = node.right.expr.items.map(convertOperand);
+        
+        return callExpression(identifier('notInList'), [
+            convertOperand(node.left),
+            ...items,
+        ]);
+    }
+    
     const jsOp = SQL_TO_JS_OP[op] ?? '===';
     
     return binaryExpression(
@@ -71,13 +86,16 @@ const convertBinary = (node) => {
     );
 };
 
-const convertCondition = (node) => {
+export const convertCondition = (node) => {
     if (node.operator?.name === 'AND')
         return convertAnd(node);
     
     if (node.operator?.name === 'OR')
         return convertOr(node);
     
+    if (node.type === 'between_expr')
+        return convertBetween(node);
+    
     return convertBinary(node);
 };
 

package/lib/parser/visitors/clause/with-named/fixture/with-named-select-fix.js

@@ -0,0 +1,19 @@
+[
+    withNamed(
+        recent = select(
+            id,
+            from(
+                users,
+                where(
+                    kind === 'const',
+                ),
+            ),
+        ),
+        select(
+            id,
+            from(
+                recent,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/with-named/fixture/with-named-select.sql

@@ -0,0 +1 @@
+WITH recent AS (SELECT id FROM users WHERE kind = 'const') SELECT id FROM recent

package/lib/parser/visitors/clause/with-named/fixture/with-recursive-fix.js

@@ -0,0 +1,27 @@
+[
+    withRecursive(
+        numbers(
+            'value',
+            unionAll(
+                select(
+                    1,
+                ),
+                select(
+                    value + 1,
+                    from(
+                        numbers,
+                        where(
+                            value < 10,
+                        ),
+                    ),
+                ),
+            ),
+        ),
+        select(
+            value,
+            from(
+                numbers,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/with-named/fixture/with-recursive-multi-fix.js

@@ -0,0 +1,38 @@
+[
+    withRecursive(
+        t(
+            unionAll(
+                select(
+                    1,
+                ),
+                select(
+                    2,
+                ),
+            ),
+        ),
+        u(
+            'a',
+            'b',
+            unionAll(
+                select(
+                    1,
+                    2,
+                ),
+                select(
+                    a,
+                    b,
+                    from(
+                        t,
+                    ),
+                ),
+            ),
+        ),
+        select(
+            a,
+            b,
+            from(
+                u,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/with-named/fixture/with-recursive-multi.sql

@@ -0,0 +1 @@
+WITH RECURSIVE t AS (SELECT 1 UNION ALL SELECT 2), u(a, b) AS (SELECT 1, 2 UNION ALL SELECT a, b FROM t) SELECT a, b FROM u

package/lib/parser/visitors/clause/with-named/fixture/with-recursive-no-columns-fix.js

@@ -0,0 +1,20 @@
+[
+    withRecursive(
+        t(
+            unionAll(
+                select(
+                    1,
+                ),
+                select(
+                    2,
+                ),
+            ),
+        ),
+        select(
+            '*',
+            from(
+                t,
+            ),
+        ),
+    ),
+];

package/lib/parser/visitors/clause/with-named/fixture/with-recursive-no-columns.sql

@@ -0,0 +1 @@
+WITH RECURSIVE t AS (SELECT 1 UNION ALL SELECT 2) SELECT * FROM t

package/lib/parser/visitors/clause/with-named/fixture/with-recursive.sql

@@ -0,0 +1 @@
+WITH RECURSIVE numbers(value) AS (SELECT 1 UNION ALL SELECT value + 1 FROM numbers WHERE value < 10) SELECT value FROM numbers

package/lib/parser/visitors/clause/with-named/with-named.js

@@ -6,6 +6,7 @@ const {
     identifier,
     assignmentExpression,
     callExpression,
+    stringLiteral,
 } = types;
 
 const isWithClause = (clause) => clause.type !== 'with_clause';
@@ -14,18 +15,30 @@ const convertTable = ({table, expr}) => {
     return assignmentExpression('=', identifier(table.name), convertClause(expr.expr));
 };
 
+// recursive CTE: numbers('value', unionAll(...))
+const convertRecursiveTable = ({table, columns, expr}) => {
+    const colArgs = columns ? columns.expr.items.map((column) => stringLiteral(column.name)) : [];
+    const body = convertClause(expr.expr);
+    
+    return callExpression(identifier(table.name), [...colArgs, body]);
+};
+
 export const convertWithNamed = (stmt) => {
     const withClause = findClause(stmt.clauses, 'with_clause');
+    const isRecursive = Boolean(withClause.recursiveKw);
+    const fnName = isRecursive ? 'withRecursive' : 'withNamed';
     
     const finalStatement = convertClause({
         ...stmt,
         clauses: stmt.clauses.filter(isWithClause),
     });
     
+    const convertCte = isRecursive ? convertRecursiveTable : convertTable;
+    
     const args = [
-        ...withClause.tables.items.map(convertTable),
+        ...withClause.tables.items.map(convertCte),
         finalStatement,
     ];
     
-    return callExpression(identifier('withNamed'), args);
+    return callExpression(identifier(fnName), args);
 };

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

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

package/lib/printer/visitors/call-expression/clauses/avg/fixture/avg-fix.sql

@@ -0,0 +1,2 @@
+SELECT AVG(score)
+FROM results

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

@@ -0,0 +1 @@
+select(avg(score), from(results));

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

@@ -0,0 +1,9 @@
+export const between = (path, {write, traverse}) => {
+    const [col, lo, hi] = path.get('arguments');
+    
+    traverse(col);
+    write(' BETWEEN ');
+    traverse(lo);
+    write(' AND ');
+    traverse(hi);
+};

package/lib/printer/visitors/call-expression/clauses/between/fixture/between-fix.sql

@@ -0,0 +1,3 @@
+SELECT *
+FROM users
+WHERE age BETWEEN 18 AND 65

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

@@ -0,0 +1,3 @@
+[
+    select('*', from(users, where(between(age, 18, 65)))),
+];

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

@@ -14,6 +14,20 @@ import {section} from './section/section.js';
 import {count} from './count/count.js';
 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 {groupBy} from './group-by/group-by.js';
+import {having} from './having/having.js';
+import {sum} from './sum/sum.js';
+import {avg} from './avg/avg.js';
+import {min} from './min/min.js';
+import {max} from './max/max.js';
+import {orderBy} from './order-by/order-by.js';
+import {desc} from './desc/desc.js';
+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 {createTable} from './create-table/create-table.js';
 import {createSequence} from './create-sequence/create-sequence.js';
 import {column} from './column/column.js';
@@ -48,6 +62,20 @@ export const clauses = {
     section,
     returning,
     withNamed,
+    withRecursive,
+    unionAll,
+    groupBy,
+    having,
+    sum,
+    avg,
+    min,
+    max,
+    orderBy,
+    desc,
+    limit,
+    distinct,
+    notInList,
+    between,
     createTable,
     createSequence,
     column,

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

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

package/lib/printer/visitors/call-expression/clauses/desc/fixture/desc-fix.sql

@@ -0,0 +1,3 @@
+SELECT id
+FROM users
+ORDER BY id DESC

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

@@ -0,0 +1,13 @@
+[
+    select(
+        id,
+        from(
+            users,
+            orderBy(
+                desc(
+                    id,
+                ),
+            ),
+        ),
+    ),
+];

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

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

package/lib/printer/visitors/call-expression/clauses/distinct/fixture/distinct-fix.sql

@@ -0,0 +1,2 @@
+SELECT DISTINCT name
+FROM users

package/lib/printer/visitors/call-expression/clauses/distinct/fixture/distinct-multi-fix.sql

@@ -0,0 +1,2 @@
+SELECT DISTINCT name, age
+FROM users

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

@@ -0,0 +1,11 @@
+[
+    select(
+        distinct(
+            name,
+            age,
+        ),
+        from(
+            users,
+        ),
+    ),
+];

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

@@ -0,0 +1,10 @@
+[
+    select(
+        distinct(
+            name,
+        ),
+        from(
+            users,
+        ),
+    ),
+];

package/lib/printer/visitors/call-expression/clauses/from/fixture/generate-series-fix.sql

@@ -0,0 +1,2 @@
+SELECT *
+FROM generate_series(1, 10, 2)

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

@@ -0,0 +1,3 @@
+[
+    select('*', from(generateSeries(1, 10, 2))),
+];

package/lib/printer/visitors/call-expression/clauses/from/fixture/group-by-having-fix.sql

@@ -0,0 +1,5 @@
+SELECT kind, COUNT(*)
+FROM VariableDeclaration
+WHERE kind = 'const'
+GROUP BY kind
+HAVING COUNT(*) > 1

package/lib/printer/visitors/call-expression/clauses/from/fixture/group-by-having.js

@@ -0,0 +1,22 @@
+[
+    select(
+        kind,
+        count(
+            '*',
+        ),
+        from(
+            VariableDeclaration,
+            where(
+                kind === 'const',
+            ),
+            groupBy(
+                kind,
+            ),
+            having(
+                count(
+                    '*',
+                ) > 1,
+            ),
+        ),
+    ),
+];

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

@@ -1,24 +1,70 @@
 import {types} from '@putout/babel';
 
-const {isTSAsExpression} = types;
+const {
+    isTSAsExpression,
+    isCallExpression,
+} = types;
 
 const printAsExpression = (path, {write, traverse}) => {
     traverse(path.get('expression'));
     write(` AS ${path.node.typeAnnotation.literal.value}`);
 };
 
-const printArg = (path, ctx) => {
-    if (isTSAsExpression(path.node))
-        return printAsExpression(path, ctx);
+const CLAUSE_NAMES = [
+    'where',
+    'groupBy',
+    'having',
+    'orderBy',
+    'limit',
+];
+
+const TABLE_ARG_NAMES = [
+    ...CLAUSE_NAMES,
+    'join',
+    'on',
+];
+
+const isClause = ({node}) => node.type === 'CallExpression' && CLAUSE_NAMES.includes(node.callee?.name);
+
+const CAMEL_RE = /([A-Z])/g;
+const toSnake = (a) => a.replace(CAMEL_RE, (_, c) => `_${c.toLowerCase()}`);
+
+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');
     
-    ctx.traverse(path);
+    write(toSnake(name));
+    write('(');
+    
+    for (const [i, arg] of args.entries()) {
+        if (i > 0)
+            write(', ');
+        
+        traverse(arg);
+    }
+    
+    write(')');
+};
+
+const printArg = (path, printer) => {
+    const {node} = path;
+    const {traverse} = printer;
+    
+    if (isTSAsExpression(node))
+        return printAsExpression(path, printer);
+    
+    if (isTableFunc(node))
+        return printTableFunc(path, printer);
+    
+    traverse(path);
 };
 
 export const from = (path, {write, traverse}) => {
     const args = path.get('arguments');
-    const lastArg = args.at(-1);
-    const hasWhere = lastArg?.node?.callee?.name === 'where';
-    const tableArgs = hasWhere ? args.slice(0, -1) : args;
+    const tableArgs = args.filter((arg) => !isClause(arg));
+    const clauseArgs = args.filter(isClause);
     
     write('FROM ');
     printArg(tableArgs[0], {
@@ -32,8 +78,9 @@ export const from = (path, {write, traverse}) => {
             traverse,
         });
     
-    if (hasWhere) {
-        write.newline();
-        traverse(lastArg);
+    for (const clause of clauseArgs) {
+        write.breakline();
+        traverse(clause);
     }
 };
+

package/lib/printer/visitors/call-expression/clauses/group-by/fixture/group-by-fix.sql

@@ -0,0 +1,3 @@
+SELECT kind, COUNT(*)
+FROM VariableDeclaration
+GROUP BY kind