happy-sql 2.4.0 → 2.5.0

package/ChangeLog

@@ -1,3 +1,37 @@
+2026.11.15, v2.5.0
+
+feature:
+- 1c961c1 happy-sql: apply type checker
+- a4f7d90 happy-sql: where: keep parentheses in nested expressions
+
+2026.11.14, v2.4.1
+
+fix:
+- 10d5818 happy-sql: join
+- 7510903 alter-table: rename table, add constraint, RLS actions
+- a4e14a1 references: ON DELETE and ON UPDATE actions
+- 60cbd74 from: extract capitalizeWord, remove inlined arrow
+- 3ebbea9 with-named: extract convertColumn, remove inlined arrow
+- 8848396 printer/from: remove inlined arrows and ternary
+- 0cc326c window-frame: remove optional chaining
+- 652387a references: remove optional chaining
+- 344f7c3 clause/index: remove optional chaining, nullish coalescing, inlined arrows
+- 313fa5f binary: remove optional chaining and nullish coalescing
+- 12b6f3c insert: remove optional chaining and inlined arrows/ternaries
+- 652bcad create-index: remove optional chaining
+- b5b40ac limit: remove optional chaining
+- 5eb1732 create-table: remove optional chaining and inlined arrows
+- f078532 create-view: extract isMaterializedKind predicate
+- 472e627 order-by: extract nulls order fn name
+- ddcb389 group-by: remove inlined arrow in map
+- 1be75b4 table-func: extract getRawName, remove inlined ternary
+- 10a0b35 column-definition: remove optional chaining, nullish coalescing, inlined arrows
+- 9108d3e operand: remove optional chaining and nullish coalescing
+
+feature:
+- ffaef07 happy-sql: sql-parser-cst v0.44.1
+- 981cf13 happy-sql: @putout/plugin-printer v9.0.0
+
 2026.08.27, v2.4.0
 
 fix:

package/lib/parser/parser.js

@@ -18,19 +18,17 @@ const DIALECTS = [
     'sqlite',
 ];
 
-const parseCstDialect = (source, dialect) => parseCst(source, {
-    dialect,
-    paramTypes: [':name'],
-    includeRange: true,
-    includeComments: true,
-});
-
 export const parseSql = (source) => {
     let cst;
     let error;
     
     for (const dialect of DIALECTS) {
-        [error, cst] = tryCatch(parseCstDialect, source, dialect);
+        [error, cst] = tryCatch(parseCst, source, {
+            dialect,
+            paramTypes: [':name'],
+            includeRange: true,
+            includeComments: true,
+        });
         
         if (cst)
             return convertSource(cst);
@@ -47,9 +45,11 @@ const getSectionName = (leading) => {
     
     const comment = leading.find(isComment);
     
-    return comment ? comment.text
-        .slice(2)
-        .trim() : null;
+    return comment
+        ? comment.text
+            .slice(2)
+            .trim()
+        : null;
 };
 
 const convertSource = (cst) => {

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

@@ -14,14 +14,17 @@ const convertRenameTable = (action) => callExpression(identifier('renameTable'),
 
 const convertAddConstraint = ({name, constraint}) => {
     const node = convertTableConstraint(constraint);
+    const args = [];
     
-    if (!name)
-        return node;
+    if (name)
+        args.push(callExpression(identifier('constraint'), [
+            identifier(name.name.name),
+            node,
+        ]));
+    else
+        args.push(node);
     
-    return callExpression(identifier('constraint'), [
-        identifier(name.name.name),
-        node,
-    ]);
+    return callExpression(identifier('addConstraint'), args);
 };
 
 const convertDropColumn = (action) => callExpression(identifier('dropColumn'), [

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

@@ -31,7 +31,7 @@ export const opName = (op) => {
     return op.name;
 };
 
-const isEscape = (node) => node?.type === 'binary_expr' && opName(node.operator) === 'ESCAPE';
+const isEscape = (node) => node && node.type === 'binary_expr' && opName(node.operator) === 'ESCAPE';
 
 const convertLike = (node) => {
     const args = [
@@ -89,13 +89,22 @@ const convertCollate = (node) => callExpression(identifier('collate'), [
     convertOperand(node.right),
 ]);
 
-const convertIsNull = (node) => callExpression(identifier('isNull'), [
-    convertOperand(node.left),
-]);
+const isNullLiteral = ({type}) => type === 'null_literal';
 
-const convertIsNotNull = (node) => callExpression(identifier('isNotNull'), [
-    convertOperand(node.left),
-]);
+const createIs = (nullName, name) => (node) => {
+    if (isNullLiteral(node.right))
+        return callExpression(identifier(nullName), [
+            convertOperand(node.left),
+        ]);
+    
+    return callExpression(identifier(name), [
+        convertOperand(node.left),
+        convertOperand(node.right),
+    ]);
+};
+
+const convertIsNull = createIs('isNull', 'is');
+const convertIsNotNull = createIs('isNotNull', 'isNot');
 
 const convertIn = (node) => {
     const inner = node.right.expr;
@@ -172,7 +181,7 @@ export const convertBinary = (node) => {
     if (convert)
         return convert(node);
     
-    const jsOp = SQL_TO_JS_OP[op] ?? '===';
+    const jsOp = SQL_TO_JS_OP[op] || '===';
     
     return binaryExpression(
         jsOp,

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

@@ -31,16 +31,18 @@ const convertGenerated = (constraint) => {
     return callExpression(identifier('identity'), []);
 };
 
-const isGeneratedExpr = ({expr}) => expr?.type === 'paren_expr';
+const isGeneratedExpr = ({expr}) => expr && expr.type === 'paren_expr';
+
+const isStored = (constraint) => Boolean(constraint.storageKw) && constraint.storageKw.name === 'STORED';
 
 const convertGeneratedExpr = (constraint) => callExpression(identifier('generatedAlwaysAs'), [
     convertBinary(constraint.expr.expr),
-    booleanLiteral(constraint.storageKw?.name === 'STORED'),
+    booleanLiteral(isStored(constraint)),
 ]);
 
 const convertDefaultNextval = (expr) => {
     const [seq] = expr.args.expr.args.items;
-    const seqName = seq.value ?? seq.name;
+    const seqName = seq.value || seq.name;
     
     return callExpression(identifier('defaultNextval'), [
         identifier(seqName),
@@ -87,15 +89,26 @@ const ACTION_NAMES = {
     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 getActionName = (kw) => kw.name;
+
+const normalizeAction = (a) => {
+    if (ACTION_NAMES[a])
+        return a;
     
-    const name = ACTION_NAMES[action] ? action : action
+    return a
         .replace(/\s+/g, '_')
         .toUpperCase();
+};
+
+const convertReferentialAction = ({eventKw, actionKw}) => {
+    const event = eventKw.name === 'DELETE' ? 'onDelete' : 'onUpdate';
+    const action = Array.isArray(actionKw)
+        ? actionKw
+            .map(getActionName)
+            .join(' ')
+        : actionKw.name;
+    
+    const name = normalizeAction(action);
     
     return callExpression(identifier(event), [
         identifier(name),

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

@@ -4,7 +4,7 @@ import {findClause} from '#parser/clause/find';
 
 const {identifier, callExpression} = types;
 
-const isDesc = (item) => item.direction?.type === 'sort_direction_desc';
+const isDesc = (item) => item.direction && item.direction.type === 'sort_direction_desc';
 
 const convertColumns = (columns) => {
     const {items} = columns.expr;

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

@@ -12,7 +12,7 @@ const {
 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 isTemp = (stmt) => stmt.kind && ['TEMP', 'TEMPORARY'].includes(stmt.kind.kindKw.name);
 
 const convertColumnListItem = (item) => {
     if (isColumnDefinition(item))
@@ -21,10 +21,15 @@ const convertColumnListItem = (item) => {
     return convertTableConstraint(item);
 };
 
-const isWithoutRowid = (options) => options?.items.some(({name}) => name?.some?.(({name}) => name === 'WITHOUT'));
+const isWithoutName = ({name}) => name === 'WITHOUT';
+const isWithoutKeyword = ({name}) => Array.isArray(name) && name.some(isWithoutName);
+const isWithoutRowid = (options) => options && options.items.some(isWithoutKeyword);
 
 const convertTableArgs = (stmt) => {
-    const colNodes = stmt.columns.expr.items.map(convertColumnListItem);
+    const colNodes = [];
+    
+    for (const item of stmt.columns.expr.items)
+        colNodes.push(convertColumnListItem(item));
     
     if (isWithoutRowid(stmt.options))
         colNodes.push(callExpression(identifier('withoutRowid'), []));
@@ -54,7 +59,7 @@ export const convertCreateTable = (stmt) => {
         ]);
     }
     
-    const asClause = stmt.clauses?.find(isAsClause);
+    const asClause = stmt.clauses && stmt.clauses.find(isAsClause);
     
     if (asClause)
         return callExpression(identifier('createTableAs'), [

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

@@ -3,7 +3,8 @@ import {convertClause} from '#parser/clause';
 
 const {identifier, callExpression} = types;
 
-const isMaterialized = (stmt) => stmt.kinds.some(({kindKw}) => kindKw.name === 'MATERIALIZED');
+const isMaterializedKind = ({kindKw}) => kindKw.name === 'MATERIALIZED';
+const isMaterialized = (stmt) => stmt.kinds.some(isMaterializedKind);
 
 export const convertCreateView = (stmt) => {
     const [asClause] = stmt.clauses;

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

@@ -1,7 +1,9 @@
 import {types} from '@putout/babel';
-import {convertBetween} from '#parser/clause/where';
+import {
+    convertCondition,
+    convertWhere,
+} from '#parser/clause/where';
 import {convertClause} from '#parser/clause';
-import {convertBinary} from '#parser/clause/binary';
 import {
     convertOperand,
     convertMemberExpr,
@@ -20,59 +22,13 @@ import {
 const {
     identifier,
     callExpression,
-    logicalExpression,
     stringLiteral,
     tsAsExpression,
     tsLiteralType,
 } = types;
 
-const isExists = (node) => node.type === 'prefix_op_expr' && node.operator.name === 'EXISTS';
-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));
-    
-    if (node.operator && node.operator.name === 'OR')
-        return logicalExpression('||', convertCondition(node.left), convertCondition(node.right));
-    
-    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),
-        ]);
-    
-    if (isExists(node))
-        return callExpression(identifier('exists'), [
-            convertClause(node.expr.expr),
-        ]);
-    
-    if (isParenExpr(node))
-        return convertCondition(node.expr);
-    
-    return convertBinary(node);
-};
-
 const convertOn = (spec) => callExpression(identifier('on'), [
     convertCondition(spec.expr),
 ]);
@@ -145,6 +101,11 @@ const joinTypeParts = (operator) => {
     return parts;
 };
 
+const capitalizeWord = (s) => s[0].toUpperCase() +
+    s
+        .slice(1)
+        .toLowerCase();
+
 const convertJoinType = (operator) => {
     const parts = joinTypeParts(operator);
     
@@ -155,14 +116,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`;
 };
@@ -238,9 +197,7 @@ export const convertFrom = ({expr, whereClause, groupByClause, havingClause, ord
     const fromArgs = [];
     
     if (whereClause)
-        fromArgs.push(callExpression(identifier('where'), [
-            convertCondition(whereClause.expr),
-        ]));
+        fromArgs.push(convertWhere(whereClause));
     
     if (groupByClause)
         fromArgs.push(convertGroupBy(groupByClause));
@@ -268,7 +225,11 @@ export const convertFrom = ({expr, whereClause, groupByClause, havingClause, ord
     
     if (expr.type === 'join_expr') {
         const parts = flattenJoins(expr);
-        return callExpression(identifier('from'), parts);
+        
+        return callExpression(identifier('from'), [
+            ...parts,
+            ...fromArgs,
+        ]);
     }
     
     if (expr.type === 'alias')

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,7 +7,7 @@ const {
 } = types;
 
 export const convertLimit = (limitClause) => {
-    if (limitClause.count?.type === 'limit_all')
+    if (limitClause.count && limitClause.count.type === 'limit_all')
         return callExpression(identifier('limitAll'), []);
     
     const args = [

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

@@ -7,8 +7,9 @@ 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(isLast ? 'nullsLast' : 'nullsFirst'), [col]);
+    return callExpression(identifier(fnName), [col]);
 };
 
 const convertOrderItem = (item) => {

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

@@ -6,9 +6,18 @@ const {callExpression, identifier} = types;
 const SNAKE_RE = /_([a-z])/g;
 const toCamel = (s) => s.replace(SNAKE_RE, (_, c) => c.toUpperCase());
 
+const getRawName = (expr) => {
+    const raw = expr.name.name;
+    
+    if (raw.includes('_'))
+        return raw.toLowerCase();
+    
+    return raw;
+};
+
 export const convertTableFunc = (expr) => {
     // multi-word snake_case names are lowercased first (GENERATE_SERIES → generateSeries)
-    const name = toCamel(expr.name.name.includes('_') ? expr.name.name.toLowerCase() : expr.name.name);
+    const name = toCamel(getRawName(expr));
     const args = expr.args.expr.args.items.map(convertOperand);
     
     return callExpression(identifier(name), args);

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

@@ -75,6 +75,8 @@ const convertSelectOrNamed = (stmt) => {
     return convertSelect(stmt);
 };
 
+const getAnalyzeTables = ({tables}) => tables.items || tables;
+
 const clauseVisitors = {
     select_stmt: convertSelectOrNamed,
     insert_stmt: convertInsertOrNamed,
@@ -96,7 +98,14 @@ const clauseVisitors = {
     vacuum_stmt: ({file}) => callExpression(identifier('vacuum'), file ? [
         stringLiteral(file.value),
     ] : []),
-    truncate_stmt: ({tables}) => callExpression(identifier('truncate'), tables.items.map(({name}) => identifier(name))),
+    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),
     ]),
@@ -111,7 +120,14 @@ const clauseVisitors = {
     reindex_stmt: (stmt) => callExpression(identifier('reindex'), stmt.name ? [
         identifier(stmt.name.name),
     ] : []),
-    analyze_stmt: (stmt) => callExpression(identifier('analyze'), (stmt.tables?.items ?? []).map(convertTableName)),
+    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),
     ]),

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

@@ -53,12 +53,31 @@ 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'), [
@@ -68,14 +87,26 @@ const convertUpsert = (upsertClause) => {
     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'), [
@@ -88,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);
@@ -100,7 +138,7 @@ export const convertInsert = (stmt) => {
     const dc = findClause(clauses, 'default_values');
     
     const colArgs = convertColumns(ic);
-    const source = dc ? callExpression(identifier('defaultValues'), []) : convertSource(vc);
+    const source = getSource(dc, vc);
     
     const args = [
         ic.orAction && convertOrAction(ic.orAction),
@@ -134,7 +172,7 @@ const convertColumns = (ic) => {
         return [];
     
     const cols = columns.expr.items;
-    const colArg = cols.length === 1 ? identifier(cols[0].name) : arrayExpression(cols.map(convertColToIdentifier));
+    const colArg = colsToArg(cols);
     
     return [
         colArg,

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

@@ -68,7 +68,7 @@ const convertQuantifier = (node) => {
 
 const convertPrefix = (node) => {
     const {operator} = node;
-    const name = operator?.name ?? operator;
+    const name = operator.name || operator;
     
     if (name === 'EXISTS')
         return callExpression(identifier('exists'), [
@@ -131,6 +131,16 @@ export const convertOperand = (node) => {
             convertClause(node.expr),
         ]);
     
+    if (node.type === 'paren_expr') {
+        const inner = convertOperand(node.expr);
+        
+        inner.extra = {
+            parenthesized: true,
+        };
+        
+        return inner;
+    }
+    
     if (node.type === 'parameter')
         return stringLiteral(node.text);
     

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

@@ -10,6 +10,7 @@ import {convertBinary} from '#parser/clause/binary';
 import {
     convertCondition,
     convertBetween,
+    convertWhere,
 } from '#parser/clause/where';
 import {findClause} from '#parser/clause/find';
 import {convertOrderBy} from '../from/order-by.js';
@@ -145,10 +146,12 @@ const convertFrameBound = (bound) => {
     
     const name = bound.type === 'frame_bound_preceding' ? 'preceding' : 'following';
     
-    const isUnbounded = bound.expr?.type === 'frame_unbounded';
-    const args = !isUnbounded && bound.expr ? [
-        numericLiteral(bound.expr.value),
-    ] : [];
+    const isUnbounded = bound.expr && bound.expr.type === 'frame_unbounded';
+    const args = !isUnbounded && bound.expr
+        ? [
+            numericLiteral(bound.expr.value),
+        ]
+        : [];
     
     return callExpression(identifier(name), args);
 };
@@ -215,8 +218,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);
@@ -234,13 +239,16 @@ 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(({type}) => type === 'select_distinct_on'))
+    if (!modifiers.some(isSelectDistinctOn))
         return null;
     
-    const modifier = modifiers.find(({type}) => type === 'select_distinct_on');
+    const modifier = modifiers.find(isSelectDistinctOn);
     const onCols = [];
     
     for (const item of modifier.columns.expr.items) {
@@ -305,6 +313,9 @@ export const convertSelect = ({clauses}) => {
     ].filter(Boolean);
     
     if (!fromClause) {
+        if (whereClause)
+            args.push(convertWhere(whereClause));
+        
         if (limitClause)
             args.push(convertLimit(limitClause));