happy-sql 2.3.0 → 2.4.0

package/ChangeLog

@@ -1,3 +1,63 @@
+2026.08.27, v2.4.0
+
+fix:
+- 044050d nextval: scope DEFAULT nextval conversion to column defaults
+- 6f9d707 from: rightOuterJoin missing from printer imports
+- ba06223 over: window frame ROWS BETWEEN support
+- 6c35624 create-table: TEMP keyword and WITHOUT ROWID
+- 038cac6 references: ON DELETE and ON UPDATE actions
+- 6cd9a75 drop-view: IF EXISTS support
+- d5bd976 create-index: column sort order and index method
+- 1a6dc5f over: window frame ROWS BETWEEN support
+- e8c9ba6 column-definition: GENERATED ALWAYS AS expression
+- dbaea87 count: preserve DISTINCT modifier
+- 5d9ce53 like: ESCAPE clause support
+- e8322bc analyze: qualified table names
+- d0446af update: SQLite OR ABORT and OR FAIL
+- 1ffd47d order-by: ordinals and NULLS FIRST/LAST
+- 48c9aed alter-table: rename table, add constraint, RLS actions
+- 297b46a create-table: table-level primary key and unique constraints
+- 8f3d71f insert: optional column list, DEFAULT VALUES, table alias
+- 1609515 from: JOIN USING support
+- 4c0bc85 pragma: support get/set/qualified/string forms
+- 3ed2c4f select: support full expression set in select columns
+- 44bf5d7 happy-sql: from: UNNEST and func_call alias support
+- fedfc86 happy-sql: ANALYZE and REINDEX preserve table name
+- fbb7ce6 from: SQLite INDEXED BY and NOT INDEXED table hints
+- 923c7bb vacuum: VACUUM INTO file support
+- d00c4d2 update: SQLite OR REPLACE and OR IGNORE
+- 196eae8 drop-index: IF EXISTS support
+- 0cf9caf create-index: IF NOT EXISTS, CONCURRENTLY, WHERE partial index
+- 15cf3bb with-named: remove extra indentation from CTE body
+- 018e921 lateral-join: alias without AS for subquery
+- e3f4ae8 detach database statement
+- c070d03 window: named WINDOW clause
+- 9792a5e from: subquery alias without AS keyword
+- 4868889 where: ISNULL/NOTNULL postfix
+- 3bea77a create-table: AS SELECT form
+- d5ff74b values: standalone VALUES statement
+- 6f27346 truncate: add statement
+- 5a07d99 select: DISTINCT ON
+- 964f8e6 func-call: FILTER (WHERE ...)
+- 407ff5e binary-expression: || concat
+- ed2b211 operand: :: cast_operator_expr
+- b08cc9f binary-expression: ?? → ?
+
+feature:
+- 3fff1e3 happy-sql: putout_processor_sql
+- 97f890f USING
+- 8ccaa46 RIGHT OUTER JOIN
+- 29a5510 happy-sql: DO block
+- a18ac59 reindex, analyze, release-savepoint: add trivial statement types
+- f0fef07 create-virtual-table: SQLite CREATE VIRTUAL TABLE USING
+- dfe2b2c grant: GRANT privilege ON table TO role
+- 2a29916 create-schema: CREATE SCHEMA
+- f272f3b create-extension: CREATE EXTENSION
+- cd61021 drop-view: DROP VIEW
+- aef8f2a create-view: CREATE VIEW and CREATE MATERIALIZED VIEW
+- d2585b8 set-param: SET and SHOW parameter statements
+- 0e734a4 explain: EXPLAIN and EXPLAIN ANALYZE
+
 2026.08.24, v2.3.0
 
 fix:

package/bin/convert.js

@@ -1,15 +1,9 @@
-import {
-    __markdown_name,
-    fromJS,
-} from '@putout/operator-json';
+import {__sql_name, fromJS} from '@putout/operator-json';
 import {convertJsToSql, convertSqlToJs} from '#happy-sql';
 
 export function convert(source) {
-    if (source.startsWith(__markdown_name))
-        return convertJsToSql(fromJS(
-            source,
-            __markdown_name,
-        ));
+    if (source.startsWith(__sql_name))
+        return convertJsToSql(fromJS(source, __sql_name));
     
     if (source.startsWith('['))
         return convertJsToSql(source);

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

@@ -1,5 +1,6 @@
 import {types} from '@putout/babel';
 import {convertColumnDefinition} from '#parser/clause/column-definition';
+import {convertTableConstraint} from '../table-constraint.js';
 
 const {identifier, callExpression} = types;
 
@@ -7,6 +8,22 @@ const convertAddColumn = (action) => callExpression(identifier('addColumn'), [
     convertColumnDefinition(action.column),
 ]);
 
+const convertRenameTable = (action) => callExpression(identifier('renameTable'), [
+    identifier(action.newName.name),
+]);
+
+const convertAddConstraint = ({name, constraint}) => {
+    const node = convertTableConstraint(constraint);
+    
+    if (!name)
+        return node;
+    
+    return callExpression(identifier('constraint'), [
+        identifier(name.name.name),
+        node,
+    ]);
+};
+
 const convertDropColumn = (action) => callExpression(identifier('dropColumn'), [
     identifier(action.column.name),
 ]);
@@ -26,6 +43,10 @@ const ACTION_CONVERTERS = {
     alter_action_drop_column: convertDropColumn,
     alter_action_rename_column: convertRenameColumn,
     alter_action_alter_column: convertAlterColumnType,
+    alter_action_rename: convertRenameTable,
+    alter_action_add_constraint: convertAddConstraint,
+    alter_action_enable: () => callExpression(identifier('enableRowLevelSecurity'), []),
+    alter_action_disable: () => callExpression(identifier('disableRowLevelSecurity'), []),
 };
 
 export const convertAlterTable = ({table, actions}) => {

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

@@ -31,10 +31,20 @@ export const opName = (op) => {
     return op.name;
 };
 
-const convertLike = (node) => callExpression(identifier('like'), [
-    convertOperand(node.left),
-    convertOperand(node.right),
-]);
+const isEscape = (node) => node?.type === 'binary_expr' && opName(node.operator) === 'ESCAPE';
+
+const convertLike = (node) => {
+    const args = [
+        convertOperand(node.left),
+    ];
+    
+    if (isEscape(node.right))
+        args.push(convertOperand(node.right.left), convertOperand(node.right.right));
+    else
+        args.push(convertOperand(node.right));
+    
+    return callExpression(identifier('like'), args);
+};
 
 const convertNotLike = (node) => callExpression(identifier('notLike'), [
     convertOperand(node.left),
@@ -56,9 +66,16 @@ const convertIsDistinctFrom = (node) => callExpression(identifier('isDistinctFro
     convertOperand(node.right),
 ]);
 
+const convertConcatOperand = (node) => {
+    if (node.operator && opName(node.operator) === '||')
+        return convertConcat(node);
+    
+    return convertOperand(node);
+};
+
 const convertConcat = (node) => callExpression(identifier('concat'), [
-    convertOperand(node.left),
-    convertOperand(node.right),
+    convertConcatOperand(node.left),
+    convertConcatOperand(node.right),
 ]);
 
 const convertJsonTuple = (op) => (node) => arrayExpression([
@@ -67,6 +84,11 @@ const convertJsonTuple = (op) => (node) => arrayExpression([
     convertOperand(node.right),
 ]);
 
+const convertCollate = (node) => callExpression(identifier('collate'), [
+    convertOperand(node.left),
+    convertOperand(node.right),
+]);
+
 const convertIsNull = (node) => callExpression(identifier('isNull'), [
     convertOperand(node.left),
 ]);
@@ -118,6 +140,7 @@ const OP_CONVERTERS = {
     '?': convertJsonTuple('?'),
     '?|': convertJsonTuple('?|'),
     '?&': convertJsonTuple('?&'),
+    '??': convertJsonTuple('??'),
     '@>': convertJsonTuple('@>'),
     '<@': convertJsonTuple('<@'),
     '||': convertConcat,
@@ -125,6 +148,7 @@ const OP_CONVERTERS = {
     'IS NOT': convertIsNotNull,
     'IN': convertIn,
     'NOT IN': convertNotIn,
+    'COLLATE': convertCollate,
 };
 
 export const SQL_TO_JS_OP = {

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

@@ -31,14 +31,25 @@ const convertGenerated = (constraint) => {
     return callExpression(identifier('identity'), []);
 };
 
+const isGeneratedExpr = ({expr}) => expr?.type === 'paren_expr';
+
+const convertGeneratedExpr = (constraint) => callExpression(identifier('generatedAlwaysAs'), [
+    convertBinary(constraint.expr.expr),
+    booleanLiteral(constraint.storageKw?.name === 'STORED'),
+]);
+
+const convertDefaultNextval = (expr) => {
+    const [seq] = expr.args.expr.args.items;
+    const seqName = seq.value ?? seq.name;
+    
+    return callExpression(identifier('defaultNextval'), [
+        identifier(seqName),
+    ]);
+};
+
 const convertDefault = ({expr}) => {
-    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 === 'func_call' && expr.name.name === 'nextval')
+        return convertDefaultNextval(expr);
     
     if (expr.type === 'number_literal')
         return callExpression(identifier('default_'), [
@@ -69,6 +80,28 @@ const convertCheck = (constraint) => callExpression(identifier('check'), [
     convertBinary(constraint.expr.expr),
 ]);
 
+const ACTION_NAMES = {
+    CASCADE: true,
+    RESTRICT: true,
+    SET_NULL: true,
+    SET_DEFAULT: true,
+};
+
+const convertReferentialAction = ({eventKw, actionKw}) => {
+    const event = eventKw.name === 'DELETE' ? 'onDelete' : 'onUpdate';
+    const action = Array.isArray(actionKw) ? actionKw
+        .map(({name}) => name)
+        .join(' ') : actionKw.name;
+    
+    const name = ACTION_NAMES[action] ? action : action
+        .replace(/\s+/g, '_')
+        .toUpperCase();
+    
+    return callExpression(identifier(event), [
+        identifier(name),
+    ]);
+};
+
 const convertReferences = (constraint) => {
     const refTable = identifier(constraint.table.name);
     const cols = constraint.columns.expr.items;
@@ -77,12 +110,20 @@ const convertReferences = (constraint) => {
     for (const col of cols)
         args.push(identifier(col.name));
     
+    for (const option of constraint.options)
+        args.push(convertReferentialAction(option));
+    
     return callExpression(identifier('references'), args);
 };
 
 const CONSTRAINT_VISITORS = {
     constraint_primary_key: () => callExpression(identifier('primaryKey'), []),
-    constraint_generated: convertGenerated,
+    constraint_generated: (constraint) => {
+        if (isGeneratedExpr(constraint))
+            return convertGeneratedExpr(constraint);
+        
+        return convertGenerated(constraint);
+    },
     constraint_not_null: () => callExpression(identifier('notNull'), []),
     constraint_default: convertDefault,
     constraint_unique: convertUnique,

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

@@ -15,7 +15,8 @@ export const isCount = (column) => {
 };
 
 export const convertCount = (column) => {
-    const {items} = column.args.expr.args;
+    const funcArgs = column.args.expr;
+    const {items} = funcArgs.args;
     const args = [];
     
     for (const item of items) {
@@ -34,5 +35,7 @@ export const convertCount = (column) => {
         args.push(identifier(item.name));
     }
     
-    return callExpression(identifier('count'), args);
+    const name = funcArgs.distinctKw ? 'countDistinct' : 'count';
+    
+    return callExpression(identifier(name), args);
 };

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

@@ -0,0 +1,7 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+export const convertCreateExtension = (stmt) => callExpression(identifier('createExtension'), [
+    identifier(stmt.name.name),
+]);

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

@@ -1,13 +1,23 @@
 import {types} from '@putout/babel';
+import {convertCondition} from '#parser/clause/where';
+import {findClause} from '#parser/clause/find';
 
 const {identifier, callExpression} = types;
 
+const isDesc = (item) => item.direction?.type === 'sort_direction_desc';
+
 const convertColumns = (columns) => {
     const {items} = columns.expr;
     const cols = [];
     
-    for (const item of items)
-        cols.push(identifier(item.expr.name));
+    for (const item of items) {
+        if (isDesc(item))
+            cols.push(callExpression(identifier('desc'), [
+                identifier(item.expr.name),
+            ]));
+        else
+            cols.push(identifier(item.expr.name));
+    }
     
     return cols;
 };
@@ -21,9 +31,30 @@ export const convertCreateIndex = (stmt) => {
     
     const isUnique = stmt.indexTypeKw && stmt.indexTypeKw.name === 'UNIQUE';
     
-    return callExpression(identifier(isUnique ? 'createUniqueIndex' : 'createIndex'), [
+    const args = [
         identifier(name.name),
         identifier(table.name),
-        ...convertColumns(columns),
-    ]);
+    ];
+    
+    if (stmt.using)
+        args.push(callExpression(identifier('accessMethod'), [
+            identifier(stmt.using.method.name),
+        ]));
+    
+    args.push(...convertColumns(columns));
+    
+    const whereClause = findClause(stmt.clauses, 'where_clause');
+    
+    if (stmt.ifNotExistsKw)
+        args.push(callExpression(identifier('ifNotExists'), []));
+    
+    if (stmt.concurrentlyKw)
+        args.push(callExpression(identifier('concurrently'), []));
+    
+    if (whereClause)
+        args.push(callExpression(identifier('where'), [
+            convertCondition(whereClause.expr),
+        ]));
+    
+    return callExpression(identifier(isUnique ? 'createUniqueIndex' : 'createIndex'), args);
 };

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

@@ -0,0 +1,7 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+export const convertCreateSchema = (stmt) => callExpression(identifier('createSchema'), [
+    identifier(stmt.name.name),
+]);

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

@@ -1,5 +1,7 @@
 import {types} from '@putout/babel';
 import {convertColumnDefinition} from '#parser/clause/column-definition';
+import {convertClause} from '#parser/clause';
+import {convertTableConstraint} from '../table-constraint.js';
 
 const {
     identifier,
@@ -7,15 +9,64 @@ const {
     arrayExpression,
 } = types;
 
-export const convertCreateTable = ({name, columns, ifNotExistsKw}) => {
-    const colNodes = columns.expr.items.map(convertColumnDefinition);
-    const tableArgs = [
-        identifier(name.name),
+const isAsClause = ({type}) => type === 'as_clause';
+const isVirtual = (stmt) => stmt.kind && stmt.kind.kindKw.name === 'VIRTUAL';
+const isColumnDefinition = ({type}) => type === 'column_definition';
+const isTemp = (stmt) => ['TEMP', 'TEMPORARY'].includes(stmt.kind?.kindKw.name);
+
+const convertColumnListItem = (item) => {
+    if (isColumnDefinition(item))
+        return convertColumnDefinition(item);
+    
+    return convertTableConstraint(item);
+};
+
+const isWithoutRowid = (options) => options?.items.some(({name}) => name?.some?.(({name}) => name === 'WITHOUT'));
+
+const convertTableArgs = (stmt) => {
+    const colNodes = stmt.columns.expr.items.map(convertColumnListItem);
+    
+    if (isWithoutRowid(stmt.options))
+        colNodes.push(callExpression(identifier('withoutRowid'), []));
+    
+    return [
+        identifier(stmt.name.name),
         arrayExpression(colNodes),
     ];
+};
+
+const convertUsing = ({module}) => {
+    const args = [];
+    
+    for (const item of module.args.expr.args.items)
+        args.push(identifier(item.name));
+    
+    return callExpression(identifier(module.name.name), args);
+};
+
+export const convertCreateTable = (stmt) => {
+    if (isVirtual(stmt)) {
+        const [usingClause] = stmt.clauses;
+        
+        return callExpression(identifier('createVirtualTable'), [
+            identifier(stmt.name.name),
+            convertUsing(usingClause),
+        ]);
+    }
+    
+    const asClause = stmt.clauses?.find(isAsClause);
+    
+    if (asClause)
+        return callExpression(identifier('createTableAs'), [
+            identifier(stmt.name.name),
+            convertClause(asClause.expr),
+        ]);
+    
+    const fnName = isTemp(stmt) ? 'createTempTable' : 'createTable';
+    const tableArgs = convertTableArgs(stmt);
     
-    if (ifNotExistsKw)
-        return callExpression(identifier('createTableIfNotExists'), tableArgs);
+    if (stmt.ifNotExistsKw)
+        return callExpression(identifier(`${fnName}IfNotExists`), tableArgs);
     
-    return callExpression(identifier('createTable'), tableArgs);
+    return callExpression(identifier(fnName), tableArgs);
 };

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

@@ -0,0 +1,17 @@
+import {types} from '@putout/babel';
+import {convertClause} from '#parser/clause';
+
+const {identifier, callExpression} = types;
+
+const isMaterialized = (stmt) => stmt.kinds.some(({kindKw}) => kindKw.name === 'MATERIALIZED');
+
+export const convertCreateView = (stmt) => {
+    const [asClause] = stmt.clauses;
+    const inner = convertClause(asClause.expr);
+    const fnName = isMaterialized(stmt) ? 'createMaterializedView' : 'createView';
+    
+    return callExpression(identifier(fnName), [
+        identifier(stmt.name.name),
+        inner,
+    ]);
+};

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

@@ -5,6 +5,9 @@ const {identifier, callExpression} = types;
 export const convertDropIndex = (stmt) => {
     const args = [];
     
+    if (stmt.ifExistsKw)
+        args.push(callExpression(identifier('ifExists'), []));
+    
     for (const idx of stmt.indexes.items)
         args.push(identifier(idx.name));
     

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

@@ -0,0 +1,15 @@
+import {types} from '@putout/babel';
+
+const {identifier, callExpression} = types;
+
+export const convertDropView = (stmt) => {
+    const args = [];
+    
+    if (stmt.ifExistsKw)
+        args.push(callExpression(identifier('ifExists'), []));
+    
+    for (const view of stmt.views.items)
+        args.push(identifier(view.name));
+    
+    return callExpression(identifier('dropView'), args);
+};

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

@@ -0,0 +1,16 @@
+import {types} from '@putout/babel';
+import {convertClause} from '#parser/clause';
+
+const {identifier, callExpression} = types;
+
+export const convertExplain = (stmt) => {
+    const inner = convertClause(stmt.statement);
+    
+    if (stmt.analyzeKw)
+        return callExpression(identifier('explainAnalyze'), [inner]);
+    
+    if (stmt.queryPlanKw)
+        return callExpression(identifier('explainQueryPlan'), [inner]);
+    
+    return callExpression(identifier('explain'), [inner]);
+};