@quereus/quereus 0.7.2 → 0.7.4

package/src/runtime/types.ts

@@ -1,242 +0,0 @@
-import type { RuntimeValue, SqlParameters, OutputValue, Row } from "../common/types.js";
-import type { Database } from "../core/database.js";
-import type { Statement } from "../core/statement.js";
-import type { RowDescriptor, RowGetter, TableDescriptor, TableGetter } from "../planner/nodes/plan-node.js";
-import type { Scheduler } from "./scheduler.js";
-import type { EmissionContext } from "./emission-context.js";
-import type { VirtualTableConnection } from "../vtab/connection.js";
-import type { PlanNode } from '../planner/nodes/plan-node.js';
-
-// Re-export types from common/types.js for convenience
-export type { OutputValue };
-
-export type RuntimeContext = {
-	db: Database;
-	stmt: Statement | undefined; // Undefined for transient exec statements
-	params: SqlParameters; // User-provided values for the current execution
-	/** Row contexts by row descriptor */
-	context: Map<RowDescriptor, RowGetter>;
-	/** Table contexts by table name, used for recursive CTEs or other temporary table situations */
-	tableContexts: Map<TableDescriptor, TableGetter>;
-	/** Debug tracer for instruction execution, if enabled */
-	tracer?: InstructionTracer;
-	/** Active connection for the current transaction context */
-	activeConnection?: VirtualTableConnection;
-	/** Whether to collect runtime execution metrics */
-	enableMetrics: boolean;
-	/** Context tracking for debugging context leaks */
-	contextTracker?: ContextTracker;
-	/** Stack of currently executing plan nodes (only when tracing enabled) */
-	planStack?: PlanNode[];
-};
-
-export type InstructionRun = (ctx: RuntimeContext, ...args: RuntimeValue[]) => OutputValue;
-
-export type Instruction = {
-	params: Instruction[];
-	run: InstructionRun;
-	/** Optional human-readable note about what this instruction does */
-	note?: string;
-	/** Optional sub-programs used to execute this instruction - this is here for tracing purposes */
-	programs?: Scheduler[];
-	/** Optional emission context for schema validation */
-	emissionContext?: EmissionContext;
-	/** Optional runtime statistics collected during execution */
-	runtimeStats?: InstructionRuntimeStats;
-};
-
-/**
- * Runtime statistics for instruction execution
- */
-export interface InstructionRuntimeStats {
-	/** Number of input values/rows processed */
-	in: number;
-	/** Number of output values/rows produced */
-	out: number;
-	/** Total execution time in nanoseconds */
-	elapsedNs: bigint;
-	/** Number of times this instruction was executed */
-	executions: number;
-}
-
-/** * Trace event for instruction execution. */
-export interface InstructionTraceEvent {
-	instructionIndex: number;
-	note?: string;
-	type: 'input' | 'output' | 'row' | 'error';
-	timestamp: number;
-	args?: RuntimeValue[];
-	result?: OutputValue;
-	error?: string;
-	/** Information about sub-programs if this instruction has any */
-	subPrograms?: SubProgramInfo[];
-	/** Row index within the async iterable (for 'row' type events) */
-	rowIndex?: number;
-	/** Row data (for 'row' type events) */
-	row?: Row;
-}
-
-/** Information about a sub-program for tracing purposes */
-export interface SubProgramInfo {
-	programIndex: number;
-	instructionCount: number;
-	rootNote?: string;
-}
-
-/** * Interface for tracing instruction execution. */
-export interface InstructionTracer {
-	/** Called before an instruction executes */
-	traceInput(instructionIndex: number, instruction: Instruction, args: RuntimeValue[]): void;
-	/** Called after an instruction executes */
-	traceOutput(instructionIndex: number, instruction: Instruction, result: OutputValue): void;
-	/** Called when an instruction throws an error */
-	traceError(instructionIndex: number, instruction: Instruction, error: Error): void;
-	/** Called for each row emitted by an async iterable instruction */
-	traceRow(instructionIndex: number, instruction: Instruction, rowIndex: number, row: Row): void;
-	/** Gets collected trace events (if supported by the tracer) */
-	getTraceEvents?(): InstructionTraceEvent[];
-	/** Gets information about all sub-programs encountered during tracing */
-	getSubPrograms?(): Map<number, { scheduler: Scheduler; parentInstructionIndex: number }>;
-}
-
-/** * Tracer that collects execution events for later analysis. */
-export class CollectingInstructionTracer implements InstructionTracer {
-	private events: InstructionTraceEvent[] = [];
-	private subPrograms = new Map<number, { scheduler: Scheduler; parentInstructionIndex: number }>();
-	private nextSubProgramId = 0;
-
-	traceInput(instructionIndex: number, instruction: Instruction, args: RuntimeValue[]): void {
-		const subPrograms = this.collectSubProgramInfo(instructionIndex, instruction);
-
-		this.events.push({
-			instructionIndex,
-			note: instruction.note,
-			type: 'input',
-			timestamp: Date.now(),
-			args: this.cloneArgs(args),
-			subPrograms
-		});
-	}
-
-	traceOutput(instructionIndex: number, instruction: Instruction, result: OutputValue): void {
-		this.events.push({
-			instructionIndex,
-			note: instruction.note,
-			type: 'output',
-			timestamp: Date.now(),
-			result: this.cloneResult(result)
-		});
-	}
-
-	traceError(instructionIndex: number, instruction: Instruction, error: Error): void {
-		this.events.push({
-			instructionIndex,
-			note: instruction.note,
-			type: 'error',
-			timestamp: Date.now(),
-			error: error.message
-		});
-	}
-
-	traceRow(instructionIndex: number, instruction: Instruction, rowIndex: number, row: Row): void {
-		this.events.push({
-			instructionIndex,
-			note: instruction.note,
-			type: 'row',
-			timestamp: Date.now(),
-			rowIndex,
-			row
-		});
-	}
-
-	getTraceEvents(): InstructionTraceEvent[] {
-		return [...this.events];
-	}
-
-	getSubPrograms(): Map<number, { scheduler: Scheduler; parentInstructionIndex: number }> {
-		return new Map(this.subPrograms);
-	}
-
-	clear(): void {
-		this.events = [];
-		this.subPrograms.clear();
-		this.nextSubProgramId = 0;
-	}
-
-	private collectSubProgramInfo(instructionIndex: number, instruction: Instruction): SubProgramInfo[] | undefined {
-		if (!instruction.programs || instruction.programs.length === 0) {
-			return undefined;
-		}
-
-		return instruction.programs.map(scheduler => {
-			const programId = this.nextSubProgramId++;
-			this.subPrograms.set(programId, { scheduler, parentInstructionIndex: instructionIndex });
-
-			return {
-				programIndex: programId,
-				instructionCount: scheduler.instructions.length,
-				rootNote: scheduler.instructions[scheduler.instructions.length - 1]?.note
-			};
-		});
-	}
-
-	private cloneArgs(args: RuntimeValue[]): RuntimeValue[] {
-		return args.map(arg => this.cloneValue(arg));
-	}
-
-	private cloneResult(result: OutputValue): OutputValue {
-		if (result instanceof Promise) {
-			return result.then(resolved => this.cloneValue(resolved as RuntimeValue));
-		}
-		return this.cloneValue(result as RuntimeValue);
-	}
-
-	private cloneValue(value: RuntimeValue): RuntimeValue {
-		if (value === null || value === undefined) return value;
-		if (typeof value === 'function') return '[Function]';
-		if (typeof value === 'object' && value && Symbol.asyncIterator in value) return '[AsyncIterable]';
-		if (Array.isArray(value)) return value.map(v => this.cloneValue(v as RuntimeValue)) as RuntimeValue;
-		if (typeof value === 'object') return '[Object]';
-		return value as RuntimeValue;
-	}
-}
-
-/**
- * Tracks context additions and removals for debugging context leaks
- */
-export interface ContextTracker {
-	/** Record that a context was added */
-	addContext(descriptor: RowDescriptor, source: string): void;
-	/** Record that a context was removed */
-	removeContext(descriptor: RowDescriptor): void;
-	/** Get all remaining contexts with their sources */
-	getRemainingContexts(): Array<{ descriptor: RowDescriptor; source: string }>;
-	/** Check if there are any remaining contexts */
-	hasRemainingContexts(): boolean;
-}
-
-/**
- * Default implementation of ContextTracker
- */
-export class DefaultContextTracker implements ContextTracker {
-	private contexts = new Map<RowDescriptor, string>();
-
-	addContext(descriptor: RowDescriptor, source: string): void {
-		this.contexts.set(descriptor, source);
-	}
-
-	removeContext(descriptor: RowDescriptor): void {
-		this.contexts.delete(descriptor);
-	}
-
-	getRemainingContexts(): Array<{ descriptor: RowDescriptor; source: string }> {
-		return Array.from(this.contexts.entries()).map(([descriptor, source]) => ({
-			descriptor,
-			source
-		}));
-	}
-
-	hasRemainingContexts(): boolean {
-		return this.contexts.size > 0;
-	}
-}

package/src/runtime/utils.ts

@@ -1,177 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { QuereusError } from '../common/errors.js';
-import { StatusCode } from '../common/types.js';
-import type { TableSchema } from '../schema/table.js';
-import type { VirtualTable } from '../vtab/table.js';
-import type { RuntimeContext } from './types.js';
-import type { VirtualTableConnection } from '../vtab/connection.js';
-import { createLogger } from '../common/logger.js';
-import type { MemoryVirtualTableConnection } from '../vtab/memory/connection.js';
-import type { MemoryTable } from '../vtab/memory/table.js';
-import type { RowDescriptor, Attribute } from '../planner/nodes/plan-node.js';
-
-const log = createLogger('runtime:utils');
-const errorLog = log.extend('error');
-export const ctxLog = createLogger('runtime:context');
-
-/**
- * Check if a value is an AsyncIterable.
- * 
- * NOTE: Hermes (React Native's JS engine) has a bug where AsyncGenerator objects
- * don't have Symbol.asyncIterator as an own or inherited property, even though
- * they are valid async iterables. We work around this by also checking for
- * the presence of a .next() method (duck typing for async iterators).
- */
-export function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T> {
-	if (typeof value !== 'object' || value === null) {
-		return false;
-	}
-	// Standard check: Symbol.asyncIterator
-	if (Symbol.asyncIterator in value) {
-		return true;
-	}
-	// Hermes workaround: AsyncGenerator has .next() but not Symbol.asyncIterator
-	const maybeAsyncGen = value as { next?: unknown; constructor?: { name?: string } };
-	if (typeof maybeAsyncGen.next === 'function' && 
-	    maybeAsyncGen.constructor?.name === 'AsyncGenerator') {
-		return true;
-	}
-	return false;
-}
-
-/**
- * Get an AsyncIterator from an AsyncIterable, handling Hermes's missing Symbol.asyncIterator.
- * 
- * @throws TypeError if value is not a valid async iterable
- */
-export function getAsyncIterator<T>(value: AsyncIterable<T>): AsyncIterator<T> {
-	// Standard path: use Symbol.asyncIterator
-	if (Symbol.asyncIterator in value) {
-		return value[Symbol.asyncIterator]();
-	}
-	// Hermes workaround: AsyncGenerator is its own iterator
-	const maybeAsyncGen = value as unknown as { next?: () => Promise<IteratorResult<T>>; constructor?: { name?: string } };
-	if (typeof maybeAsyncGen.next === 'function' && 
-	    maybeAsyncGen.constructor?.name === 'AsyncGenerator') {
-		return maybeAsyncGen as AsyncIterator<T>;
-	}
-	throw new TypeError('Value is not async iterable');
-}
-
-export async function asyncIterableToArray<T>(iterable: AsyncIterable<T>): Promise<T[]> {
-	const result: T[] = [];
-	for await (const item of iterable) {
-		result.push(item);
-	}
-	return result;
-}
-
-/**
- * Helper to get or create a VirtualTable connection for a given table.
- * This ensures transaction consistency by reusing connections within the same context.
- */
-export async function getVTableConnection(ctx: RuntimeContext, tableSchema: TableSchema): Promise<VirtualTableConnection> {
-	const tableName = tableSchema.name; // Use just the table name, not fully qualified
-
-	// Check if we already have an active connection for this table
-	const existingConnections = ctx.db.getConnectionsForTable(tableName);
-	if (existingConnections.length > 0) {
-		log(`Reusing existing connection for table ${tableName}`);
-		return existingConnections[0];
-	}
-
-	// Create a new VirtualTable instance
-	const vtab = await getVTable(ctx, tableSchema);
-
-	// Try to create a connection if the table supports it
-	let connection: VirtualTableConnection;
-	if (vtab.createConnection) {
-		connection = await vtab.createConnection();
-		log(`Created new connection ${connection.connectionId} for table ${tableName}`);
-	} else if (vtab.getConnection) {
-		const existingConn = vtab.getConnection();
-		if (existingConn) {
-			connection = existingConn;
-			log(`Using existing internal connection ${connection.connectionId} for table ${tableName}`);
-		} else {
-			throw new QuereusError(`Table '${tableName}' does not support connections`, StatusCode.INTERNAL);
-		}
-	} else {
-		throw new QuereusError(`Table '${tableName}' does not support connections`, StatusCode.INTERNAL);
-	}
-
-	// Register the connection with the database
-	await ctx.db.registerConnection(connection);
-
-	// Set as the active connection in the runtime context if none is set
-	if (!ctx.activeConnection) {
-		ctx.activeConnection = connection;
-	}
-
-	return connection;
-}
-
-/**
- * Helper to get the VirtualTable instance for a given TableReferenceNode.
- * This is the legacy method that creates ephemeral instances.
- * When reusing connections, this will also inject the existing connection into the VirtualTable.
- */
-export async function getVTable(ctx: RuntimeContext, tableSchema: TableSchema): Promise<VirtualTable> {
-	// All tables are virtual, so vtabModuleName should always be present.
-	if (!tableSchema.vtabModuleName) {
-		throw new QuereusError(`Table schema for '${tableSchema.name}' is missing vtabModuleName.`, StatusCode.INTERNAL);
-	}
-	const moduleInfo = ctx.db._getVtabModule(tableSchema.vtabModuleName);
-	if (!moduleInfo) {
-		throw new QuereusError(`Virtual table module '${tableSchema.vtabModuleName}' not found for table '${tableSchema.name}'`, StatusCode.ERROR);
-	}
-	const module = moduleInfo.module;
-	if (typeof module.connect !== 'function') {
-		throw new QuereusError(`Virtual table module '${tableSchema.vtabModuleName}' does not implement connect`, StatusCode.MISUSE);
-	}
-	const vtabArgs = tableSchema.vtabArgs || {};
-	const vtabInstance = module.connect(ctx.db, moduleInfo.auxData, tableSchema.vtabModuleName, tableSchema.schemaName, tableSchema.name, vtabArgs);
-
-	// If we have an active connection for this table, inject it into the VirtualTable
-	const tableName = tableSchema.name;
-	const existingConnections = ctx.db.getConnectionsForTable(tableName);
-	if (existingConnections.length > 0 && tableSchema.vtabModuleName === 'memory') {
-		const memoryConnection = existingConnections[0] as MemoryVirtualTableConnection;
-		const memoryTable = vtabInstance as MemoryTable;
-		if (memoryConnection.getMemoryConnection && memoryTable.setConnection) {
-			memoryTable.setConnection(memoryConnection.getMemoryConnection());
-			log(`Injected existing connection into VirtualTable for table ${tableName}`);
-		}
-	}
-
-	return vtabInstance;
-}
-
-/**
- * Helper to properly disconnect and unregister a VirtualTable instance.
- */
-export async function disconnectVTable(ctx: RuntimeContext, vtab: VirtualTable): Promise<void> {
-	// Disconnect the VirtualTable instance
-	if (typeof vtab.disconnect === 'function') {
-		await vtab.disconnect().catch((e: any) => {
-			errorLog(`Error during disconnect for table '${vtab.tableName}': ${e}`);
-		});
-	}
-}
-
-/**
- * Helper function to log context push operations
- */
-export function logContextPush(descriptor: RowDescriptor, note: string, attributes?: readonly Attribute[]) {
-	const attrs = Object.keys(descriptor).filter(k => descriptor[parseInt(k)] !== undefined);
-	const attrNames = attributes ? attributes.map(attr => `${attr.name}(#${attr.id})`).join(',') : 'unknown';
-	ctxLog('PUSH context %s: attrs=[%s] names=[%s]', note, attrs.join(','), attrNames);
-}
-
-/**
- * Helper function to log context pop operations
- */
-export function logContextPop(descriptor: RowDescriptor, note: string) {
-	const attrs = Object.keys(descriptor).filter(k => descriptor[parseInt(k)] !== undefined);
-	ctxLog('POP context %s: attrs=[%s]', note, attrs.join(','));
-}

package/src/schema/assertion.ts

@@ -1,21 +0,0 @@
-export interface AssertionDependentTable {
-  /** Instance-unique table reference key, e.g. schema.table#nodeId */
-  relationKey: string;
-  /** Base table identifier, e.g. schema.table */
-  base: string;
-}
-
-export interface IntegrityAssertionSchema {
-  /** Unique assertion name */
-  name: string;
-  /** SQL text of the violation-producing query. Any returned row indicates a violation. */
-  violationSql: string;
-  /** Whether the assertion is deferrable. Currently always enforced at COMMIT. */
-  deferrable: boolean;
-  /** If true, initially deferred. Currently informational. */
-  initiallyDeferred: boolean;
-  /** Base tables referenced; filled during assertion preparation/creation. */
-  dependentTables?: AssertionDependentTable[];
-}
-
-

package/src/schema/catalog.ts

@@ -1,269 +0,0 @@
-import type { Database } from '../core/database.js';
-import type { TableSchema, IndexSchema } from './table.js';
-import type { ViewSchema } from './view.js';
-import type { IntegrityAssertionSchema } from './assertion.js';
-import { createTableToString, createViewToString, createIndexToString } from '../util/ast-stringify.js';
-import type * as AST from '../parser/ast.js';
-
-/**
- * Represents a catalog snapshot of the current database schema state
- */
-export interface SchemaCatalog {
-	schemaName: string;
-	tables: CatalogTable[];
-	views: CatalogView[];
-	indexes: CatalogIndex[];
-	assertions: CatalogAssertion[];
-}
-
-export interface CatalogTable {
-	name: string;
-	ddl: string;
-	columns: Array<{ name: string; type: string; notNull: boolean; primaryKey: boolean }>;
-}
-
-export interface CatalogView {
-	name: string;
-	ddl: string;
-}
-
-export interface CatalogIndex {
-	name: string;
-	tableName: string;
-	ddl: string;
-}
-
-export interface CatalogAssertion {
-	name: string;
-	ddl: string;
-}
-
-/**
- * Collects current schema state from the database into a catalog representation
- */
-export function collectSchemaCatalog(db: Database, schemaName: string = 'main'): SchemaCatalog {
-	const schema = db.schemaManager.getSchema(schemaName);
-	if (!schema) {
-		return {
-			schemaName,
-			tables: [],
-			views: [],
-			indexes: [],
-			assertions: []
-		};
-	}
-
-	const tables: CatalogTable[] = [];
-	const views: CatalogView[] = [];
-	const indexes: CatalogIndex[] = [];
-	const assertions: CatalogAssertion[] = [];
-
-	// Collect tables
-	for (const tableSchema of schema.getAllTables()) {
-		if (!tableSchema.isView) {
-			tables.push(tableSchemaToCatalog(tableSchema));
-
-			// Collect indexes for this table
-			if (tableSchema.indexes && tableSchema.indexes.length > 0) {
-				for (const indexSchema of tableSchema.indexes) {
-					indexes.push({
-						name: indexSchema.name,
-						tableName: tableSchema.name,
-						ddl: generateIndexDDL(indexSchema, tableSchema)
-					});
-				}
-			}
-		}
-	}
-
-	// Collect views
-	for (const viewSchema of schema.getAllViews()) {
-		views.push(viewSchemaToCatalog(viewSchema));
-	}
-
-	// Collect assertions
-	for (const assertionSchema of schema.getAllAssertions()) {
-		assertions.push(assertionSchemaToCatalog(assertionSchema));
-	}
-
-	return {
-		schemaName,
-		tables,
-		views,
-		indexes,
-		assertions
-	};
-}
-
-function tableSchemaToCatalog(tableSchema: TableSchema): CatalogTable {
-	// Generate canonical DDL from TableSchema
-	const ddl = generateTableDDL(tableSchema);
-
-	const columns = tableSchema.columns.map(col => ({
-		name: col.name,
-		type: col.logicalType.name,
-		notNull: col.notNull,
-		primaryKey: col.primaryKey
-	}));
-
-	return {
-		name: tableSchema.name,
-		ddl,
-		columns
-	};
-}
-
-function viewSchemaToCatalog(viewSchema: ViewSchema): CatalogView {
-	return {
-		name: viewSchema.name,
-		ddl: viewSchema.sql
-	};
-}
-
-function assertionSchemaToCatalog(assertionSchema: IntegrityAssertionSchema): CatalogAssertion {
-	return {
-		name: assertionSchema.name,
-		ddl: `CREATE ASSERTION ${assertionSchema.name} CHECK (${assertionSchema.violationSql})`
-	};
-}
-
-/**
- * Generates canonical DDL for an index from its schema
- */
-function generateIndexDDL(indexSchema: IndexSchema, tableSchema: TableSchema): string {
-	// Convert IndexSchema back to AST CreateIndexStmt for stringification
-	const indexStmt: AST.CreateIndexStmt = {
-		type: 'createIndex',
-		index: { type: 'identifier', name: indexSchema.name },
-		table: { type: 'identifier', name: tableSchema.name },
-		ifNotExists: false,
-		isUnique: false,
-		columns: indexSchema.columns.map(col => ({
-			name: tableSchema.columns[col.index].name,
-			expr: undefined,
-			collation: col.collation,
-			direction: col.desc ? 'desc' : 'asc'
-		}))
-	};
-
-	return createIndexToString(indexStmt);
-}
-
-/**
- * Generates canonical DDL for a table from its schema
- */
-function generateTableDDL(tableSchema: TableSchema): string {
-	const parts: string[] = ['CREATE TABLE'];
-
-	if (tableSchema.isTemporary) {
-		parts.push('TEMP');
-	}
-
-	parts.push(`"${tableSchema.name}"`);
-
-	// Generate column definitions
-	const columnDefs: string[] = [];
-	for (const col of tableSchema.columns) {
-		let colDef = `"${col.name}"`;
-		if (col.logicalType) {
-			colDef += ` ${col.logicalType.name}`;
-		}
-		if (col.notNull) {
-			colDef += ' NOT NULL';
-		}
-		if (col.primaryKey && tableSchema.primaryKeyDefinition.length === 1) {
-			colDef += ' PRIMARY KEY';
-		}
-		columnDefs.push(colDef);
-	}
-
-	// Add table-level PRIMARY KEY if composite
-	if (tableSchema.primaryKeyDefinition.length > 1) {
-		const pkCols = tableSchema.primaryKeyDefinition
-			.map(pk => `"${tableSchema.columns[pk.index].name}"`)
-			.join(', ');
-		columnDefs.push(`PRIMARY KEY (${pkCols})`);
-	}
-
-	parts.push(`(${columnDefs.join(', ')})`);
-
-	// Add USING clause
-	if (tableSchema.vtabModuleName) {
-		parts.push(`USING ${tableSchema.vtabModuleName}`);
-		if (tableSchema.vtabArgs && Object.keys(tableSchema.vtabArgs).length > 0) {
-			const args = Object.entries(tableSchema.vtabArgs)
-				.map(([key, value]) => `${key} = ${JSON.stringify(value)}`)
-				.join(', ');
-			parts.push(`(${args})`);
-		}
-	}
-
-	return parts.join(' ');
-}
-
-/**
- * Generates canonical DDL from a declared schema AST
- */
-export function generateDeclaredDDL(declaredSchema: AST.DeclareSchemaStmt, targetSchema?: string): string[] {
-	const ddlStatements: string[] = [];
-
-	for (const item of declaredSchema.items) {
-		switch (item.type) {
-			case 'declaredTable': {
-				// Qualify table name with schema if specified
-				const tableStmt = item.tableStmt;
-				if (targetSchema && targetSchema !== 'main' && !tableStmt.table.schema) {
-					const qualifiedStmt: AST.CreateTableStmt = {
-						...tableStmt,
-						table: {
-							...tableStmt.table,
-							schema: targetSchema
-						}
-					};
-					ddlStatements.push(createTableToString(qualifiedStmt));
-				} else {
-					ddlStatements.push(createTableToString(tableStmt));
-				}
-				break;
-			}
-			case 'declaredIndex': {
-				// Generate index DDL using AST stringifier
-				const indexStmt = item.indexStmt;
-				if (targetSchema && targetSchema !== 'main' && !indexStmt.table.schema) {
-					const qualifiedStmt: AST.CreateIndexStmt = {
-						...indexStmt,
-						table: {
-							...indexStmt.table,
-							schema: targetSchema
-						}
-					};
-					ddlStatements.push(createIndexToString(qualifiedStmt));
-				} else {
-					ddlStatements.push(createIndexToString(indexStmt));
-				}
-				break;
-			}
-			case 'declaredView': {
-				// Qualify view name with schema if specified
-				const viewStmt = item.viewStmt;
-				if (targetSchema && targetSchema !== 'main' && !viewStmt.view.schema) {
-					const qualifiedStmt: AST.CreateViewStmt = {
-						...viewStmt,
-						view: {
-							...viewStmt.view,
-							schema: targetSchema
-						}
-					};
-					ddlStatements.push(createViewToString(qualifiedStmt));
-				} else {
-					ddlStatements.push(createViewToString(viewStmt));
-				}
-				break;
-			}
-		}
-	}
-
-	return ddlStatements;
-}
-
-