happy-sql 2.3.0 → 2.4.1

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

@@ -2,11 +2,20 @@ import {types} from '@putout/babel';
 import {convertBetween} from '#parser/clause/where';
 import {convertClause} from '#parser/clause';
 import {convertBinary} from '#parser/clause/binary';
+import {
+    convertOperand,
+    convertMemberExpr,
+} from '#parser/clause/operand';
 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';
+import {
+    convertLimit,
+    convertOffset,
+    convertFetch,
+    convertForUpdate,
+} from './limit.js';
 
 const {
     identifier,
@@ -21,6 +30,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),
+    ]);
+};
+
 const convertCondition = (node) => {
     if (node.operator && node.operator.name === 'AND')
         return logicalExpression('&&', convertCondition(node.left), convertCondition(node.right));
@@ -31,6 +54,9 @@ 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),
@@ -51,7 +77,30 @@ const convertOn = (spec) => callExpression(identifier('on'), [
     convertCondition(spec.expr),
 ]);
 
+const isJoinUsing = ({type}) => type === 'join_using_specification';
+
+const convertSpecification = (spec) => {
+    if (isJoinUsing(spec))
+        return callExpression(identifier('using'), spec.expr.expr.items.map(({name}) => identifier(name)));
+    
+    return convertOn(spec);
+};
+
+const isIndexedTable = ({type}) => type === 'indexed_table';
+const isNotIndexedTable = ({type}) => type === 'not_indexed_table';
+
 const convertAlias = (node) => {
+    if (isIndexedTable(node))
+        return callExpression(identifier('indexedBy'), [
+            identifier(node.table.name),
+            identifier(node.index.name),
+        ]);
+    
+    if (isNotIndexedTable(node))
+        return callExpression(identifier('notIndexed'), [
+            identifier(node.table.name),
+        ]);
+    
     if (node.type !== 'alias')
         return identifier(node.name);
     
@@ -75,6 +124,9 @@ const convertAlias = (node) => {
         ]), tsLiteralType(stringLiteral(aliasName)));
     }
     
+    if (node.expr.type === 'func_call')
+        return tsAsExpression(convertTableFunc(node.expr), tsLiteralType(stringLiteral(node.alias.name)));
+    
     return tsAsExpression(identifier(node.expr.name), tsLiteralType(stringLiteral(node.alias.name)));
 };
 
@@ -93,6 +145,11 @@ const joinTypeParts = (operator) => {
     return parts;
 };
 
+const capitalizeWord = (s) => s[0].toUpperCase() +
+    s
+        .slice(1)
+        .toLowerCase();
+
 const convertJoinType = (operator) => {
     const parts = joinTypeParts(operator);
     
@@ -103,14 +160,12 @@ const convertJoinType = (operator) => {
         return 'join';
     
     // 'LEFT OUTER' → 'leftOuter' → 'leftOuterJoin'
-    const camel = parts[0].toLowerCase() +
-        parts
-            .slice(1)
-            .map((s) => s[0].toUpperCase() +
-            s
-                .slice(1)
-                .toLowerCase())
-            .join('');
+    const tail = [];
+    
+    for (const part of parts.slice(1))
+        tail.push(capitalizeWord(part));
+    
+    const camel = parts[0].toLowerCase() + tail.join('');
     
     return `${camel}Join`;
 };
@@ -152,7 +207,7 @@ const flattenJoins = (node, joins = []) => {
         else
             joins.push(callExpression(identifier(fnName), [
                 convertAlias(node.right),
-                convertOn(node.specification),
+                convertSpecification(node.specification),
             ]));
         
         return joins;
@@ -163,7 +218,26 @@ const flattenJoins = (node, joins = []) => {
     return joins;
 };
 
-export const convertFrom = ({expr, whereClause, groupByClause, havingClause, orderByClause, limitClause}) => {
+const convertWindow = (node) => {
+    const {name} = node;
+    const {expr} = node.window;
+    
+    const args = [
+        identifier(name.name),
+    ];
+    
+    const {partitionBy, orderBy} = expr;
+    
+    if (partitionBy)
+        args.push(callExpression(identifier('partitionBy'), partitionBy.specifications.items.map(convertOperand)));
+    
+    if (orderBy)
+        args.push(convertOrderBy(orderBy));
+    
+    return callExpression(identifier('namedWindow'), args);
+};
+
+export const convertFrom = ({expr, whereClause, groupByClause, havingClause, orderByClause, windowClause, limitClause, offsetClause, fetchClause, forClause}) => {
     const fromArgs = [];
     
     if (whereClause)
@@ -177,15 +251,31 @@ export const convertFrom = ({expr, whereClause, groupByClause, havingClause, ord
     if (havingClause)
         fromArgs.push(convertHaving(havingClause));
     
+    if (windowClause)
+        fromArgs.push(...windowClause.namedWindows.items.map(convertWindow));
+    
     if (orderByClause)
         fromArgs.push(convertOrderBy(orderByClause));
     
     if (limitClause)
         fromArgs.push(convertLimit(limitClause));
     
+    if (offsetClause)
+        fromArgs.push(convertOffset(offsetClause));
+    
+    if (fetchClause)
+        fromArgs.push(convertFetch(fetchClause));
+    
+    if (forClause)
+        fromArgs.push(convertForUpdate());
+    
     if (expr.type === 'join_expr') {
         const parts = flattenJoins(expr);
-        return callExpression(identifier('from'), parts);
+        
+        return callExpression(identifier('from'), [
+            ...parts,
+            ...fromArgs,
+        ]);
     }
     
     if (expr.type === 'alias')
@@ -200,8 +290,14 @@ export const convertFrom = ({expr, whereClause, groupByClause, havingClause, ord
             ...fromArgs,
         ]);
     
+    if (expr.type === 'member_expr')
+        return callExpression(identifier('from'), [
+            convertMemberExpr(expr),
+            ...fromArgs,
+        ]);
+    
     return callExpression(identifier('from'), [
-        identifier(expr.name),
+        convertAlias(expr),
         ...fromArgs,
     ]);
 };

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

@@ -3,4 +3,11 @@ import {convertOperand} from '#parser/clause/operand';
 
 const {callExpression, identifier} = types;
 
-export const convertGroupBy = (clause) => callExpression(identifier('groupBy'), clause.columns.items.map(convertOperand));
+export const convertGroupBy = (clause) => {
+    const args = [];
+    
+    for (const item of clause.columns.items)
+        args.push(convertOperand(item));
+    
+    return callExpression(identifier('groupBy'), args);
+};

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

@@ -7,6 +7,9 @@ const {
 } = types;
 
 export const convertLimit = (limitClause) => {
+    if (limitClause.count && limitClause.count.type === 'limit_all')
+        return callExpression(identifier('limitAll'), []);
+    
     const args = [
         numericLiteral(limitClause.count.value),
     ];
@@ -16,3 +19,13 @@ export const convertLimit = (limitClause) => {
     
     return callExpression(identifier('limit'), args);
 };
+
+export const convertOffset = (offsetClause) => callExpression(identifier('offset'), [
+    numericLiteral(offsetClause.offset.value),
+]);
+
+export const convertFetch = (fetchClause) => callExpression(identifier('fetchFirst'), [
+    numericLiteral(fetchClause.count.value),
+]);
+
+export const convertForUpdate = () => callExpression(identifier('forUpdate'), []);

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

@@ -3,15 +3,27 @@ import {convertOperand} from '#parser/clause/operand';
 
 const {callExpression, identifier} = types;
 
+const isDesc = ({type}) => type === 'sort_direction_desc';
+
+const convertNullsOrder = (col, nullHandlingKw) => {
+    const isLast = nullHandlingKw.at(-1).name === 'LAST';
+    const fnName = isLast ? 'nullsLast' : 'nullsFirst';
+    
+    return callExpression(identifier(fnName), [col]);
+};
+
 const convertOrderItem = (item) => {
     if (item.type !== 'sort_specification')
         return convertOperand(item);
     
-    const col = convertOperand(item.expr);
+    let col = convertOperand(item.expr);
     const {direction} = item;
     
-    if (direction.type === 'sort_direction_desc')
-        return callExpression(identifier('desc'), [col]);
+    if (direction && isDesc(direction))
+        col = callExpression(identifier('desc'), [col]);
+    
+    if (item.nullHandlingKw)
+        return convertNullsOrder(col, item.nullHandlingKw);
     
     // ASC is default — no wrapper
     return col;

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

@@ -1,28 +1,24 @@
 import {types} from '@putout/babel';
+import {convertOperand} from '#parser/clause/operand';
 
-const {
-    callExpression,
-    identifier,
-    numericLiteral,
-    stringLiteral,
-} = types;
+const {callExpression, identifier} = 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);
+const getRawName = (expr) => {
+    const raw = expr.name.name;
     
-    if (arg.type === 'string_literal')
-        return stringLiteral(arg.value);
+    if (raw.includes('_'))
+        return raw.toLowerCase();
     
-    return identifier(arg.name);
+    return raw;
 };
 
 export const convertTableFunc = (expr) => {
-    const name = toCamel(expr.name.name);
-    const args = expr.args.expr.args.items.map(convertArg);
+    // multi-word snake_case names are lowercased first (GENERATE_SERIES → generateSeries)
+    const name = toCamel(getRawName(expr));
+    const args = expr.args.expr.args.items.map(convertOperand);
     
     return callExpression(identifier(name), args);
 };

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

@@ -0,0 +1,26 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+export const convertGrant = (stmt) => {
+    const privArgs = [];
+    
+    for (const p of stmt.privileges.items)
+        privArgs.push(identifier(p.privilegeKw.name));
+    
+    const tableArgs = [];
+    
+    for (const t of stmt.resource.tables.items)
+        tableArgs.push(identifier(t.name));
+    
+    const roleArgs = [];
+    
+    for (const r of stmt.roles.items)
+        roleArgs.push(identifier(r.name));
+    
+    return callExpression(identifier('grant'), [
+        callExpression(identifier('privilege'), privArgs),
+        callExpression(identifier('grantOn'), tableArgs),
+        callExpression(identifier('to'), roleArgs),
+    ]);
+};

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

@@ -12,8 +12,19 @@ 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 {convertExplain} from '#parser/clause/explain';
+import {
+    convertSetParam,
+    convertShowParam,
+} from '#parser/clause/set-param';
+import {convertCreateView} from '#parser/clause/create-view';
+import {convertDropView} from '#parser/clause/drop-view';
+import {convertCreateExtension} from '#parser/clause/create-extension';
+import {convertCreateSchema} from '#parser/clause/create-schema';
+import {convertGrant} from '#parser/clause/grant';
 import {convertUnion} from '#parser/clause/union';
 import {findClause} from '#parser/clause/find';
+import {convertMemberExpr} from '#parser/clause/operand';
 import {
     convertBegin,
     convertCommit,
@@ -21,7 +32,20 @@ import {
     convertSavepoint,
 } from '#parser/clause/transaction';
 
-const {identifier, callExpression} = types;
+const {
+    identifier,
+    callExpression,
+    stringLiteral,
+} = types;
+
+const isMemberExpr = ({type}) => type === 'member_expr';
+
+const convertTableName = (table) => {
+    if (isMemberExpr(table))
+        return convertMemberExpr(table);
+    
+    return identifier(table.name);
+};
 
 export const convertClause = (stmt) => {
     const {type} = stmt;
@@ -51,6 +75,8 @@ const convertSelectOrNamed = (stmt) => {
     return convertSelect(stmt);
 };
 
+const getAnalyzeTables = ({tables}) => tables.items || tables;
+
 const clauseVisitors = {
     select_stmt: convertSelectOrNamed,
     insert_stmt: convertInsertOrNamed,
@@ -69,5 +95,43 @@ const clauseVisitors = {
     pragma_stmt: convertPragma,
     attach_database_stmt: convertAttach,
     create_index_stmt: convertCreateIndex,
-    vacuum_stmt: () => callExpression(identifier('vacuum'), []),
+    vacuum_stmt: ({file}) => callExpression(identifier('vacuum'), file ? [
+        stringLiteral(file.value),
+    ] : []),
+    truncate_stmt: ({tables}) => {
+        const args = [];
+        
+        for (const table of tables.items)
+            args.push(convertTableName(table));
+        
+        return callExpression(identifier('truncate'), args);
+    },
+    detach_database_stmt: ({schema}) => callExpression(identifier('detach'), [
+        identifier(schema.name),
+    ]),
+    explain_stmt: convertExplain,
+    set_parameter_stmt: convertSetParam,
+    show_parameter_stmt: convertShowParam,
+    create_view_stmt: convertCreateView,
+    drop_view_stmt: convertDropView,
+    create_extension_stmt: convertCreateExtension,
+    create_schema_stmt: convertCreateSchema,
+    grant_privilege_stmt: convertGrant,
+    reindex_stmt: (stmt) => callExpression(identifier('reindex'), stmt.name ? [
+        identifier(stmt.name.name),
+    ] : []),
+    analyze_stmt: (stmt) => {
+        const args = [];
+        
+        for (const table of getAnalyzeTables(stmt))
+            args.push(convertTableName(table));
+        
+        return callExpression(identifier('analyze'), args);
+    },
+    release_savepoint_stmt: ({savepoint}) => callExpression(identifier('releaseSavepoint'), [
+        identifier(savepoint.name),
+    ]),
+    do_stmt: (stmt) => callExpression(identifier('doBlock'), [
+        stringLiteral(stmt.body.value),
+    ]),
 };

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

@@ -3,12 +3,16 @@ 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 {convertCondition} from '#parser/clause/where';
 import {findClause} from '#parser/clause/find';
 
 const {
     identifier,
     callExpression,
     arrayExpression,
+    stringLiteral,
+    tsAsExpression,
+    tsLiteralType,
 } = types;
 
 const convertExprToIdentifier = ({expr}) => identifier(expr.name);
@@ -49,24 +53,60 @@ const convertSource = (vc) => {
     return callExpression(identifier('values'), rowArgs);
 };
 
+const getTargetArgs = (target) => {
+    if (!target)
+        return [];
+    
+    const args = [];
+    
+    for (const item of target.expr.items)
+        args.push(convertExprToIdentifier(item));
+    
+    return args;
+};
+
+const convertUpsertAction = (action) => {
+    if (action.type === 'upsert_action_nothing')
+        return identifier('nothing');
+    
+    return convertSet(action.set);
+};
+
 const convertUpsert = (upsertClause) => {
     const target = upsertClause.conflictTarget;
     const {action} = upsertClause;
     
-    const targetArgs = target ? target.expr.items.map(convertExprToIdentifier) : [];
-    const actionNode = action.type === 'upsert_action_nothing' ? identifier('nothing') : convertSet(action.set);
+    const targetArgs = getTargetArgs(target);
+    const actionNode = convertUpsertAction(action);
+    
+    if (upsertClause.where)
+        targetArgs.push(callExpression(identifier('where'), [
+            convertCondition(upsertClause.where.expr),
+        ]));
     
     return callExpression(identifier('onConflict'), [...targetArgs, actionNode]);
 };
 
-const isReplaceInto = ({insertKw, orAction}) => !orAction && insertKw?.name === 'REPLACE';
+const isReplaceInto = ({insertKw, orAction}) => !orAction && insertKw && insertKw.name === 'REPLACE';
+
+const colsToArg = (cols) => {
+    if (cols.length === 1)
+        return identifier(cols[0].name);
+    
+    const args = [];
+    
+    for (const col of cols)
+        args.push(convertColToIdentifier(col));
+    
+    return arrayExpression(args);
+};
 
 const convertReplaceInto = ({clauses}) => {
     const ic = findClause(clauses, 'insert_clause');
     const rc = findClause(clauses, 'returning_clause');
     
     const cols = ic.columns.expr.items;
-    const colArg = cols.length === 1 ? identifier(cols[0].name) : arrayExpression(cols.map(convertColToIdentifier));
+    const colArg = colsToArg(cols);
     const source = convertSource(findClause(clauses, 'values_clause'));
     
     return callExpression(identifier('replaceInto'), [
@@ -79,6 +119,13 @@ const convertReplaceInto = ({clauses}) => {
     ].filter(Boolean));
 };
 
+const getSource = (dc, vc) => {
+    if (dc)
+        return callExpression(identifier('defaultValues'), []);
+    
+    return convertSource(vc);
+};
+
 export const convertInsert = (stmt) => {
     if (isReplaceInto(stmt.clauses[0]))
         return convertReplaceInto(stmt);
@@ -88,16 +135,16 @@ export const convertInsert = (stmt) => {
     const [, vc] = clauses;
     const uc = findClause(clauses, 'upsert_clause');
     const rc = findClause(clauses, 'returning_clause');
+    const dc = findClause(clauses, 'default_values');
     
-    const cols = ic.columns.expr.items;
-    const colArg = cols.length === 1 ? identifier(cols[0].name) : arrayExpression(cols.map(convertColToIdentifier));
-    const source = convertSource(vc);
+    const colArgs = convertColumns(ic);
+    const source = getSource(dc, vc);
     
     const args = [
         ic.orAction && convertOrAction(ic.orAction),
         callExpression(identifier('into'), [
-            identifier(ic.table.name),
-            colArg,
+            convertTable(ic),
+            ...colArgs,
             source,
         ]),
         uc && convertUpsert(uc),
@@ -106,3 +153,28 @@ export const convertInsert = (stmt) => {
     
     return callExpression(identifier('insert'), args);
 };
+
+const isAliasTable = ({table}) => table.type === 'alias';
+
+const convertTable = (ic) => {
+    if (!isAliasTable(ic))
+        return identifier(ic.table.name);
+    
+    const {expr, alias} = ic.table;
+    
+    return tsAsExpression(identifier(expr.name), tsLiteralType(stringLiteral(alias.name)));
+};
+
+const convertColumns = (ic) => {
+    const columns = ic.columns || ic.table.columnAliases;
+    
+    if (!columns)
+        return [];
+    
+    const cols = columns.expr.items;
+    const colArg = colsToArg(cols);
+    
+    return [
+        colArg,
+    ];
+};

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

@@ -2,6 +2,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';
+import {convertBinary} from '#parser/clause/binary';
 
 const {
     identifier,
@@ -13,17 +14,40 @@ const {
     callExpression,
 } = types;
 
+const isString = (a) => typeof a === 'string';
+
 export const convertMemberExpr = (node) => {
     const object = identifier(node.object.name);
     
     if (node.property.type === 'all_columns')
         return memberExpression(object, stringLiteral('*'), true);
     
+    if (node.property.type === 'array_subscript')
+        return memberExpression(object, convertOperand(node.property.expr), true);
+    
     return memberExpression(object, identifier(node.property.name));
 };
 
 const isFuncCall = ({type}) => type === 'func_call';
 
+const getDataTypeName = ({name}) => {
+    if (isString(name))
+        return name;
+    
+    return name.text;
+};
+
+const isArrayDataType = ({type}) => type === 'array_data_type';
+
+const convertDataType = (dataType) => {
+    if (!isArrayDataType(dataType))
+        return identifier(getDataTypeName(dataType));
+    
+    return callExpression(identifier('arrayType'), [
+        identifier(getDataTypeName(dataType.dataType)),
+    ]);
+};
+
 const convertQuantifier = (node) => {
     const {name} = node.quantifierKw;
     const inner = node.expr.expr;
@@ -42,6 +66,25 @@ const convertQuantifier = (node) => {
     return callExpression(identifier(name), args);
 };
 
+const convertPrefix = (node) => {
+    const {operator} = node;
+    const name = operator.name || operator;
+    
+    if (name === 'EXISTS')
+        return callExpression(identifier('exists'), [
+            convertClause(node.expr.expr),
+        ]);
+    
+    if (name === 'NOT')
+        return callExpression(identifier('not'), [
+            convertOperand(node.expr),
+        ]);
+    
+    return callExpression(identifier('unaryMinus'), [
+        convertOperand(node.expr),
+    ]);
+};
+
 export const convertOperand = (node) => {
     if (isCount(node))
         return convertCount(node);
@@ -74,7 +117,18 @@ export const convertOperand = (node) => {
     if (node.type === 'cast_operator_expr')
         return callExpression(identifier('pgCast'), [
             convertOperand(node.left),
-            identifier(node.right.name),
+            convertDataType(node.right),
+        ]);
+    
+    if (node.type === 'binary_expr')
+        return convertBinary(node);
+    
+    if (node.type === 'prefix_op_expr')
+        return convertPrefix(node);
+    
+    if (node.type === 'paren_expr' && node.expr.type === 'select_stmt')
+        return callExpression(identifier('subquery'), [
+            convertClause(node.expr),
         ]);
     
     if (node.type === 'parameter')