fix: v0.7.3 数据正确性与边界窗口收尾 — INSERT 语句级原子（三引擎+Aria PK 批内重复）/ 索引列 IS NULL 恒空 / delete RESTRICT 破坏索引 / queryStream 子查询静默空结果 / ALTER DROP 索引残留 / UNIQUE INDEX 存量校验 / SELECT * 别名投影 / WAL BEGIN/ROLLBACK 事务边界 / aria $in 与级联重复扫描性能 / $and 等值下推 / ANALYZE 索引统计 / React-Vue hooks 生命周期 / 迁移主键兜底 + 58 回归

dist/metona-sqlark.cjs

@@ -34,7 +34,7 @@ class DatabaseError extends Error {
 // ---------------------------------------------------------------------------
 //  版本
 // ---------------------------------------------------------------------------
-const VERSION = '0.7.2';
+const VERSION = '0.7.3';
 
 /**
  * metona-sqlark Shared WHERE Matcher — 统一的条件匹配逻辑
@@ -439,6 +439,11 @@ class MemoryEngine {
         if (!schema.columns[column.name]) {
             throw new DatabaseError(`Column "${column.name}" does not exist in table "${tableName}"`, 'COLUMN_NOT_FOUND');
         }
+        // v0.7.3: 被删列是索引列 → 同步清理索引 Map —— 此前残留旧索引：
+        // 查询已删列仍走旧索引（不含新行）→ 结果不完整（对齐 AriaEngine cleanupTableIndexes）
+        if (schema.columns[column.name].index || schema.columns[column.name].unique) {
+            this.indexes.get(tableName)?.delete(column.name);
+        }
         delete schema.columns[column.name];
         // 清理已有行中该列的值（find 返回行引用，直接删除生效）
         const table = this.tables.get(tableName);
@@ -454,18 +459,42 @@ class MemoryEngine {
         const table = this.tables.get(tableName);
         const pkColumn = this.getPrimaryKey(schema);
         const pks = [];
+        // v0.7.3: 语句级原子性 —— 两阶段（先全量预检，后执行）。
+        // 此前逐行"校验+写入"：第 N 行主键重复/唯一冲突抛错时，前 N-1 行已提交
+        // （无事务下语句级部分提交，与 v0.7.2 修复的 UPDATE 同类问题）。
+        const validated = [];
+        const pkSet = new Set();
+        const batchUnique = new Map();
+        // 阶段 1：全量预检（任何一行失败 → 整条语句不执行）
         for (const row of rows) {
             const validatedRow = this.validateRow(schema, row);
             const pkValue = String(validatedRow[pkColumn]);
-            if (table.has(pkValue))
+            // 批内主键互查（内存表尚未反映本批写入）
+            if (table.has(pkValue) || pkSet.has(pkValue)) {
                 throw new DatabaseError(`Duplicate primary key "${pkValue}" in table "${tableName}"`, 'DUPLICATE_KEY');
-            this.checkUniqueness(schema, validatedRow);
+            }
+            pkSet.add(pkValue);
+            // v0.7.3: 批内唯一互查 + 索引查（此前两行同批写入同一唯一值时，
+            // 第一行已写入索引 → 第二行 checkUniqueness 抛错 → 第一行残留）
+            this.checkInsertUniqueness(schema, tableName, validatedRow, batchUnique);
+            validated.push(validatedRow);
+        }
+        // 阶段 2：执行（预检已通过，此阶段不再抛校验类错误）
+        for (const validatedRow of validated) {
+            const pkValue = String(validatedRow[pkColumn]);
             table.set(pkValue, validatedRow);
             this.updateIndexes(tableName, validatedRow, pkValue);
             pks.push(pkValue);
         }
         return pks;
     }
+    /** v0.7.3: 按主键取已验证行（KVStoreEngine 持久化 validated 行用，含 default/类型归一） */
+    getRow(tableName, pkValue) {
+        const table = this.tables.get(tableName);
+        if (!table)
+            return null;
+        return table.get(pkValue) ?? null;
+    }
     async find(tableName, query) {
         this.ensureTable(tableName);
         const table = this.tables.get(tableName);
@@ -558,7 +587,37 @@ class MemoryEngine {
         return count;
     }
     /**
-     * v0.7.2: 更新唯一性预检 — 批内互查（多条行更新到同一唯一值）+ 索引查
+     * v0.7.3: 插入唯一性预检 —— 批内互查（本批前几行写入同一唯一值）
+     * + 索引查（表中已有行）。与 update 的 checkUpdateUniqueness 对称，
+     * 两阶段 insert 预检阶段调用（索引尚未反映本批写入）。
+     */
+    checkInsertUniqueness(schema, tableName, row, batchUnique) {
+        const tableIndexes = this.indexes.get(tableName);
+        for (const [colName, colDef] of Object.entries(schema.columns)) {
+            if (!colDef.unique)
+                continue;
+            const value = row[colName];
+            if (value === undefined || value === null)
+                continue;
+            let seen = batchUnique.get(colName);
+            if (!seen) {
+                seen = new Set();
+                batchUnique.set(colName, seen);
+            }
+            if (seen.has(value)) {
+                throw new DatabaseError(`Unique constraint violation on column "${colName}" in table "${schema.name}"`, 'UNIQUE_VIOLATION');
+            }
+            seen.add(value);
+            if (!tableIndexes)
+                continue;
+            const colIndex = tableIndexes.get(colName);
+            if (colIndex && colIndex.has(value)) {
+                throw new DatabaseError(`Unique constraint violation on column "${colName}" in table "${schema.name}"`, 'UNIQUE_VIOLATION');
+            }
+        }
+    }
+    /**
+     * v0.7.3: 更新唯一性预检 — 批内互查（多条行更新到同一唯一值）+ 索引查
      * （排除自身旧条目）。阶段 1 中索引尚未更新，批内互查避免"两行同时改到
      * 同一新值"绕过唯一约束。
      */
@@ -628,30 +687,11 @@ class MemoryEngine {
     /**
      * v0.4.2-fix: ON UPDATE 外键级联 — 被引用表主键变更时处理引用表：
      * RESTRICT 抛错 / CASCADE 更新 FK 值 / SET NULL 置空。
-     * 分两阶段：先全量 RESTRICT 检查（任何修改前），再执行级联（防部分修改）。
+     * v0.7.3-perf: 删除冗余的阶段 1 RESTRICT 扫描 —— checkUpdateRestrict 已在
+     * 两阶段 update 预检（阶段 1b）覆盖 RESTRICT 与 SET NULL+required，
+     * 此处任何修改前重复全表扫描纯属浪费。直接执行 CASCADE / SET NULL。
      */
     async applyUpdateCascade(tableName, oldPk, newPk) {
-        // 阶段 1: RESTRICT 检查（引用旧主键的行存在即拒绝）
-        for (const [refTableName, refSchema] of this.schemas) {
-            if (refTableName === tableName)
-                continue;
-            for (const [colName, colDef] of Object.entries(refSchema.columns)) {
-                if (!colDef.references || !colDef.onUpdate)
-                    continue;
-                const [refTable] = colDef.references.split('.');
-                if (refTable !== tableName)
-                    continue;
-                const refTableData = this.tables.get(refTableName);
-                if (!refTableData)
-                    continue;
-                for (const [, refRow] of refTableData) {
-                    if (String(refRow[colName]) === oldPk && colDef.onUpdate === 'RESTRICT') {
-                        throw new DatabaseError(`Cannot update "${tableName}" key "${oldPk}": foreign key "${colName}" in "${refTableName}" has dependent rows`, 'FOREIGN_KEY_VIOLATION');
-                    }
-                }
-            }
-        }
-        // 阶段 2: CASCADE / SET NULL
         for (const [refTableName, refSchema] of this.schemas) {
             if (refTableName === tableName)
                 continue;
@@ -682,28 +722,27 @@ class MemoryEngine {
         const toDelete = [];
         for (const [pk, row] of table) {
             if (!query.where || Object.keys(query.where).length === 0 || matchWhere(row, query.where)) {
-                // v0.3.3: 删除行前清理其索引条目（修复删除后索引残留）
-                this.removeIndexEntries(tableName, row, pk);
-                toDelete.push(pk);
+                toDelete.push({ pk, row });
             }
         }
         // v0.6.3-fix: 级联两阶段 —— 先对全部待删行做 RESTRICT 预检（沿 CASCADE 链递归），
         // 任何一行违规则整体拒绝。此前逐行执行：第 N 行 RESTRICT 抛错时，前 N-1 行的
         // 级联子行已被删除、父行未删 → 无事务下部分级联（数据不一致）
+        //
+        // v0.7.3-fix: 索引清理移到预检之后 —— 此前 removeIndexEntries 在收集阶段执行，
+        // RESTRICT 预检抛错时行未删但索引条目已删 → 唯一约束失效、索引查询丢行
         const restrictVisited = new Set();
-        for (const pk of toDelete) {
-            const row = table.get(pk);
-            if (row)
-                this.checkCascadeRestrict(tableName, pk, restrictVisited);
+        for (const { pk } of toDelete) {
+            this.checkCascadeRestrict(tableName, pk, restrictVisited);
         }
-        // 级联删除：检查引用此表的其他表（RESTRICT 已预检通过，此阶段不再抛错）
+        // 预检通过：清理索引 + 级联删除（此阶段不再抛校验类错误）
         let cascadeCount = 0;
-        for (const pk of toDelete) {
-            const row = table.get(pk);
-            if (row)
-                cascadeCount += await this.cascadeDelete(tableName, pk, row);
+        for (const { pk, row } of toDelete) {
+            // v0.3.3: 删除行前清理其索引条目（修复删除后索引残留）
+            this.removeIndexEntries(tableName, row, pk);
+            cascadeCount += await this.cascadeDelete(tableName, pk, row);
         }
-        for (const pk of toDelete)
+        for (const { pk } of toDelete)
             table.delete(pk);
         return toDelete.length + cascadeCount;
     }
@@ -782,22 +821,34 @@ class MemoryEngine {
             throw new DatabaseError(`Column "${column}" does not exist in table "${tableName}"`, 'COLUMN_NOT_FOUND');
         if (colDef.index || colDef.unique)
             return; // 已存在
-        colDef.index = true;
-        if (unique)
-            colDef.unique = true;
         const tableIndexes = this.indexes.get(tableName);
         if (!tableIndexes.has(column))
             tableIndexes.set(column, new Map());
         const colIndex = tableIndexes.get(column);
         const table = this.tables.get(tableName);
-        for (const [pk, row] of table) {
-            const value = row[column];
-            if (value !== undefined && value !== null) {
-                if (!colIndex.has(value))
-                    colIndex.set(value, new Set());
-                colIndex.get(value).add(pk);
+        try {
+            for (const [pk, row] of table) {
+                const value = row[column];
+                if (value !== undefined && value !== null) {
+                    // v0.7.3: UNIQUE 索引回填校验存量唯一性 —— 此前重复数据静默建索引
+                    // （SQLite 语义应报错），且此后该列唯一约束永远无法满足
+                    if (unique && colIndex.has(value)) {
+                        throw new DatabaseError(`Unique index on column "${column}" in table "${tableName}" cannot be created: duplicate value "${String(value)}"`, 'UNIQUE_VIOLATION');
+                    }
+                    if (!colIndex.has(value))
+                        colIndex.set(value, new Set());
+                    colIndex.get(value).add(pk);
+                }
             }
         }
+        catch (error) {
+            // 回填失败（唯一冲突）：清理半初始化索引，标志未落，保持原子语义
+            tableIndexes.delete(column);
+            throw error;
+        }
+        colDef.index = true;
+        if (unique)
+            colDef.unique = true;
     }
     async dropIndex(tableName, column, _indexName) {
         // v0.7.2: 同 createIndex —— 列级标志修改无法通过事务快照回滚，显式拒绝
@@ -920,26 +971,30 @@ class MemoryEngine {
                 break;
         }
     }
-    /** O(1) 唯一性检查：利用哈希索引 */
-    checkUniqueness(schema, row) {
-        const tableIndexes = this.indexes.get(schema.name);
-        if (!tableIndexes)
-            return;
-        for (const [colName, colDef] of Object.entries(schema.columns)) {
-            if (!colDef.unique || row[colName] === undefined || row[colName] === null)
-                continue;
-            const colIndex = tableIndexes.get(colName);
-            if (colIndex && colIndex.has(row[colName])) {
-                throw new DatabaseError(`Unique constraint violation on column "${colName}" in table "${schema.name}"`, 'UNIQUE_VIOLATION');
-            }
-        }
-    }
     /** 索引查找 */
     tryIndexLookup(tableName, table, query) {
         const tableIndexes = this.indexes.get(tableName);
         if (!tableIndexes || !query.where)
             return Array.from(table.values());
-        for (const [col, condition] of Object.entries(query.where)) {
+        // v0.7.3: 递归展开 $and 中的等值条件 —— 此前仅顶层键，
+        // `WHERE a AND b`（解析为顶层 $and）永远全表扫描，索引形同虚设。
+        // $or/$not 语义不适用单索引下推，保守跳过。命中索引后 find 仍以
+        // 全条件 matchWhere 过滤（子集语义安全）。
+        const flat = [];
+        const collect = (w) => {
+            for (const [k, v] of Object.entries(w)) {
+                if (k === '$and') {
+                    for (const sub of v)
+                        collect(sub);
+                    continue;
+                }
+                if (k === '$or' || k === '$not')
+                    continue;
+                flat.push([k, v]);
+            }
+        };
+        collect(query.where);
+        for (const [col, condition] of flat) {
             // v0.4.1: 支持 { $eq: value } 形式（SQL 解析器生成的等值条件）走索引
             let targetValue;
             if (typeof condition !== 'object' || condition === null) {
@@ -951,6 +1006,11 @@ class MemoryEngine {
             else {
                 continue;
             }
+            // v0.7.3: null/undefined 条件不走索引 —— 索引不含 null 条目，
+            // colIndex.get(null) 恒 undefined → return [] 短路全表扫描 → 索引列
+            // IS NULL 恒空（对齐 AriaEngine v0.6.2 修复）
+            if (targetValue === null || targetValue === undefined)
+                continue;
             const colIndex = tableIndexes.get(col);
             if (colIndex) {
                 const pks = colIndex.get(targetValue);
@@ -2297,11 +2357,14 @@ class KVStoreEngine {
         const schema = await this.memory.getTableSchema(tableName);
         if (!schema)
             throw new DatabaseError(`Table "${tableName}" does not exist`, 'TABLE_NOT_FOUND');
-        const pkCol = this.getPK(schema);
+        // v0.7.3: 持久化内存中的 validated 行（含 default 值/类型归一/列投影）——
+        // 此前写原始入参 row：default 不落盘、schema 外列被持久化，重启后行不一致
         const puts = {};
-        rows.forEach((row, i) => {
-            puts[this.rowKey(tableName, String(pks[i] ?? row[pkCol]))] = enc(JSON.stringify(row));
-        });
+        for (const pk of pks) {
+            const row = this.memory.getRow(tableName, pk);
+            if (row)
+                puts[this.rowKey(tableName, pk)] = enc(JSON.stringify(row));
+        }
         await this.kv.putMany(puts);
         return pks;
     }
@@ -4910,7 +4973,8 @@ class WAL {
                 const computedNew = crc32(recordBytes);
                 const computedLegacy = this.legacyChecksum(recordBytes);
                 if ((computedNew >>> 0) !== storedCrc && (computedLegacy >>> 0) !== storedCrc) {
-                    // CRC 不匹配，跳过此损坏记录
+                    // CRC 不匹配，跳过此损坏记录（长度字段链完整时后续好记录仍可恢复，
+                    // 行为由 aria-wal-crc 测试锁定）
                     // eslint-disable-next-line no-console
                     console.warn(`[AriaEngine WAL] CRC mismatch at record LSN=${lsn}, skipping`);
                     continue;
@@ -6875,6 +6939,22 @@ class AriaEngine {
             validatedRows.push({ row: validated, pkValue, key: `${tableName}:${pkValue}` });
         }
         await this.lsm.prefetchKeys(validatedRows.map((v) => v.key));
+        // v0.7.3: 主键批内互查 + 预检 —— 此前 PK 重复检查在写入循环内：
+        // 第 N 行重复抛错时，前 N-1 行已 put LSM 且其 WAL 记录随 appendBatch 一起
+        // 丢失 → 语句级部分提交 + 内存/WAL 不一致（与 v0.6.2 的 unique 预检同一阶段）。
+        const pkSet = new Set();
+        for (const { pkValue, key } of validatedRows) {
+            if (pkSet.has(pkValue)) {
+                throw new DatabaseError(`Duplicate primary key "${pkValue}" in table "${tableName}"`, 'DUPLICATE_KEY');
+            }
+            pkSet.add(pkValue);
+            const existing = this.currentTxnId
+                ? (this.txnSnapshot?.get(key) ?? this.lsm.get(key))
+                : this.lsm.get(key);
+            if (existing && !existing.__txn_deleted) {
+                throw new DatabaseError(`Duplicate primary key "${pkValue}" in table "${tableName}"`, 'DUPLICATE_KEY');
+            }
+        }
         // v0.6.2: 唯一约束 — 批量预加载本批唯一列涉及的索引范围（一次 drainChain）
         for (const colName of uniqueCols) {
             const idxLsm = this.secondaryIndexes.get(`${tableName}:idx:${colName}`);
@@ -6909,13 +6989,7 @@ class AriaEngine {
             }
         }
         for (const { row: validated, pkValue, key } of validatedRows) {
-            // Check duplicate in LSM + transaction snapshot
-            const existing = this.currentTxnId
-                ? (this.txnSnapshot?.get(key) ?? this.lsm.get(key))
-                : this.lsm.get(key);
-            if (existing && !existing.__txn_deleted) {
-                throw new DatabaseError(`Duplicate primary key "${pkValue}" in table "${tableName}"`, 'DUPLICATE_KEY');
-            }
+            // PK 重复已在批预检阶段检查（v0.7.3），此处不再重复查询
             if (this.currentTxnId && this.txnSnapshot) {
                 // Within transaction: buffer to snapshot + MVCC version chain
                 this.txnSnapshot.set(key, validated);
@@ -7153,25 +7227,9 @@ class AriaEngine {
         if (visited.has(visitKey))
             return;
         visited.add(visitKey);
-        // 阶段 1: RESTRICT 检查
-        for (const [refTableName, refSchema] of this.schemas) {
-            if (refTableName === tableName)
-                continue;
-            for (const [colName, colDef] of Object.entries(refSchema.columns)) {
-                if (!colDef.references || !colDef.onUpdate)
-                    continue;
-                const [refTable] = colDef.references.split('.');
-                if (refTable !== tableName)
-                    continue;
-                if (colDef.onUpdate !== 'RESTRICT')
-                    continue;
-                const refRows = await this.getAllRows(refTableName);
-                if (refRows.some((r) => String(r[colName]) === oldPk)) {
-                    throw new DatabaseError(`Cannot update "${tableName}" key "${oldPk}": foreign key "${colName}" in "${refTableName}" has dependent rows`, 'FOREIGN_KEY_VIOLATION');
-                }
-            }
-        }
-        // 阶段 2: CASCADE / SET NULL
+        // v0.7.3-perf: 删除冗余的阶段 1 RESTRICT 扫描 —— checkForeignKeyUpdateRestrict
+        // 已在两阶段 update 预检（阶段 1b）覆盖 RESTRICT 与 SET NULL+required，
+        // 此处任何修改前重复全表扫描纯属浪费。直接执行 CASCADE / SET NULL。
         for (const [refTableName, refSchema] of this.schemas) {
             if (refTableName === tableName)
                 continue;
@@ -7554,9 +7612,6 @@ class AriaEngine {
         // 但索引 LSM 未恢复 → 此前静默 return 导致索引永久缺失）
         if (this.secondaryIndexes.has(idxKey))
             return;
-        colDef.index = true;
-        if (unique)
-            colDef.unique = true;
         const idxLsm = new LSM({
             memtableSizeThreshold: this.config.memtableSizeThreshold,
             levelSizeMultiplier: this.config.levelSizeMultiplier,
@@ -7567,16 +7622,38 @@ class AriaEngine {
         });
         await idxLsm.init();
         this.secondaryIndexes.set(idxKey, idxLsm);
-        // 从主 LSM 重建索引数据
-        const pkCol = this.tablePKs.get(tableName);
-        const rows = await this.getAllRows(tableName);
-        for (const row of rows) {
-            const value = row[column];
-            if (value !== undefined && value !== null) {
-                idxLsm.put(`${String(value)}:${row[pkCol]}`, { pk: row[pkCol] });
+        try {
+            // 从主 LSM 重建索引数据
+            const pkCol = this.tablePKs.get(tableName);
+            const rows = await this.getAllRows(tableName);
+            const seen = new Set();
+            for (const row of rows) {
+                const value = row[column];
+                if (value !== undefined && value !== null) {
+                    const v = String(value);
+                    // v0.7.3: UNIQUE 索引回填校验存量唯一性 —— 此前重复数据静默建索引
+                    // （SQLite 语义应报错），与 MemoryEngine 对齐
+                    if (unique && seen.has(v)) {
+                        throw new DatabaseError(`Unique index on column "${column}" in table "${tableName}" cannot be created: duplicate value "${v}"`, 'UNIQUE_VIOLATION');
+                    }
+                    seen.add(v);
+                    idxLsm.put(`${v}:${row[pkCol]}`, { pk: row[pkCol] });
+                }
             }
+            await idxLsm.flush();
         }
-        await idxLsm.flush();
+        catch (error) {
+            // 回填失败（唯一冲突）：清理半初始化索引（内存 + 存储），标志未落，保持原子语义
+            this.secondaryIndexes.delete(idxKey);
+            try {
+                await idxLsm.clear();
+            }
+            catch { /* 清理失败不阻塞 */ }
+            throw error;
+        }
+        colDef.index = true;
+        if (unique)
+            colDef.unique = true;
         await this.persistSchemas();
     }
     async dropIndex(tableName, column, _indexName) {
@@ -7613,12 +7690,23 @@ class AriaEngine {
             throw new DatabaseError('Transaction already in progress', 'TX_ACTIVE');
         this.currentTxnId = this.mvcc.beginTransaction();
         this.txnSnapshot = new Map();
-        await this.wal.append({
-            type: WALRecordType.BEGIN,
-            txnId: this.currentTxnId,
-            tableName: '',
-            key: '',
-        });
+        // v0.7.3-fix: WAL BEGIN 写失败回滚内存事务状态 —— 此前 append 抛错（full 模式）
+        // 时 currentTxnId 已设置 → TX_ACTIVE 永久泄漏（后续无法开始新事务）。
+        // 回滚 mvcc 登记 + 快照后重抛，调用方可重试。
+        try {
+            await this.wal.append({
+                type: WALRecordType.BEGIN,
+                txnId: this.currentTxnId,
+                tableName: '',
+                key: '',
+            });
+        }
+        catch (error) {
+            this.mvcc.rollbackTransaction(this.currentTxnId);
+            this.currentTxnId = null;
+            this.txnSnapshot = null;
+            throw error;
+        }
     }
     async commitTransaction() {
         if (!this.currentTxnId)
@@ -7650,6 +7738,18 @@ class AriaEngine {
     async rollbackTransaction() {
         if (!this.currentTxnId)
             throw new DatabaseError('No active transaction', 'TX_NONE');
+        const txnId = this.currentTxnId;
+        // v0.7.3-fix: 先持久化 WAL ROLLBACK，再回滚内存 —— 与 commitTransaction 的
+        // "WAL 领先内存"（v0.4.3-fix）对齐。此前内存先回滚、ROLLBACK 记录后写：
+        // full 模式写失败时崩溃重放无 ROLLBACK 记录 → 已回滚事务的数据复活。
+        // 现在写失败 → 内存未回滚、事务仍活跃（调用方可重试），崩溃后重放
+        // 看到 ROLLBACK 记录同样不会复活数据。
+        await this.wal.append({
+            type: WALRecordType.ROLLBACK,
+            txnId,
+            tableName: '',
+            key: '',
+        });
         // v0.3.3: 记录事务涉及的表（用于回滚后重建索引，消除索引残留）
         const affectedTables = new Set();
         if (this.txnSnapshot) {
@@ -7659,14 +7759,8 @@ class AriaEngine {
                     affectedTables.add(key.slice(0, idx));
             }
         }
-        this.mvcc.rollbackTransaction(this.currentTxnId);
+        this.mvcc.rollbackTransaction(txnId);
         this.txnSnapshot = null;
-        await this.wal.append({
-            type: WALRecordType.ROLLBACK,
-            txnId: this.currentTxnId,
-            tableName: '',
-            key: '',
-        });
         this.currentTxnId = null;
         // v0.3.3: 事务内直接写入了二级索引 LSM，回滚后全量重建受影响表的索引
         for (const tableName of affectedTables) {
@@ -8084,10 +8178,25 @@ class AriaEngine {
         if (!schema)
             return null;
         const pkCol = this.tablePKs.get(tableName);
-        for (const [col, condition] of Object.entries(query.where)) {
-            // 跳过 $and/$or/$not 逻辑组合
-            if (col === '$and' || col === '$or' || col === '$not')
-                continue;
+        // v0.7.3: 递归展开 $and 中的等值条件 —— 此前仅顶层键，
+        // `WHERE a AND b`（解析为顶层 $and）永远全表扫描，索引形同虚设。
+        // $or/$not 语义不适用单索引下推，保守跳过。命中索引后 find 仍以
+        // 全条件 matchWhere 过滤（子集语义安全）。
+        const flat = [];
+        const collect = (w) => {
+            for (const [k, v] of Object.entries(w)) {
+                if (k === '$and') {
+                    for (const sub of v)
+                        collect(sub);
+                    continue;
+                }
+                if (k === '$or' || k === '$not' || k === '$exists')
+                    continue;
+                flat.push([k, v]);
+            }
+        };
+        collect(query.where);
+        for (const [col, condition] of flat) {
             const colDef = schema.columns[col];
             const hasIndex = colDef && (colDef.index || colDef.unique || colDef.primaryKey);
             if (!hasIndex && col !== pkCol)
@@ -8165,18 +8274,31 @@ class AriaEngine {
                 // v0.6.2-fix(P1): IN 列表含 null 不走索引（索引不含 null 条目，会漏匹配 null 行）
                 if (c.$in.some((v) => v === null))
                     continue;
+                // v0.7.3-perf: 批级预加载全部值的索引范围 + 主表行（各一次 drainChain）——
+                // 此前逐值 indexScanToRows：每个值一次 prefetchRange + prefetchKeys，
+                // 后台 compaction 长耗时时 N 倍放大（与 v0.6.1 修的 insert 批量预加载
+                // 性能悬崖同类）。批级预加载后循环内同步 rangeScan/get。
+                const values = c.$in.map((v) => String(v));
+                await idxLsm.prefetchPrefixRanges(values.map((v) => [v, `${v}\uffff`]));
                 const results = [];
                 const seenPks = new Set(); // v0.4.1: IN 值可能重复，按 pk 去重
-                for (const val of c.$in) {
-                    const rows = await this.indexScanToRows(tableName, pkCol, idxLsm, String(val), String(val));
-                    for (const row of rows) {
-                        const pk = String(row[pkCol]);
-                        if (!seenPks.has(pk)) {
+                const pks = [];
+                for (const val of values) {
+                    const entries = idxLsm.rangeScan(val, `${val}\uffff`);
+                    for (const [, idxEntry] of entries) {
+                        const pk = idxEntry.pk;
+                        if (pk && !seenPks.has(pk)) {
                             seenPks.add(pk);
-                            results.push(row);
+                            pks.push(pk);
                         }
                     }
                 }
+                await this.lsm.prefetchKeys(pks.map((pk) => `${tableName}:${pk}`));
+                for (const pk of pks) {
+                    const row = this.lsm.get(`${tableName}:${pk}`);
+                    if (row)
+                        results.push({ ...row, [pkCol]: pk });
+                }
                 return results;
             }
             // $gt / $gte / $lt / $lte → 范围扫描
@@ -8240,10 +8362,6 @@ class AriaEngine {
             this.mvcc.gc(50);
         }
     }
-    /** 估算 WAL 大小（字节） */
-    getWALEstimatedSize() {
-        return this.wal.getBufferedCount() * 200; // 粗略估算每条 ~200B
-    }
     /**
      * ANALYZE: 收集表统计信息
      * 返回行数、平均行大小、索引深度等
@@ -8252,15 +8370,28 @@ class AriaEngine {
         this.ensureOpen();
         this.ensureTable(tableName);
         const rows = await this.getAllRows(tableName);
+        // v0.7.3: 统计汇总主 LSM + 该表全部二级索引 LSM —— 此前只统计主 LSM，
+        // 表带多个索引时索引深度/SSTable 数量严重低估
+        let sstableCount = this.lsm.getStats().sstableCount;
+        let memtableSize = this.lsm.getStats().memtableSize;
+        let indexDepth = this.lsm.getStats().levelCounts.filter((c) => c > 0).length;
+        for (const [idxKey, idxLsm] of this.secondaryIndexes) {
+            if (!idxKey.startsWith(`${tableName}:idx:`))
+                continue;
+            const s = idxLsm.getStats();
+            sstableCount += s.sstableCount;
+            memtableSize += s.memtableSize;
+            indexDepth = Math.max(indexDepth, s.levelCounts.filter((c) => c > 0).length);
+        }
         const stats = {
             table: tableName,
             rowCount: rows.length,
             avgRowSize: rows.length > 0
                 ? Math.round(rows.reduce((s, r) => s + JSON.stringify(r).length, 0) / rows.length)
                 : 0,
-            indexDepth: this.lsm.getStats().levelCounts.filter((c) => c > 0).length,
-            sstableCount: this.lsm.getStats().sstableCount,
-            memtableSize: this.lsm.getStats().memtableSize,
+            indexDepth,
+            sstableCount,
+            memtableSize,
             estimatedMemory: this.lsm.getEstimatedMemory(),
         };
         // 列基数统计
@@ -9602,6 +9733,12 @@ class Parser {
         if (this.curTokenIs(TokenType.STAR)) {
             columns.push('*');
             this.nextToken();
+            // v0.7.3: `SELECT *, col [AS alias], ...` —— '*' 后可继续列列表
+            // （此前 '*' 独占分支，逗号后直接 PARSE_ERROR；executor 侧投影已支持混合）
+            while (this.curTokenIs(TokenType.COMMA)) {
+                this.nextToken();
+                columns.push(this.parseColumnWithAlias());
+            }
         }
         else {
             columns.push(...this.parseColumnList());
@@ -10727,26 +10864,36 @@ class QueryExecutor {
         catch { /* 非查询语句无 QueryPlan */ }
         // v0.7.0: 真实索引命中信息（此前 usingIndex 恒为 'auto' 占位）。
         // 引擎无关启发式：WHERE 中存在主键/索引/唯一列条件 → 对应引擎索引路径。
+        // v0.7.3: 递归识别 $and 嵌套等值条件（与 Memory/Aria 的 $and 下推行为对齐；
+        // $or/$not 不下推，保持 none）。
         let usingIndex = plan?.table ? 'none' : 'none';
         if (plan && plan.table && plan.where && Object.keys(plan.where).length > 0) {
             try {
                 const schema = await this.engine.getTableSchema(plan.table);
                 if (schema) {
-                    for (const col of Object.keys(plan.where)) {
-                        if (col.startsWith('$'))
-                            continue;
-                        const colDef = schema.columns[col];
-                        if (!colDef)
-                            continue;
-                        if (colDef.primaryKey) {
-                            usingIndex = 'pk';
-                            break;
+                    const findIndex = (w) => {
+                        for (const [k, v] of Object.entries(w)) {
+                            if (k === '$and') {
+                                for (const sub of v) {
+                                    const hit = findIndex(sub);
+                                    if (hit)
+                                        return hit;
+                                }
+                                continue;
+                            }
+                            if (k === '$or' || k === '$not')
+                                continue;
+                            const colDef = schema.columns[k];
+                            if (!colDef)
+                                continue;
+                            if (colDef.primaryKey)
+                                return 'pk';
+                            if (colDef.index || colDef.unique)
+                                return `index:${k}`;
                         }
-                        if (colDef.index || colDef.unique) {
-                            usingIndex = `index:${col}`;
-                            break;
-                        }
-                    }
+                        return null;
+                    };
+                    usingIndex = findIndex(plan.where) ?? 'none';
                 }
             }
             catch { /* schema 读取失败保持 none */ }
@@ -10877,7 +11024,11 @@ class QueryExecutor {
         }
         if (stmt.orderBy && stmt.orderBy.length > 0)
             rows = applyOrderBy(rows, stmt.orderBy);
-        if (!hasGroupBy && !hasAggregate && stmt.columns.length > 0 && stmt.columns[0] !== '*') {
+        // v0.7.3: `SELECT *, col AS alias` —— 此前 columns[0]==='*' 直接不投影，
+        // 别名列/常量列丢失。仅当 '*' 是唯一列时跳过投影（projectRow 对裸 '*'
+        // 合并原行全部列，其余表达式覆盖/追加）
+        if (!hasGroupBy && !hasAggregate && stmt.columns.length > 0
+            && !(stmt.columns.length === 1 && stmt.columns[0] === '*')) {
             rows = rows.map((row) => this.projectRow(row, stmt.columns));
         }
         // v0.3.3: ORDER BY 别名 → 投影后才存在，需在投影后重新排序
@@ -11447,9 +11598,13 @@ class QueryExecutor {
         const aliasCols = [];
         const caseCols = [];
         const constCols = [];
+        // v0.7.3: 裸 '*' 与列表达式混合（SELECT *, name AS nick）→ 原行全部列为基
+        let hasStar = false;
         for (const col of columns) {
-            if (col === '*')
+            if (col === '*') {
+                hasStar = true;
                 continue;
+            }
             const expr = parseCaseExpression(col);
             if (expr) {
                 caseCols.push({ alias: expr.alias ?? col, expr });
@@ -11463,20 +11618,26 @@ class QueryExecutor {
             // v0.4.0: 字符串常量列 SELECT 'lit' → 常量输出
             const lit = col.match(/^'(.*)'$/s);
             if (lit) {
-                const value = lit[1].replace(/\\'/g, "'");
+                // v0.7.3: SQL 标准 '' 转义还原（readString 已把 '' 合并为单个 '，
+                // 打包回列的文本中相邻两个 ' 即一个引号字面量）
+                const value = lit[1].replace(/''/g, "'");
                 constCols.push({ key: col, value });
                 continue;
             }
             plain.push(col);
         }
-        const projected = plain.length > 0 ? projectColumns(row, plain) : {};
+        // v0.7.3: hasStar 时以原行全部列为基（projectColumns 仅投影 plain 列，不含 * 的其余列）
+        const projected = hasStar
+            ? { ...row }
+            : (plain.length > 0 ? projectColumns(row, plain) : {});
         for (const { alias, source } of aliasCols) {
             if (source === '*') {
                 Object.assign(projected, row);
             }
             else {
                 const lit = source.match(/^'(.*)'$/s);
-                projected[alias] = lit ? lit[1].replace(/\\'/g, "'") : row[source];
+                // v0.7.3: 同 constCols —— SQL 标准 '' 转义还原
+                projected[alias] = lit ? lit[1].replace(/''/g, "'") : row[source];
             }
         }
         for (const { key, value } of constCols) {
@@ -12348,9 +12509,41 @@ class MetonaSqlark {
         const select = stmt;
         // 不可流式场景：JOIN / GROUP BY / HAVING / DISTINCT / 聚合 / UNION / 关联子查询 / ORDER BY
         const aggregate = select.columns.some((c) => /^(COUNT|SUM|AVG|MIN|MAX)\(/i.test(c));
+        // v0.7.3: WHERE 含子查询（$subquery / $exists / 嵌套 $col 列引用）不可流式 ——
+        // 引擎层 matchWhere 的 $in/$nin 遇未解析的 $subquery 对象返回 false → 所有行
+        // 被静默过滤（空结果）；$col 操作符无对应匹配分支会抛 QUERY_ERROR。
+        // 递归检测后回退物化路径（resolveSubqueries 正确解析）。
+        const hasSubquery = (where) => {
+            if (!where)
+                return false;
+            for (const [k, v] of Object.entries(where)) {
+                if (k === '$and' || k === '$or') {
+                    if (v.some((sub) => hasSubquery(sub)))
+                        return true;
+                    continue;
+                }
+                if (k === '$not') {
+                    if (hasSubquery(v))
+                        return true;
+                    continue;
+                }
+                if (k === '$exists')
+                    return true;
+                if (typeof v === 'object' && v !== null) {
+                    for (const [, operand] of Object.entries(v)) {
+                        if (typeof operand === 'object' && operand !== null) {
+                            const ops = operand;
+                            if ('$subquery' in ops || '$col' in ops)
+                                return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        };
         const streamable = !select.joins && !select.groupBy && !select.having && !select.distinct
             && !aggregate && !(select.orderBy && select.orderBy.length > 0)
-            && !(select.where && select.where['$exists'] !== undefined);
+            && !hasSubquery(select.where);
         if (streamable && typeof this.engine.findStream === 'function') {
             // 用户回调为 async（返回 Promise）时引擎同步扫描无法 await → 回退物化
             const isAsync = onRow.constructor?.name === 'AsyncFunction';
@@ -12507,9 +12700,20 @@ class MetonaSqlark {
     async triggerStatementHooks(stmt, phase, result) {
         switch (stmt.type) {
             case 'INSERT': {
+                // v0.7.3: 列映射对齐 executor —— 省略列名时按 schema 列顺序映射
+                // （此前用数字键 String(i)，与 executor 写入的真实行键不一致）
+                let cols = stmt.columns ?? [];
+                if (cols.length === 0) {
+                    try {
+                        const schema = await this.engine.getTableSchema(stmt.into);
+                        cols = schema ? Object.keys(schema.columns) : [];
+                    }
+                    catch {
+                        cols = [];
+                    }
+                }
                 const rows = (stmt.values ?? []).map((vals) => {
                     const row = {};
-                    const cols = stmt.columns ?? [];
                     for (let i = 0; i < vals.length; i++) {
                         row[cols[i] ?? String(i)] = vals[i];
                     }