@poe-platform/safe-bash 0.1.803 → 0.1.804

package/dist/safe-bash-command-sqlite3/index.js

@@ -2472,6 +2472,50 @@ var SqliteDatabase = class {
       indexRows
     });
   }
+  bulkImportRows(tableName, rows) {
+    const tbl = this.findTable(tableName);
+    if (!tbl) return false;
+    const lowerTbl = tbl.name.toLowerCase();
+    const hasTriggers = Array.from(this.triggers.values()).some((tr) => tr.tableName.toLowerCase() === lowerTbl);
+    const hasComplexCols = tbl.columns.some(
+      (c) => Boolean(c.checkExpr || c.generatedExpr || c.primaryKey && c.type.toUpperCase() === "INTEGER" && !tbl.withoutRowId && tbl.primaryKeyCols.length === 1)
+    );
+    if (this.foreignKeys || hasTriggers || hasComplexCols) {
+      return false;
+    }
+    const cols = tbl.columns;
+    const colCount = cols.length;
+    let inserted = 0;
+    for (let i = 0; i < rows.length; i++) {
+      const r = rows[i];
+      if (r.length === 1 && r[0] === "" && colCount > 1) continue;
+      const data = {};
+      for (let cIdx = 0; cIdx < colCount; cIdx++) {
+        const col = cols[cIdx];
+        const raw = r[cIdx] ?? "";
+        const val = applyColumnAffinity(raw, col.type);
+        if (col.notNull && (val === null || val === void 0)) {
+          return false;
+        }
+        data[col.name] = val;
+      }
+      const rowid = tbl.nextRowId;
+      const candidate = { rowid, data };
+      const conflict = runSynchronously(this.checkConstraintsAndConflicts(tbl, candidate));
+      if (conflict) {
+        throw new Error(`UNIQUE constraint failed: ${tbl.name}`);
+      }
+      this.checkRowCount(tbl.rows.length + 1);
+      tbl.rows.push(candidate);
+      tbl.nextRowId = rowid + 1;
+      if (rowid > tbl.maxAutoInc) tbl.maxAutoInc = rowid;
+      this.lastInsertRowid = rowid;
+      inserted++;
+    }
+    this.lastChanges = inserted;
+    this.totalChanges += inserted;
+    return true;
+  }
   findTable(name) {
     const lower = name.toLowerCase();
     for (const [k, v] of this.tables) {
@@ -3533,6 +3577,63 @@ var SqliteDatabase = class {
         resolvedKeySets.push(index.columns.map((cKey, i) => ({ cKey, collate: index.collations?.[i] ?? tbl.columns.find((col) => col.name === cKey)?.collate ?? "BINARY" })));
       }
     }
+    if (resolvedKeySets.length === 0 && candidate.rowid >= tbl.nextRowId) {
+      return null;
+    }
+    const canUseFastIndex = excludeRowid === void 0 && tbl.rows.length > 32 && resolvedKeySets.every((ks) => ks.every((k) => k.collate === "BINARY"));
+    if (canUseFastIndex) {
+      const encodeKey = (row, ks) => {
+        if (ks.length === 1) {
+          const v = row.data[ks[0].cKey] ?? null;
+          if (v === null) return null;
+          return `${typeof v}:${String(v)}`;
+        }
+        const parts = [];
+        for (const { cKey } of ks) {
+          const v = row.data[cKey] ?? null;
+          if (v === null) return null;
+          parts.push(`${typeof v}:${String(v)}`);
+        }
+        return parts.join("");
+      };
+      const indexRow = (idx, row) => {
+        idx.byRowid.set(row.rowid, row);
+        for (let i = 0; i < resolvedKeySets.length; i += 1) {
+          const k = encodeKey(row, resolvedKeySets[i]);
+          if (k !== null) {
+            idx.byKeySets[i].set(k, row);
+          }
+        }
+      };
+      let fastIdx = tbl.__fastConflictIndex;
+      if (!fastIdx || fastIdx.byKeySets.length !== resolvedKeySets.length || fastIdx.len !== tbl.rows.length && !(fastIdx.len + 1 === tbl.rows.length && fastIdx.lastRow === tbl.rows[tbl.rows.length - 2])) {
+        fastIdx = {
+          len: tbl.rows.length,
+          lastRow: tbl.rows[tbl.rows.length - 1],
+          byRowid: /* @__PURE__ */ new Map(),
+          byKeySets: resolvedKeySets.map(() => /* @__PURE__ */ new Map())
+        };
+        for (const r of tbl.rows) {
+          indexRow(fastIdx, r);
+        }
+        tbl.__fastConflictIndex = fastIdx;
+      } else if (fastIdx.len + 1 === tbl.rows.length) {
+        const added = tbl.rows[tbl.rows.length - 1];
+        indexRow(fastIdx, added);
+        fastIdx.len = tbl.rows.length;
+        fastIdx.lastRow = added;
+      }
+      const byId = fastIdx.byRowid.get(candidate.rowid);
+      if (byId) return byId;
+      for (let i = 0; i < resolvedKeySets.length; i += 1) {
+        const k = encodeKey(candidate, resolvedKeySets[i]);
+        if (k !== null) {
+          const hit = fastIdx.byKeySets[i].get(k);
+          if (hit) return hit;
+        }
+      }
+      return null;
+    }
     for (const existing of tbl.rows) {
       yield;
       if (excludeRowid !== void 0 && existing.rowid === excludeRowid) {
@@ -4807,11 +4908,13 @@ var SqliteDatabase = class {
         }, this);
       }
     } else {
-      groupedRows = yield* stepMap(workingRows, function* (r) {
+      groupedRows = yield* stepMap(workingRows, function* (r, idx) {
         yield;
+        workingRows[idx] = void 0;
         return { representative: r, group: [r] };
       }, this);
     }
+    workingRows = [];
     const windowResults = /* @__PURE__ */ new Map();
     for (const st of selectTargets) {
       yield;
@@ -4823,8 +4926,15 @@ var SqliteDatabase = class {
         windowResults
       );
     }
+    const firstWindowPeek = windowResults.keys().next().value;
+    const needsPostProjectionCtx = Boolean(
+      orderByTokens && orderByTokens.length > 0 || !orderByTokens?.length && firstWindowPeek?.kind === "func" && firstWindowPeek.over
+    );
+    const emptyCtx = {};
+    const emptyGroup = [];
     let projected = yield* stepMap(groupedRows, function* (g, rowIdx) {
-      const repCtx = { ...g.representative };
+      groupedRows[rowIdx] = void 0;
+      const repCtx = g.representative;
       const values = yield* stepMap(selectTargets, function* (st) {
         const val = yield* this.evalExprSteps(
           st.expr,
@@ -4838,8 +4948,13 @@ var SqliteDatabase = class {
         }
         return val;
       }, this);
-      return { values, ctx: repCtx, group: g.group };
+      return {
+        values,
+        ctx: needsPostProjectionCtx ? repCtx : emptyCtx,
+        group: needsPostProjectionCtx ? g.group : emptyGroup
+      };
     }, this);
+    groupedRows = [];
     const firstWindow = windowResults.keys().next().value;
     if (!orderByTokens?.length && firstWindow?.kind === "func" && firstWindow.over) {
       const sortSpecs = [
@@ -5186,7 +5301,97 @@ var SqliteDatabase = class {
         }
       }
       const rightMatched = /* @__PURE__ */ new Set();
-      for (const leftRow of currentRows) {
+      let equiJoinSpec;
+      const rightAliasLower = resolved.alias.toLowerCase();
+      const rightColSet = new Set(resolved.columns.map((c) => c.toLowerCase()));
+      const leftAliasSet = new Set(schema.slice(0, -1).map((s) => s.tableAlias.toLowerCase()));
+      const classifyJoinCol = (colExpr) => {
+        if (colExpr.table) {
+          const tLower = colExpr.table.toLowerCase();
+          if (tLower === rightAliasLower) return "right";
+          if (leftAliasSet.has(tLower)) return "left";
+          return void 0;
+        }
+        const cLower = colExpr.name.toLowerCase();
+        const inLeft = prevCols.has(cLower);
+        const inRight = rightColSet.has(cLower);
+        if (inLeft && !inRight) return "left";
+        if (inRight && !inLeft) return "right";
+        return void 0;
+      };
+      const findEquiPair = (expr, topLevel) => {
+        if (!expr || equiJoinSpec) return;
+        if (expr.kind === "binary" && expr.op === "=" && expr.left.kind === "column" && expr.right.kind === "column") {
+          const sideA = classifyJoinCol(expr.left);
+          const sideB = classifyJoinCol(expr.right);
+          if (sideA === "left" && sideB === "right") {
+            equiJoinSpec = {
+              leftTable: expr.left.table,
+              leftCol: expr.left.name,
+              rightTable: expr.right.table ?? resolved.alias,
+              rightCol: expr.right.name,
+              isPureSingleEqui: topLevel
+            };
+          } else if (sideA === "right" && sideB === "left") {
+            equiJoinSpec = {
+              leftTable: expr.right.table,
+              leftCol: expr.right.name,
+              rightTable: expr.left.table ?? resolved.alias,
+              rightCol: expr.left.name,
+              isPureSingleEqui: topLevel
+            };
+          }
+        } else if (expr.kind === "binary" && expr.op === "AND") {
+          findEquiPair(expr.left, false);
+          findEquiPair(expr.right, false);
+        }
+      };
+      if (!resolved.isCorrelated) {
+        if (onExpr) {
+          findEquiPair(onExpr, true);
+        } else if (usingList && usingList.length > 0) {
+          equiJoinSpec = {
+            leftTable: void 0,
+            leftCol: usingList[0],
+            rightTable: resolved.alias,
+            rightCol: usingList[0],
+            isPureSingleEqui: usingList.length === 1
+          };
+        }
+      }
+      const getHashJoinKeys = (val) => {
+        if (val === null || val === void 0) return [];
+        if (typeof val === "number") {
+          return ["num:" + String(Object.is(val, -0) ? 0 : val)];
+        }
+        if (typeof val === "string") {
+          const trimmed = val.trim();
+          const num = trimmed !== "" ? Number(trimmed) : NaN;
+          if (!Number.isNaN(num)) {
+            return ["str:" + val, "num:" + String(Object.is(num, -0) ? 0 : num)];
+          }
+          return ["str:" + val];
+        }
+        return ["other:" + String(val)];
+      };
+      let rightHashIndex;
+      if (equiJoinSpec && resolved.rows.length > 0) {
+        rightHashIndex = /* @__PURE__ */ new Map();
+        for (let rIdx = 0; rIdx < resolved.rows.length; rIdx += 1) {
+          const rVal = this.lookupColInRow(resolved.rows[rIdx], equiJoinSpec.rightTable, equiJoinSpec.rightCol);
+          for (const key of getHashJoinKeys(rVal)) {
+            let bucket = rightHashIndex.get(key);
+            if (!bucket) {
+              bucket = [];
+              rightHashIndex.set(key, bucket);
+            }
+            bucket.push(rIdx);
+          }
+        }
+      }
+      for (let lIdx = 0; lIdx < currentRows.length; lIdx += 1) {
+        const leftRow = currentRows[lIdx];
+        currentRows[lIdx] = void 0;
         yield;
         const candidateRightRows = resolved.isCorrelated ? (yield* this.resolveSingleTableSource(
           item.sourceTokens,
@@ -5195,22 +5400,83 @@ var SqliteDatabase = class {
           cteScope
         )).rows : resolved.rows;
         let matchedLeft = false;
-        for (let rIdx = 0; rIdx < candidateRightRows.length; rIdx += 1) {
+        let candidateIndices;
+        let leftEquiVal = null;
+        if (rightHashIndex && equiJoinSpec) {
+          leftEquiVal = this.lookupColInRow(leftRow, equiJoinSpec.leftTable, equiJoinSpec.leftCol);
+          const probeKeys = getHashJoinKeys(leftEquiVal);
+          if (probeKeys.length === 0) {
+            candidateIndices = [];
+          } else if (probeKeys.length === 1) {
+            candidateIndices = rightHashIndex.get(probeKeys[0]) ?? [];
+          } else {
+            const seen = /* @__PURE__ */ new Set();
+            for (const pk of probeKeys) {
+              const bucket = rightHashIndex.get(pk);
+              if (bucket) {
+                for (const idx of bucket) seen.add(idx);
+              }
+            }
+            candidateIndices = [...seen];
+          }
+        }
+        const totalCandidates = candidateIndices ? candidateIndices.length : candidateRightRows.length;
+        for (let cPos = 0; cPos < totalCandidates; cPos += 1) {
           yield;
+          const rIdx = candidateIndices ? candidateIndices[cPos] : cPos;
           const rightRow = candidateRightRows[rIdx];
-          const merged = { ...leftRow };
-          for (const [k, v] of Object.entries(rightRow)) {
-            yield;
-            if (k.includes(".") || !(k in merged) || merged[k] === null) {
-              merged[k] = v;
+          if (equiJoinSpec) {
+            const rVal = this.lookupColInRow(rightRow, equiJoinSpec.rightTable, equiJoinSpec.rightCol);
+            if (leftEquiVal === null || rVal === null || !sqlEquals(leftEquiVal, rVal)) {
+              continue;
+            }
+          }
+          const canMutateInPlace = !matchedLeft && totalCandidates === 1 && Boolean(equiJoinSpec && equiJoinSpec.isPureSingleEqui);
+          let merged;
+          const lTables = leftRow.__tables;
+          const rTables = rightRow.__tables;
+          if (lTables && rTables) {
+            if (canMutateInPlace) {
+              Object.assign(lTables, rTables);
+              if (leftRow.__rowids && rightRow.__rowids) {
+                Object.assign(leftRow.__rowids, rightRow.__rowids);
+              }
+              leftRow.__sources.push(...rightRow.__sources ?? []);
+              merged = leftRow;
+            } else {
+              merged = {
+                __rowid: leftRow.__rowid,
+                __tables: { ...lTables, ...rTables },
+                __rowids: { ...leftRow.__rowids, ...rightRow.__rowids },
+                __sources: [...leftRow.__sources ?? [], ...rightRow.__sources ?? []]
+              };
+            }
+          } else {
+            merged = canMutateInPlace ? leftRow : { ...leftRow };
+            if (lTables && !canMutateInPlace) {
+              merged.__tables = { ...lTables };
+              merged.__rowids = { ...leftRow.__rowids };
+              merged.__sources = [...leftRow.__sources ?? []];
+            }
+            if (rTables) {
+              merged.__tables = { ...merged.__tables ?? {}, ...rTables };
+              merged.__rowids = { ...merged.__rowids ?? {}, ...rightRow.__rowids };
+              merged.__sources = [...merged.__sources ?? [], ...rightRow.__sources ?? []];
+            }
+            for (const k in rightRow) {
+              if (k.startsWith("__")) continue;
+              const v = rightRow[k];
+              if (k.includes(".") || !(k in merged) || merged[k] === null) {
+                merged[k] = v;
+              }
             }
           }
           let matches = true;
-          if (onExpr) {
+          if (onExpr && !(equiJoinSpec && equiJoinSpec.isPureSingleEqui)) {
             matches = isTruthy(
               yield* this.evalExprSteps(onExpr, merged, positionalParams, cteScope)
             );
-          } else if (usingList && usingList.length > 0) {
+          } else if (usingList && usingList.length > 0 && !(equiJoinSpec && equiJoinSpec.isPureSingleEqui)) {
             for (const uCol of usingList) {
               yield;
               const lVal = this.lookupColInRow(leftRow, void 0, uCol);
@@ -5229,16 +5495,29 @@ var SqliteDatabase = class {
           }
         }
         if (!matchedLeft && (item.joinType === "LEFT" || item.joinType === "FULL")) {
-          const nullPadded = { ...leftRow };
+          const nullObj = {};
           for (const col of resolved.columns) {
-            yield;
-            nullPadded[`${resolved.alias}.${col}`] = null;
-            if (!(col in nullPadded)) {
-              nullPadded[col] = null;
+            nullObj[col] = null;
+          }
+          const lTables = leftRow.__tables;
+          if (lTables) {
+            lTables[resolved.alias] = nullObj;
+            if (leftRow.__rowids) leftRow.__rowids[resolved.alias] = null;
+            leftRow.__sources.push(nullObj);
+            this.checkRowCount(nextRows.length + 1);
+            nextRows.push(leftRow);
+          } else {
+            const nullPadded = { ...leftRow };
+            for (const col of resolved.columns) {
+              yield;
+              nullPadded[`${resolved.alias}.${col}`] = null;
+              if (!(col in nullPadded)) {
+                nullPadded[col] = null;
+              }
             }
+            this.checkRowCount(nextRows.length + 1);
+            nextRows.push(nullPadded);
           }
-          this.checkRowCount(nextRows.length + 1);
-          nextRows.push(nullPadded);
         }
       }
       if (item.joinType === "RIGHT" || item.joinType === "FULL") {
@@ -5246,18 +5525,44 @@ var SqliteDatabase = class {
           yield;
           if (!rightMatched.has(rIdx)) {
             const rightRow = resolved.rows[rIdx];
-            const nullPadded = {};
-            for (const s of schema.slice(0, -1)) {
-              yield;
-              for (const col of s.columns) {
+            const rTables = rightRow.__tables;
+            if (rTables) {
+              const tablesMap = {};
+              const rowidsMap = {};
+              const sourcesList = [];
+              for (const s of schema.slice(0, -1)) {
+                const nullLeft = {};
+                for (const col of s.columns) {
+                  nullLeft[col] = null;
+                }
+                tablesMap[s.tableAlias] = nullLeft;
+                rowidsMap[s.tableAlias] = null;
+                sourcesList.push(nullLeft);
+              }
+              Object.assign(tablesMap, rTables);
+              if (rightRow.__rowids) Object.assign(rowidsMap, rightRow.__rowids);
+              sourcesList.push(...rightRow.__sources ?? []);
+              this.checkRowCount(nextRows.length + 1);
+              nextRows.push({
+                __rowid: rightRow.__rowid ?? null,
+                __tables: tablesMap,
+                __rowids: rowidsMap,
+                __sources: sourcesList
+              });
+            } else {
+              const nullPadded = {};
+              for (const s of schema.slice(0, -1)) {
                 yield;
-                nullPadded[`${s.tableAlias}.${col}`] = null;
-                nullPadded[col] = null;
+                for (const col of s.columns) {
+                  yield;
+                  nullPadded[`${s.tableAlias}.${col}`] = null;
+                  nullPadded[col] = null;
+                }
               }
+              Object.assign(nullPadded, rightRow);
+              this.checkRowCount(nextRows.length + 1);
+              nextRows.push(nullPadded);
             }
-            Object.assign(nullPadded, rightRow);
-            this.checkRowCount(nextRows.length + 1);
-            nextRows.push(nullPadded);
           }
         }
       }
@@ -5511,15 +5816,21 @@ var SqliteDatabase = class {
         cteScope
       )) ?? { columns: [], rows: [] };
       const cols2 = view.columns && view.columns.length > 0 ? view.columns : res.columns;
-      const rows2 = yield* stepMap(res.rows, function* (r) {
+      const sameViewAlias = alias.toLowerCase() === name.toLowerCase();
+      const rows2 = yield* stepMap(res.rows, function* (r, rIdx) {
         yield;
-        const obj = {};
-        cols2.forEach((c, cIdx) => {
-          obj[c] = r[cIdx] ?? null;
-          obj[`${alias}.${c}`] = r[cIdx] ?? null;
-          obj[`${name}.${c}`] = r[cIdx] ?? null;
-        });
-        return obj;
+        res.rows[rIdx] = void 0;
+        const data = {};
+        for (let cIdx = 0; cIdx < cols2.length; cIdx++) {
+          data[cols2[cIdx]] = r[cIdx] ?? null;
+        }
+        const tablesMap = sameViewAlias ? { [alias]: data } : { [alias]: data, [name]: data };
+        return {
+          __rowid: rIdx + 1,
+          __tables: tablesMap,
+          __rowids: sameViewAlias ? { [alias]: rIdx + 1 } : { [alias]: rIdx + 1, [name]: rIdx + 1 },
+          __sources: [data]
+        };
       }, this);
       return { alias, columns: cols2, rows: rows2 };
     }
@@ -5530,22 +5841,17 @@ var SqliteDatabase = class {
     const cols = tbl.columns.map((c) => {
       return c.name;
     });
+    const sameAliasAndName = alias.toLowerCase() === name.toLowerCase();
     const rows = yield* stepMap(this.preparing ? [] : tbl.rows, function* (r) {
-      const obj = {
-        rowid: r.rowid,
-        _rowid_: r.rowid,
-        oid: r.rowid,
-        [`${alias}.rowid`]: r.rowid,
-        [`${name}.rowid`]: r.rowid
+      yield;
+      const tablesMap = sameAliasAndName ? { [alias]: r.data } : { [alias]: r.data, [name]: r.data };
+      const rowidsMap = sameAliasAndName ? { [alias]: r.rowid } : { [alias]: r.rowid, [name]: r.rowid };
+      return {
+        __rowid: r.rowid,
+        __tables: tablesMap,
+        __rowids: rowidsMap,
+        __sources: [r.data]
       };
-      for (const c of cols) {
-        yield;
-        const val = r.data[c] ?? null;
-        obj[c] = val;
-        obj[`${alias}.${c}`] = val;
-        obj[`${name}.${c}`] = val;
-      }
-      return obj;
     }, this);
     return { alias, columns: cols, rows };
   }
@@ -6056,31 +6362,150 @@ var SqliteDatabase = class {
     }
   }
   lookupColInRow(row, table, name, doubleQuoted = false) {
+    const tables = row.__tables;
+    const sources = row.__sources;
+    const rowids = row.__rowids;
+    const lowerName = name.toLowerCase();
+    if (lowerName === "rowid" || lowerName === "_rowid_" || lowerName === "oid") {
+      if (!table && name in row && !name.startsWith("__")) {
+        return row[name];
+      }
+      if (table) {
+        const exact = `${table}.${name}`;
+        if (exact in row) return row[exact];
+        if (tables) {
+          let td = tables[table];
+          if (!td) {
+            const lt = table.toLowerCase();
+            for (const tk in tables) {
+              if (tk.toLowerCase() === lt) {
+                td = tables[tk];
+                break;
+              }
+            }
+          }
+          if (td) {
+            if (name in td) return td[name];
+            for (const k in td) {
+              if (k.toLowerCase() === lowerName) return td[k];
+            }
+          }
+        }
+        if (rowids) {
+          if (table in rowids) return rowids[table];
+          const lt = table.toLowerCase();
+          for (const tk in rowids) {
+            if (tk.toLowerCase() === lt) return rowids[tk];
+          }
+        }
+        const tableRowidKey = table + ".rowid";
+        if (tableRowidKey in row) return row[tableRowidKey];
+      } else {
+        if (sources) {
+          for (let i = 0; i < sources.length; i++) {
+            const s = sources[i];
+            if (name in s) return s[name];
+            for (const k in s) {
+              if (k.toLowerCase() === lowerName) return s[k];
+            }
+          }
+        }
+        for (const k in row) {
+          if (!k.startsWith("__") && k.toLowerCase() === lowerName) return row[k];
+        }
+        if ("__rowid" in row) return row.__rowid;
+      }
+    }
     if (table) {
+      if (tables) {
+        let td = tables[table];
+        if (!td) {
+          const lt = table.toLowerCase();
+          for (const tk in tables) {
+            if (tk.toLowerCase() === lt) {
+              td = tables[tk];
+              break;
+            }
+          }
+        }
+        if (td) {
+          if (name in td) return td[name] ?? null;
+          for (const k in td) {
+            if (k.toLowerCase() === lowerName) return td[k] ?? null;
+          }
+        }
+      }
       const exact = `${table}.${name}`;
       if (exact in row) {
         return row[exact];
       }
       const lowerExact = exact.toLowerCase();
-      for (const [k, v] of Object.entries(row)) {
+      for (const k in row) {
+        if (k.startsWith("__")) continue;
         if (k.toLowerCase() === lowerExact) {
-          return v;
+          return row[k];
         }
       }
-    }
-    if (!table && name in row) {
-      return row[name];
-    }
-    const lowerName = name.toLowerCase();
-    for (const [k, v] of Object.entries(row)) {
-      if (!table && (k.toLowerCase() === lowerName || k.toLowerCase().endsWith(`.${lowerName}`))) {
-        return v;
+    } else {
+      if (name in row && !name.startsWith("__")) {
+        return row[name];
+      }
+      if (sources) {
+        let found;
+        for (let i = 0; i < sources.length; i++) {
+          const src = sources[i];
+          if (name in src) {
+            const v = src[name] ?? null;
+            if (found === void 0 || found === null) found = v;
+            if (found !== null && found !== void 0) return found;
+          }
+        }
+        if (found !== void 0) return found;
+        for (let i = 0; i < sources.length; i++) {
+          const src = sources[i];
+          for (const k in src) {
+            if (k.toLowerCase() === lowerName) {
+              const v = src[k] ?? null;
+              if (found === void 0 || found === null) found = v;
+              if (found !== null && found !== void 0) return found;
+            }
+          }
+        }
+        if (found !== void 0) return found;
+      }
+      for (const k in row) {
+        if (k.startsWith("__")) continue;
+        if (k.toLowerCase() === lowerName || k.toLowerCase().endsWith(`.${lowerName}`)) {
+          return row[k];
+        }
       }
     }
     for (let i = this.outerRows.length - 1; i >= 0; i -= 1) {
       const outer = this.outerRows[i];
+      const outerTables = outer.__tables;
+      const outerSources = outer.__sources;
+      if (table && outerTables) {
+        const lt = table.toLowerCase();
+        for (const tk in outerTables) {
+          if (tk.toLowerCase() === lt) {
+            const td = outerTables[tk];
+            if (name in td) return td[name] ?? null;
+            for (const k in td) {
+              if (k.toLowerCase() === lowerName) return td[k] ?? null;
+            }
+          }
+        }
+      } else if (!table && outerSources) {
+        for (let s = 0; s < outerSources.length; s++) {
+          const src = outerSources[s];
+          if (name in src) return src[name] ?? null;
+          for (const k in src) {
+            if (k.toLowerCase() === lowerName) return src[k] ?? null;
+          }
+        }
+      }
       const key = Object.keys(outer).find(
-        (key2) => table ? key2.toLowerCase() === `${table}.${name}`.toLowerCase() : key2.toLowerCase() === lowerName
+        (key2) => !key2.startsWith("__") && (table ? key2.toLowerCase() === `${table}.${name}`.toLowerCase() : key2.toLowerCase() === lowerName)
       );
       if (key !== void 0) return outer[key];
     }
@@ -8077,12 +8502,22 @@ Options:
               await execSingleStmt(createSql);
               tbl = db.findTable ? db.findTable(tableArg) : void 0;
             }
-            for (const r of dataRows) {
-              if (r.length === 1 && r[0] === "" && colCount > 1) {
-                continue;
+            const targetTableName = tbl ? tbl.name : tableArg;
+            if (typeof db.bulkImportRows === "function" && db.bulkImportRows(targetTableName, dataRows)) {
+              state.dirty = true;
+            } else {
+              const batchValues = [];
+              for (const r of dataRows) {
+                if (r.length === 1 && r[0] === "" && colCount > 1) {
+                  continue;
+                }
+                const valsSql = Array.from({ length: colCount }, (_, cIdx) => `'${(r[cIdx] ?? "").replace(/'/g, "''")}'`).join(", ");
+                batchValues.push(`(${valsSql})`);
+              }
+              for (let b = 0; b < batchValues.length; b += 500) {
+                const chunk = batchValues.slice(b, b + 500);
+                await execSingleStmt(`INSERT INTO "${targetTableName}" VALUES ${chunk.join(", ")}`);
               }
-              const valsSql = Array.from({ length: colCount }, (_, cIdx) => `'${(r[cIdx] ?? "").replace(/'/g, "''")}'`).join(", ");
-              await execSingleStmt(`INSERT INTO "${tbl ? tbl.name : tableArg}" VALUES (${valsSql})`);
             }
             state.dirty = true;
             return;
@@ -8244,7 +8679,7 @@ Options:
               }
             } else {
               sqlBuffer.push(line);
-              if (trimmed.endsWith(";") && !/\bBEGIN\b/i.test(sqlBuffer.join("\n"))) {
+              if (trimmed.endsWith(";") && !(/\bCREATE\s+(?:TEMP\s+|TEMPORARY\s+)?TRIGGER\b[\s\S]*\bBEGIN\b/i.test(sqlBuffer.join("\n")) && !/\bEND\s*;\s*$/i.test(sqlBuffer.join("\n")))) {
                 const ok = await flushSqlBuffer();
                 if (!ok) {
                   return false;
@@ -8664,7 +9099,7 @@ Options:
         const fileArg = parts[pIdx] ?? "";
         const tableArg = parts[pIdx + 1] ?? "";
         const fileBytes = readFileSync(fileArg);
-        if (!fileBytes || fileBytes.byteLength > 65536) return false;
+        if (!fileBytes || fileBytes.byteLength > 16 * 1024 * 1024) return false;
         const content = textDecoder3.decode(fileBytes);
         const sep = csvOverride ? "," : state.colSeparator;
         const parsedRows = parseCsvContent(content, sep).slice(skipRows);
@@ -8680,10 +9115,15 @@ Options:
           db.executeStatement(createSql);
           tbl = db.findTable(tableArg);
         }
+        const batchValues = [];
         for (const r of dataRows) {
           if (r.length === 1 && r[0] === "" && colCount > 1) continue;
           const valsSql = Array.from({ length: colCount }, (_, cIdx) => `'${(r[cIdx] ?? "").replace(/'/g, "''")}'`).join(", ");
-          db.executeStatement(`INSERT INTO "${tbl ? tbl.name : tableArg}" VALUES (${valsSql})`);
+          batchValues.push(`(${valsSql})`);
+        }
+        for (let b = 0; b < batchValues.length; b += 500) {
+          const chunk = batchValues.slice(b, b + 500);
+          db.executeStatement(`INSERT INTO "${tbl ? tbl.name : tableArg}" VALUES ${chunk.join(", ")}`);
         }
         state.dirty = true;
         return true;
@@ -8731,7 +9171,7 @@ Options:
           if (state.exitRequested) return true;
         } else {
           sqlBuffer.push(line);
-          if (trimmed.endsWith(";") && !/\bBEGIN\b/i.test(sqlBuffer.join("\n"))) {
+          if (trimmed.endsWith(";") && !(/\bCREATE\s+(?:TEMP\s+|TEMPORARY\s+)?TRIGGER\b[\s\S]*\bBEGIN\b/i.test(sqlBuffer.join("\n")) && !/\bEND\s*;\s*$/i.test(sqlBuffer.join("\n")))) {
             if (!flushSqlBuffer()) return false;
             if (state.exitRequested) return true;
           }