happy-sql 2.1.1 → 2.2.1

package/ChangeLog

@@ -1,3 +1,74 @@
+2026.08.24, v2.2.1
+
+fix:
+- c1535ff npmignore: fixture: exclude
+
+2026.08.24, v2.2.0
+
+fix:
+- d0a98eb column-definition: NOT NULL, DEFAULT, UNIQUE, CHECK, REFERENCES; CREATE TABLE IF NOT EXISTS
+- 8db3673 insert: multi-row VALUES support
+- 24afa16 index: wire create_index_stmt and vacuum_stmt to clauseVisitors
+- 4cdca5c from: LATERAL join support
+- b87b5ab select: ARRAY literal expression in column list
+- e803804 operand: ANY and ALL quantifier expressions
+- e5ca74f operand: handle PostgreSQL :: cast operator (cast_operator_expr)
+- 6f26e0c printer: CallExpression: into
+- 7325059 printer: queries
+- 9c12f1a printer: queries
+- d82705d where: NOT EXISTS, paren_expr in nested conditions
+- 719b4e3 happy-sql: parser+printer: UNION distinct vs UNION ALL
+- c8b4354 alter-table: support ADD COLUMN, DROP COLUMN, RENAME COLUMN, ALTER COLUMN TYPE
+- 9d052b4 binary: JSONB ->, ->>, and || string concat operators
+- 8d8205e binary: JSONB ->, ->>, and || string concat operators
+- f5ab342 select: support EXTRACT(unit FROM col)
+- 016d2ed select: support table.* (member_expr with all_columns)
+- 6a7510d select: support NULL and TRUE/FALSE literals
+- ea56135 drop-table: support multiple tables
+- 1a05cfd update: support RETURNING clause
+- c3e8b45 update: support FROM clause
+- 81c9875 where: not-between: detect betweenKw array, emit notBetween()
+- 267f929 binary: NOT LIKE, ILIKE, SIMILAR TO, IS DISTINCT FROM: add to OP_CONVERTERS
+- d52c89c from: support NATURAL JOIN
+- c595d7e from: support FULL OUTER JOIN
+- 7287f91 select: support CASE WHEN
+- 69e2c88 select: support CAST(x AS TYPE)
+- e112e67 where: support EXISTS
+- 324625b where: support IN (subquery)
+- 4922056 from: support subquery in FROM
+- b980624 returning: handle RETURNING *
+- a7b7b53 select: func-call: pass args to generic functions
+- 601c165 from: preserve LEFT/INNER/RIGHT/LEFT OUTER JOIN type
+
+feature:
+- 624c378 VACUUM
+- be90105 create index: add
+- 06be326 happy-sql: parser+printer: WINDOW ... OVER (PARTITION BY, ORDER BY)
+- bb3762d happy-sql: parser+printer: array literal ARRAY[...]
+- 34ab6f1 happy-sql: parser+printer: JSON/JSONB operators as array tuples
+- c1b121a attach: SQLite ATTACH DATABASE: parser + printer
+- 823912c pragma: SQLite PRAGMA statement: parser + printer
+- eadebe8 drop-index: parser + printer
+- 847adae transaction: BEGIN, COMMIT, ROLLBACK, SAVEPOINT, ROLLBACK TO SAVEPOINT
+- e2feb52 happy-sql: ctx -> printer
+- 515f571 happy-sql: generate_series — table-valued function in FROM
+- 39f51e3 parser/printer: where: between: add + test: happy-sql: roundtrip: full groupBy integration test
+- 6a22942 parser/printer: where: not-in: add
+- c1461ac parser/printer: distinct: add
+- 8885f47 parser/printer: limit, offset: add
+- 48f567c parser/printer: order-by: add
+- 33a852e parser/printer: aggregate functions: sum, avg, min, max, count(col)
+
+2026.08.23, v2.2.0
+
+feature:
+- parser/printer: JSON/JSONB operators as array tuples: ->, ->>, #>, #>>, ?, ?|, ?&, @>, <@
+- parser/printer: array literal ARRAY[...]
+fix:
+- parser/printer: UNION distinct vs UNION ALL
+feature:
+- parser/printer: WINDOW ... OVER (PARTITION BY, ORDER BY)
+
 2026.08.22, v2.1.1
 
 feature:

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

@@ -0,0 +1,40 @@
+import {types} from '@putout/babel';
+import {convertColumnDefinition} from '#parser/clause/column-definition';
+
+const {identifier, callExpression} = types;
+
+const convertAddColumn = (action) => callExpression(identifier('addColumn'), [
+    convertColumnDefinition(action.column),
+]);
+
+const convertDropColumn = (action) => callExpression(identifier('dropColumn'), [
+    identifier(action.column.name),
+]);
+
+const convertRenameColumn = (action) => callExpression(identifier('renameColumn'), [
+    identifier(action.oldName.name),
+    identifier(action.newName.name),
+]);
+
+const convertAlterColumnType = (action) => callExpression(identifier('alterColumnType'), [
+    identifier(action.column.name),
+    identifier(action.action.dataType.name),
+]);
+
+const ACTION_CONVERTERS = {
+    alter_action_add_column: convertAddColumn,
+    alter_action_drop_column: convertDropColumn,
+    alter_action_rename_column: convertRenameColumn,
+    alter_action_alter_column: convertAlterColumnType,
+};
+
+export const convertAlterTable = ({table, actions}) => {
+    const args = [
+        identifier(table.name),
+    ];
+    
+    for (const action of actions.items)
+        args.push(ACTION_CONVERTERS[action.type](action));
+    
+    return callExpression(identifier('alterTable'), args);
+};

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

@@ -0,0 +1,12 @@
+import {types} from '@putout/babel';
+
+const {
+    identifier,
+    callExpression,
+    stringLiteral,
+} = types;
+
+export const convertAttach = (stmt) => callExpression(identifier('attach'), [
+    stringLiteral(stmt.file.value),
+    identifier(stmt.schema.name),
+]);

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

@@ -0,0 +1,158 @@
+import {types} from '@putout/babel';
+import {convertOperand} from '#parser/clause/operand';
+import {convertClause} from '#parser/clause';
+
+const {
+    identifier,
+    callExpression,
+    binaryExpression,
+    arrayExpression,
+    stringLiteral,
+} = types;
+
+const isString = (a) => typeof a === 'string';
+const isSubqueryExpr = (node) => node.type === 'select_stmt';
+
+const getName = ({name}) => name;
+
+export const opName = (op) => {
+    if (Array.isArray(op)) {
+        const parts = [];
+        
+        for (const k of op)
+            parts.push(getName(k));
+        
+        return parts.join(' ');
+    }
+    
+    if (isString(op))
+        return op;
+    
+    return op.name;
+};
+
+const convertLike = (node) => callExpression(identifier('like'), [
+    convertOperand(node.left),
+    convertOperand(node.right),
+]);
+
+const convertNotLike = (node) => callExpression(identifier('notLike'), [
+    convertOperand(node.left),
+    convertOperand(node.right),
+]);
+
+const convertIlike = (node) => callExpression(identifier('ilike'), [
+    convertOperand(node.left),
+    convertOperand(node.right),
+]);
+
+const convertSimilarTo = (node) => callExpression(identifier('similarTo'), [
+    convertOperand(node.left),
+    convertOperand(node.right),
+]);
+
+const convertIsDistinctFrom = (node) => callExpression(identifier('isDistinctFrom'), [
+    convertOperand(node.left),
+    convertOperand(node.right),
+]);
+
+const convertConcat = (node) => callExpression(identifier('concat'), [
+    convertOperand(node.left),
+    convertOperand(node.right),
+]);
+
+const convertJsonTuple = (op) => (node) => arrayExpression([
+    convertOperand(node.left),
+    stringLiteral(op),
+    convertOperand(node.right),
+]);
+
+const convertIsNull = (node) => callExpression(identifier('isNull'), [
+    convertOperand(node.left),
+]);
+
+const convertIsNotNull = (node) => callExpression(identifier('isNotNull'), [
+    convertOperand(node.left),
+]);
+
+const convertIn = (node) => {
+    const inner = node.right.expr;
+    
+    if (isSubqueryExpr(inner))
+        return callExpression(identifier('inQuery'), [
+            convertOperand(node.left),
+            convertClause(inner),
+        ]);
+    
+    const args = [
+        convertOperand(node.left),
+    ];
+    
+    for (const item of inner.items)
+        args.push(convertOperand(item));
+    
+    return callExpression(identifier('inList'), args);
+};
+
+const convertNotIn = (node) => {
+    const args = [
+        convertOperand(node.left),
+    ];
+    
+    for (const item of node.right.expr.items)
+        args.push(convertOperand(item));
+    
+    return callExpression(identifier('notInList'), args);
+};
+
+const OP_CONVERTERS = {
+    'LIKE': convertLike,
+    'NOT LIKE': convertNotLike,
+    'ILIKE': convertIlike,
+    'SIMILAR TO': convertSimilarTo,
+    'IS DISTINCT FROM': convertIsDistinctFrom,
+    '->': convertJsonTuple('->'),
+    '->>': convertJsonTuple('->>'),
+    '#>': convertJsonTuple('#>'),
+    '#>>': convertJsonTuple('#>>'),
+    '?': convertJsonTuple('?'),
+    '?|': convertJsonTuple('?|'),
+    '?&': convertJsonTuple('?&'),
+    '@>': convertJsonTuple('@>'),
+    '<@': convertJsonTuple('<@'),
+    '||': convertConcat,
+    'IS': convertIsNull,
+    'IS NOT': convertIsNotNull,
+    'IN': convertIn,
+    'NOT IN': convertNotIn,
+};
+
+export const SQL_TO_JS_OP = {
+    '=': '===',
+    '!=': '!==',
+    '>=': '>=',
+    '<=': '<=',
+    '>': '>',
+    '<': '<',
+    '+': '+',
+    '-': '-',
+    '*': '*',
+    '/': '/',
+    '%': '%',
+};
+
+export const convertBinary = (node) => {
+    const op = opName(node.operator);
+    const convert = OP_CONVERTERS[op];
+    
+    if (convert)
+        return convert(node);
+    
+    const jsOp = SQL_TO_JS_OP[op] ?? '===';
+    
+    return binaryExpression(
+        jsOp,
+        convertOperand(node.left),
+        convertOperand(node.right),
+    );
+};

package/lib/parser/visitors/clause/case-when/case-when.js

@@ -0,0 +1,24 @@
+import {types} from '@putout/babel';
+import {convertOperand} from '#parser/clause/operand';
+import {convertCondition} from '#parser/clause/where';
+
+const {callExpression, identifier} = types;
+
+export const convertCaseWhen = (node) => {
+    const args = [];
+    
+    for (const clause of node.clauses) {
+        if (clause.type === 'case_when') {
+            args.push(convertCondition(clause.condition));
+            args.push(convertOperand(clause.result));
+            continue;
+        }
+        
+        if (clause.type === 'case_else')
+            args.push(callExpression(identifier('else_'), [
+                convertOperand(clause.result),
+            ]));
+    }
+    
+    return callExpression(identifier('caseWhen'), args);
+};

package/lib/parser/visitors/clause/column-definition/column-definition.js

@@ -1,6 +1,14 @@
 import {types} from '@putout/babel';
+import {convertBinary} from '#parser/clause/binary';
 
-const {identifier, callExpression} = types;
+const {
+    identifier,
+    callExpression,
+    numericLiteral,
+    stringLiteral,
+    nullLiteral,
+    booleanLiteral,
+} = types;
 
 const getDataType = (dataType) => {
     if (dataType.type === 'identifier')
@@ -24,21 +32,62 @@ const convertGenerated = (constraint) => {
 };
 
 const convertDefault = ({expr}) => {
-    if (expr.type !== 'func_call' || expr.name.name !== 'nextval')
-        return null;
+    if (expr.type === 'func_call' && expr.name.name === 'nextval') {
+        const seqName = expr.args.expr.args.items[0].value;
+        
+        return callExpression(identifier('nextval'), [
+            identifier(seqName),
+        ]);
+    }
+    
+    if (expr.type === 'number_literal')
+        return callExpression(identifier('default_'), [
+            numericLiteral(expr.value),
+        ]);
+    
+    if (expr.type === 'string_literal')
+        return callExpression(identifier('default_'), [
+            stringLiteral(expr.value),
+        ]);
+    
+    if (expr.type === 'null_literal')
+        return callExpression(identifier('default_'), [
+            nullLiteral(),
+        ]);
+    
+    if (expr.type === 'boolean_literal')
+        return callExpression(identifier('default_'), [
+            booleanLiteral(expr.value),
+        ]);
+    
+    return null;
+};
+
+const convertUnique = () => callExpression(identifier('unique'), []);
+
+const convertCheck = (constraint) => callExpression(identifier('check'), [
+    convertBinary(constraint.expr.expr),
+]);
+
+const convertReferences = (constraint) => {
+    const refTable = identifier(constraint.table.name);
+    const cols = constraint.columns.expr.items;
+    const args = [refTable];
     
-    const seqName = expr.args.expr.args.items[0].value;
+    for (const col of cols)
+        args.push(identifier(col.name));
     
-    return callExpression(identifier('nextval'), [
-        identifier(seqName),
-    ]);
+    return callExpression(identifier('references'), args);
 };
 
 const CONSTRAINT_VISITORS = {
     constraint_primary_key: () => callExpression(identifier('primaryKey'), []),
     constraint_generated: convertGenerated,
-    constraint_not_null: () => null,
+    constraint_not_null: () => callExpression(identifier('notNull'), []),
     constraint_default: convertDefault,
+    constraint_unique: convertUnique,
+    constraint_check: convertCheck,
+    references_specification: convertReferences,
 };
 
 const convertConstraint = (constraint) => {

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

@@ -0,0 +1,29 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+const convertColumns = (columns) => {
+    const {items} = columns.expr;
+    const cols = [];
+    
+    for (const item of items)
+        cols.push(identifier(item.expr.name));
+    
+    return cols;
+};
+
+export const convertCreateIndex = (stmt) => {
+    const {
+        name,
+        table,
+        columns,
+    } = stmt;
+    
+    const isUnique = stmt.indexTypeKw && stmt.indexTypeKw.name === 'UNIQUE';
+    
+    return callExpression(identifier(isUnique ? 'createUniqueIndex' : 'createIndex'), [
+        identifier(name.name),
+        identifier(table.name),
+        ...convertColumns(columns),
+    ]);
+};

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

@@ -7,11 +7,15 @@ const {
     arrayExpression,
 } = types;
 
-export const convertCreateTable = ({name, columns}) => {
+export const convertCreateTable = ({name, columns, ifNotExistsKw}) => {
     const colNodes = columns.expr.items.map(convertColumnDefinition);
-    
-    return callExpression(identifier('createTable'), [
+    const tableArgs = [
         identifier(name.name),
         arrayExpression(colNodes),
-    ]);
+    ];
+    
+    if (ifNotExistsKw)
+        return callExpression(identifier('createTableIfNotExists'), tableArgs);
+    
+    return callExpression(identifier('createTable'), tableArgs);
 };

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

@@ -1,5 +1,6 @@
 import {types} from '@putout/babel';
 import {convertWhere} from '#parser/clause/where';
+import {convertReturning} from '#parser/clause/returning';
 import {findClause} from '#parser/clause/find';
 
 const {identifier, callExpression} = types;
@@ -7,12 +8,14 @@ const {identifier, callExpression} = types;
 export const convertDelete = ({clauses}) => {
     const deleteClause = findClause(clauses, 'delete_clause');
     const whereClause = findClause(clauses, 'where_clause');
+    const returningClause = findClause(clauses, 'returning_clause');
     
     const table = identifier(deleteClause.tables.items[0].name);
     
     const args = [
         callExpression(identifier('from'), [table]),
         whereClause && convertWhere(whereClause),
+        returningClause && convertReturning(returningClause),
     ].filter(Boolean);
     
     return callExpression(identifier('deleteFrom'), args);

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

@@ -0,0 +1,12 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+export const convertDropIndex = (stmt) => {
+    const args = [];
+    
+    for (const idx of stmt.indexes.items)
+        args.push(identifier(idx.name));
+    
+    return callExpression(identifier('dropIndex'), args);
+};

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

@@ -0,0 +1,18 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+export const convertDropTable = (stmt) => {
+    const tableArgs = [];
+    
+    for (const table of stmt.tables.items)
+        tableArgs.push(identifier(table.name));
+    
+    if (stmt.ifExistsKw)
+        return callExpression(identifier('dropTable'), [
+            callExpression(identifier('ifExists'), []),
+            ...tableArgs,
+        ]);
+    
+    return callExpression(identifier('dropTable'), tableArgs);
+};