happy-sql 2.3.0 → 2.4.1

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

@@ -1,12 +1,62 @@
 import {types} from '@putout/babel';
+import {convertMemberExpr} from '#parser/clause/operand';
 
-const {identifier, callExpression} = types;
+const {
+    identifier,
+    stringLiteral,
+    numericLiteral,
+    callExpression,
+    binaryExpression,
+} = types;
+
+const isPragmaFuncCall = ({type}) => type === 'pragma_func_call';
+const isPragmaAssignment = ({type}) => type === 'pragma_assignment';
+
+const convertName = (node) => {
+    if (node.type === 'member_expr')
+        return convertMemberExpr(node);
+    
+    return identifier(node.name);
+};
+
+const convertValue = (node) => {
+    if (node.type === 'keyword' || node.type === 'identifier')
+        return identifier(node.name);
+    
+    if (node.type === 'number_literal')
+        return numericLiteral(node.value);
+    
+    return stringLiteral(node.value);
+};
 
 export const convertPragma = ({pragma}) => {
+    if (isPragmaAssignment(pragma))
+        return convertAssignment(pragma);
+    
+    if (isPragmaFuncCall(pragma))
+        return convertFuncCall(pragma);
+    
+    return callExpression(identifier('pragma'), [
+        convertName(pragma),
+    ]);
+};
+
+const convertAssignment = ({name, value}) => callExpression(identifier('pragma'), [
+    binaryExpression('===', convertName(name), convertValue(value)),
+]);
+
+const convertFuncCall = (pragma) => {
     const arg = pragma.args.expr;
     
     return callExpression(identifier('pragma'), [
         identifier(pragma.name.name),
-        identifier(arg.name.toLowerCase()),
+        convertArg(arg),
     ]);
 };
+
+const convertArg = (arg) => {
+    if (arg.type === 'string_literal')
+        return stringLiteral(arg.value);
+    
+    return identifier(arg.name.toLowerCase());
+};

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

@@ -7,8 +7,18 @@ 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 {
+    convertCondition,
+    convertBetween,
+} from '#parser/clause/where';
 import {findClause} from '#parser/clause/find';
 import {convertOrderBy} from '../from/order-by.js';
+import {
+    convertLimit,
+    convertOffset,
+    convertFetch,
+    convertForUpdate,
+} from '../from/limit.js';
 
 const isString = (a) => typeof a === 'string';
 
@@ -48,16 +58,29 @@ const convertExtract = (column) => {
     ]);
 };
 
+const convertFilter = (column, fn) => {
+    if (!column.filter)
+        return fn;
+    
+    const {where} = column.filter;
+    const condition = convertCondition(where.expr.expr);
+    
+    return callExpression(identifier('filter'), [fn, condition]);
+};
+
 const convertColumn = (column) => {
     if (isCount(column))
-        return convertCount(column);
+        return convertOverIfPresent(column, convertFilter(column, convertCount(column)));
     
     if (column.type === 'func_call')
-        return convertFuncCall(column);
+        return convertFilter(column, convertFuncCall(column));
     
     if (column.type === 'cast_expr')
         return convertCast(column);
     
+    if (column.type === 'cast_operator_expr')
+        return convertOperand(column);
+    
     if (column.type === 'extract_expr')
         return convertExtract(column);
     
@@ -91,12 +114,65 @@ const convertColumn = (column) => {
     if (column.type === 'array_literal_expr')
         return convertOperand(column);
     
+    if (column.type === 'prefix_op_expr')
+        return convertOperand(column);
+    
+    if (column.type === 'postfix_op_expr')
+        return convertCondition(column);
+    
+    if (column.type === 'between_expr')
+        return convertBetween(column);
+    
+    // quoted identifier like "weird col" — keep original text
+    if (isString(column.text) && column.text.startsWith('"'))
+        return stringLiteral(column.text);
+    
     return identifier(column.name);
 };
 
+const convertOverIfPresent = (column, fn) => {
+    if (!column.over)
+        return fn;
+    
+    return convertOver(column, fn);
+};
+
+const isWindowRef = (over) => over.window.type === 'identifier';
+
+const convertFrameBound = (bound) => {
+    if (bound.type === 'frame_bound_current_row')
+        return callExpression(identifier('currentRow'), []);
+    
+    const name = bound.type === 'frame_bound_preceding' ? 'preceding' : 'following';
+    
+    const isUnbounded = bound.expr && bound.expr.type === 'frame_unbounded';
+    const args = !isUnbounded && bound.expr
+        ? [
+            numericLiteral(bound.expr.value),
+        ]
+        : [];
+    
+    return callExpression(identifier(name), args);
+};
+
+const convertFrame = ({extent}) => callExpression(identifier('rowsBetween'), [
+    convertFrameBound(extent.begin),
+    convertFrameBound(extent.end),
+]);
+
 const convertOverClause = (over) => {
+    if (isWindowRef(over))
+        return [
+            identifier(over.window.name),
+        ];
+    
     const result = [];
-    const {partitionBy, orderBy} = over.window.expr;
+    
+    const {
+        partitionBy,
+        orderBy,
+        frame,
+    } = over.window.expr;
     
     if (partitionBy)
         result.push(callExpression(identifier('partitionBy'), partitionBy.specifications.items.map(convertOperand)));
@@ -104,6 +180,9 @@ const convertOverClause = (over) => {
     if (orderBy)
         result.push(convertOrderBy(orderBy));
     
+    if (frame)
+        result.push(convertFrame(frame));
+    
     return result;
 };
 
@@ -138,8 +217,10 @@ const convertFuncCall = (column) => {
     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 (column.over) {
+        const funcName = LOWERCASE_FUNCS.has(lower) ? lower : name;
+        return convertOver(column, callExpression(identifier(funcName), args));
+    }
     
     if (LOWERCASE_FUNCS.has(lower))
         return callExpression(identifier(lower), args);
@@ -157,21 +238,62 @@ const convertColumns = (columns) => {
     return columns.items.map(convertColumn);
 };
 
-const isDistinct = (selectClause) => selectClause.modifiers.some(({type}) => type === 'select_distinct');
+const isSelectDistinct = ({type}) => type === 'select_distinct';
+const isSelectDistinctOn = ({type}) => type === 'select_distinct_on';
+
+const isDistinct = (selectClause) => selectClause.modifiers.some(isSelectDistinct);
+
+const convertDistinctOn = ({modifiers}) => {
+    if (!modifiers.some(isSelectDistinctOn))
+        return null;
+    
+    const modifier = modifiers.find(isSelectDistinctOn);
+    const onCols = [];
+    
+    for (const item of modifier.columns.expr.items) {
+        onCols.push(identifier(item.name));
+    }
+    
+    return callExpression(identifier('distinctOn'), onCols);
+};
+
+const convertValuesRow = (node) => {
+    const {items} = node.expr;
+    
+    return callExpression(identifier('row'), items.map(convertOperand));
+};
+
+const convertValuesClause = (clause) => callExpression(identifier('values'), clause.values.items.map(convertValuesRow));
 
 export const convertSelect = ({clauses}) => {
     const selectClause = findClause(clauses, 'select_clause');
+    const valuesClause = findClause(clauses, 'values_clause');
+    
+    if (!selectClause && valuesClause)
+        return convertValuesClause(valuesClause);
+    
     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 windowClause = findClause(clauses, 'window_clause');
     const limitClause = findClause(clauses, 'limit_clause');
+    const offsetClause = findClause(clauses, 'offset_clause');
+    const fetchClause = findClause(clauses, 'fetch_clause');
+    const forClause = findClause(clauses, 'for_clause');
     
     const cols = convertColumns(selectClause.columns);
-    const selectArgs = isDistinct(selectClause) ? [
-        callExpression(identifier('distinct'), cols),
-    ] : cols;
+    const distinctOn = convertDistinctOn(selectClause);
+    const selectArgs = [];
+    
+    if (distinctOn)
+        selectArgs.push(distinctOn);
+    
+    if (isDistinct(selectClause))
+        selectArgs.push(callExpression(identifier('distinct'), cols));
+    else
+        selectArgs.push(...cols);
     
     const args = [
         ...selectArgs,
@@ -181,9 +303,27 @@ export const convertSelect = ({clauses}) => {
             groupByClause,
             havingClause,
             orderByClause,
+            windowClause,
             limitClause,
+            offsetClause,
+            fetchClause,
+            forClause,
         }),
     ].filter(Boolean);
     
+    if (!fromClause) {
+        if (limitClause)
+            args.push(convertLimit(limitClause));
+        
+        if (offsetClause)
+            args.push(convertOffset(offsetClause));
+        
+        if (fetchClause)
+            args.push(convertFetch(fetchClause));
+        
+        if (forClause)
+            args.push(convertForUpdate());
+    }
+    
     return callExpression(identifier('select'), args);
 };

package/lib/parser/visitors/clause/set-param/set-param.js

@@ -0,0 +1,19 @@
+import {types} from '@putout/babel';
+import {convertOperand} from '#parser/clause/operand';
+
+const {identifier, callExpression} = types;
+
+export const convertSetParam = (stmt) => {
+    const args = [
+        identifier(stmt.name.name),
+    ];
+    
+    for (const item of stmt.value.items)
+        args.push(convertOperand(item));
+    
+    return callExpression(identifier('setParam'), args);
+};
+
+export const convertShowParam = (stmt) => callExpression(identifier('showParam'), [
+    identifier(stmt.name.name),
+]);

package/lib/parser/visitors/clause/table-constraint.js

@@ -0,0 +1,27 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+export const convertConstraintColumn = (item) => {
+    if (item.expr)
+        return identifier(item.expr.name);
+    
+    return identifier(item.name);
+};
+
+const convertConstraintColumns = ({columns}) => columns.expr.items.map(convertConstraintColumn);
+
+export const TABLE_CONSTRAINTS = {
+    constraint_primary_key: (item) => callExpression(identifier('tablePrimaryKey'), convertConstraintColumns(item)),
+    constraint_unique: (item) => callExpression(identifier('tableUnique'), convertConstraintColumns(item)),
+};
+
+export const convertTableConstraint = (item) => {
+    if (item.type === 'constraint')
+        return callExpression(identifier('constraint'), [
+            identifier(item.name.name.name),
+            convertTableConstraint(item.constraint),
+        ]);
+    
+    return TABLE_CONSTRAINTS[item.type](item);
+};

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

@@ -10,6 +10,20 @@ const {
     callExpression,
 } = types;
 
+const OR_ACTION_MAP = {
+    REPLACE: () => callExpression(identifier('orReplace'), []),
+    IGNORE: () => callExpression(identifier('orIgnore'), []),
+    ABORT: () => callExpression(identifier('orAbort'), []),
+    FAIL: () => callExpression(identifier('orFail'), []),
+};
+
+const convertOrAction = (orAction) => {
+    if (!orAction)
+        return null;
+    
+    return OR_ACTION_MAP[orAction.actionKw.name]();
+};
+
 export const convertUpdate = ({clauses}) => {
     const updateClause = findClause(clauses, 'update_clause');
     const setClause = findClause(clauses, 'set_clause');
@@ -26,7 +40,10 @@ export const convertUpdate = ({clauses}) => {
     
     const setCall = callExpression(identifier('set'), setArgs);
     
+    const orAction = convertOrAction(updateClause.orAction);
+    
     const args = [
+        orAction,
         table,
         setCall,
         fromClause && convertFromClause(fromClause),

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

@@ -31,6 +31,20 @@ const isExists = (node) => node.type === 'prefix_op_expr' && node.operator.name
 const isNotExists = (node) => node.type === 'prefix_op_expr' && node.operator.name === 'NOT' && isExists(node.expr);
 const isParenExpr = (node) => node.type === 'paren_expr';
 
+const POSTFIX_OP = {
+    ISNULL: 'isNull',
+    NOTNULL: 'isNotNull',
+};
+
+const convertPostfix = (node) => {
+    const {name} = node.operator;
+    const fn = POSTFIX_OP[name];
+    
+    return callExpression(identifier(fn), [
+        convertOperand(node.expr),
+    ]);
+};
+
 export const convertCondition = (node) => {
     if (node.operator && node.operator.name === 'AND')
         return convertAnd(node);
@@ -41,6 +55,9 @@ export const convertCondition = (node) => {
     if (node.type === 'between_expr')
         return convertBetween(node);
     
+    if (node.type === 'postfix_op_expr')
+        return convertPostfix(node);
+    
     if (isNotExists(node))
         return callExpression(identifier('notExists'), [
             convertClause(node.expr.expr.expr),

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

@@ -15,9 +15,23 @@ const convertTable = ({table, expr}) => {
     return assignmentExpression('=', identifier(table.name), convertClause(expr.expr));
 };
 
+const convertColumn = (column) => stringLiteral(column.name);
+
+const getColArgs = (columns) => {
+    if (!columns)
+        return [];
+    
+    const args = [];
+    
+    for (const col of columns.expr.items)
+        args.push(convertColumn(col));
+    
+    return args;
+};
+
 // recursive CTE: numbers('value', unionAll(...))
 const convertRecursiveTable = ({table, columns, expr}) => {
-    const colArgs = columns ? columns.expr.items.map((column) => stringLiteral(column.name)) : [];
+    const colArgs = getColArgs(columns);
     const body = convertClause(expr.expr);
     
     return callExpression(identifier(table.name), [...colArgs, body]);

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

@@ -0,0 +1,4 @@
+export const accessMethod = (path, {write, traverse}) => {
+    write('USING ');
+    traverse(path.get('arguments.0'));
+};

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

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

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

@@ -0,0 +1,10 @@
+export const analyze = (path, {write, traverse}) => {
+    const args = path.get('arguments');
+    
+    write('ANALYZE');
+    
+    if (args.length) {
+        write.space();
+        traverse(args[0]);
+    }
+};

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

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