@quereus/quereus 0.7.3 → 0.7.5

package/src/schema/change-events.ts

@@ -1,80 +0,0 @@
-import { createLogger } from '../common/logger.js';
-
-const log = createLogger('schema:change-events');
-
-/**
- * Represents a schema change event.
- */
-export interface SchemaChangeEvent {
-	type: 'table_added' | 'table_removed' | 'table_modified' |
-	      'function_added' | 'function_removed' | 'function_modified' |
-	      'module_added' | 'module_removed' | 'collation_added' | 'collation_removed';
-	schemaName?: string;
-	objectName: string;
-	oldObject?: unknown;
-	newObject?: unknown;
-}
-
-/**
- * Function that handles schema change events.
- */
-export type SchemaChangeListener = (event: SchemaChangeEvent) => void;
-
-/**
- * Manages schema change listeners and notifications.
- */
-export class SchemaChangeNotifier {
-	private listeners = new Set<SchemaChangeListener>();
-
-	/**
-	 * Adds a schema change listener.
-	 * @returns A function to unsubscribe the listener.
-	 */
-	addListener(listener: SchemaChangeListener): () => void {
-		this.listeners.add(listener);
-		log('Added schema change listener, total listeners: %d', this.listeners.size);
-		return () => this.removeListener(listener);
-	}
-
-	/**
-	 * Removes a schema change listener.
-	 */
-	removeListener(listener: SchemaChangeListener): void {
-		const removed = this.listeners.delete(listener);
-		if (removed) {
-			log('Removed schema change listener, total listeners: %d', this.listeners.size);
-		}
-	}
-
-	/**
-	 * Notifies all listeners of a schema change event.
-	 */
-	notifyChange(event: SchemaChangeEvent): void {
-		log('Notifying %d listeners of schema change: %s %s',
-			this.listeners.size, event.type, event.objectName);
-
-		for (const listener of this.listeners) {
-			try {
-				listener(event);
-			} catch (error) {
-				log('Error in schema change listener: %s', error);
-			}
-		}
-	}
-
-	/**
-	 * Gets the number of active listeners.
-	 */
-	getListenerCount(): number {
-		return this.listeners.size;
-	}
-
-	/**
-	 * Clears all listeners.
-	 */
-	clearListeners(): void {
-		const count = this.listeners.size;
-		this.listeners.clear();
-		log('Cleared all %d schema change listeners', count);
-	}
-}

package/src/schema/column.ts

@@ -1,51 +0,0 @@
-import { SqlDataType } from '../common/types.js';
-import type { Expression } from '../parser/ast.js';
-import type { LogicalType } from '../types/logical-type.js';
-
-/**
- * Represents the schema definition of a single column in a table.
- */
-export interface ColumnSchema {
-	/** Column name */
-	name: string;
-	/** Logical type definition */
-	logicalType: LogicalType;
-	/** Whether the column has a NOT NULL constraint */
-	notNull: boolean;
-	/** Whether the column is part of the primary key */
-	primaryKey: boolean;
-	/** Order within the primary key (1-based) or 0 if not PK */
-	pkOrder: number;
-	/** Default value expression */
-	defaultValue: Expression | null;
-	/** Declared collation sequence name (e.g., "BINARY", "NOCASE", "RTRIM") */
-	collation: string;
-	/** Is the column generated? */
-	generated: boolean;
-	/** Sort direction for primary key ('asc' | 'desc') */
-	pkDirection?: 'asc' | 'desc';
-}
-
-/**
- * Creates a default ColumnSchema with basic properties
- * Following Third Manifesto principles, columns default to NOT NULL unless explicitly specified otherwise
- *
- * @param name The name for the column
- * @param defaultNotNull Whether columns should be NOT NULL by default (defaults to true for Third Manifesto compliance)
- * @returns A new column schema with default values
- */
-export function createDefaultColumnSchema(name: string, defaultNotNull: boolean = true): ColumnSchema {
-	// Import TEXT_TYPE lazily to avoid circular dependencies
-	const { TEXT_TYPE } = require('../types/builtin-types.js');
-
-	return {
-		name: name,
-		logicalType: TEXT_TYPE,
-		notNull: defaultNotNull, // Third Manifesto: default to NOT NULL
-		primaryKey: false,
-		pkOrder: 0,
-		defaultValue: null,
-		collation: 'BINARY', // SQLite's default
-		generated: false,
-	};
-}

package/src/schema/declared-schema-manager.ts

@@ -1,82 +0,0 @@
-import type * as AST from '../parser/ast.js';
-import type { SqlValue } from '../common/types.js';
-import { createLogger } from '../common/logger.js';
-
-const log = createLogger('schema:declared');
-
-/**
- * Manages declared schemas and their associated seed data
- */
-export class DeclaredSchemaManager {
-	private declaredSchemas: Map<string, AST.DeclareSchemaStmt> = new Map();
-	private seedData: Map<string, Map<string, SqlValue[][]>> = new Map(); // schemaName -> tableName -> rows
-
-	/**
-	 * Stores a declared schema
-	 */
-	setDeclaredSchema(schemaName: string, declaration: AST.DeclareSchemaStmt): void {
-		this.declaredSchemas.set(schemaName.toLowerCase(), declaration);
-		log('Stored declared schema for: %s', schemaName);
-	}
-
-	/**
-	 * Retrieves a declared schema
-	 */
-	getDeclaredSchema(schemaName: string): AST.DeclareSchemaStmt | undefined {
-		return this.declaredSchemas.get(schemaName.toLowerCase());
-	}
-
-	/**
-	 * Checks if a schema has been declared
-	 */
-	hasDeclaredSchema(schemaName: string): boolean {
-		return this.declaredSchemas.has(schemaName.toLowerCase());
-	}
-
-	/**
-	 * Stores seed data for a table in a schema
-	 */
-	setSeedData(schemaName: string, tableName: string, rows: SqlValue[][]): void {
-		const lowerSchema = schemaName.toLowerCase();
-		if (!this.seedData.has(lowerSchema)) {
-			this.seedData.set(lowerSchema, new Map());
-		}
-		const schemaSeedData = this.seedData.get(lowerSchema)!;
-		schemaSeedData.set(tableName.toLowerCase(), rows);
-		log('Stored seed data for %s.%s (%d rows)', schemaName, tableName, rows.length);
-	}
-
-	/**
-	 * Retrieves seed data for a table
-	 */
-	getSeedData(schemaName: string, tableName: string): SqlValue[][] | undefined {
-		const schemaSeedData = this.seedData.get(schemaName.toLowerCase());
-		if (!schemaSeedData) return undefined;
-		return schemaSeedData.get(tableName.toLowerCase());
-	}
-
-	/**
-	 * Gets all seed data for a schema
-	 */
-	getAllSeedData(schemaName: string): Map<string, SqlValue[][]> {
-		return this.seedData.get(schemaName.toLowerCase()) || new Map();
-	}
-
-	/**
-	 * Clears all seed data for a schema
-	 */
-	clearSeedData(schemaName: string): void {
-		this.seedData.delete(schemaName.toLowerCase());
-		log('Cleared seed data for: %s', schemaName);
-	}
-
-	/**
-	 * Removes a declared schema and its seed data
-	 */
-	removeDeclaredSchema(schemaName: string): void {
-		this.declaredSchemas.delete(schemaName.toLowerCase());
-		this.seedData.delete(schemaName.toLowerCase());
-		log('Removed declared schema: %s', schemaName);
-	}
-}
-

package/src/schema/function.ts

@@ -1,188 +0,0 @@
-import type { MaybePromise, Row, SqlValue, DeepReadonly } from '../common/types.js';
-import { FunctionFlags } from '../common/constants.js';
-import { SqlDataType } from '../common/types.js';
-import type { Database } from '../core/database.js';
-import type { BaseType, ScalarType, RelationType } from '../common/datatype.js';
-import type { AggValue } from '../func/registration.js';
-import type { LogicalType } from '../types/logical-type.js';
-
-/**
- * Type for a scalar function implementation.
- */
-export type ScalarFunc = (...args: SqlValue[]) => MaybePromise<SqlValue>;
-
-/**
- * Type for a table-valued function implementation.
- */
-export type TableValuedFunc = (...args: SqlValue[]) => MaybePromise<AsyncIterable<Row>>;
-
-/**
- * Type for a database-aware table-valued function implementation.
- * Takes a database instance and SQL values, returns an async iterable of rows.
- */
-export type IntegratedTableValuedFunc = (db: Database, ...args: SqlValue[]) => MaybePromise<AsyncIterable<Row>>;
-
-/**
- * Type for aggregate step function.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AggregateReducer<T = any> = (accumulator: T, ...args: SqlValue[]) => T;
-
-/**
- * Type for aggregate finalizer function.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AggregateFinalizer<T = any> = (accumulator: T) => SqlValue;
-
-/**
- * Custom emitter hook for functions that need special emission logic.
- * This allows functions to cache compiled state in the EmissionContext,
- * optimize constant arguments, or perform other emission-time optimizations.
- */
-export type CustomEmitterHook = (
-	plan: any, // ScalarFunctionCallNode, but we avoid circular dependency
-	ctx: any,  // EmissionContext, but we avoid circular dependency
-	defaultEmit: (plan: any, ctx: any) => any // Instruction
-) => any; // Instruction
-
-/**
- * Base interface for all function schemas with common properties.
- */
-interface BaseFunctionSchema {
-	/** Function name (lowercase for consistent lookup) */
-	name: string;
-	/** Number of arguments (-1 for variable) */
-	numArgs: number;
-	/** Combination of FunctionFlags */
-	flags: FunctionFlags;
-	/** User data pointer passed during registration */
-	userData?: unknown;
-	/** Return type information */
-	returnType: BaseType;
-	/**
-	 * Optional custom emitter hook for emission-time optimizations.
-	 * If provided, this function will be called during plan emission instead of
-	 * the default scalar function emitter. The hook receives the plan node,
-	 * emission context, and a reference to the default emitter.
-	 */
-	customEmitter?: CustomEmitterHook;
-}
-
-/**
- * Schema for scalar functions that return a single value.
- */
-export interface ScalarFunctionSchema extends BaseFunctionSchema {
-	returnType: ScalarType;
-	/** Direct scalar function implementation */
-	implementation: ScalarFunc;
-	/**
-	 * Optional type inference function for polymorphic functions.
-	 * If provided, this function will be called at planning time to determine
-	 * the return type based on the actual argument types.
-	 * This allows functions like abs() to return INTEGER when given INTEGER,
-	 * and REAL when given REAL.
-	 */
-	inferReturnType?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => ScalarType;
-	/**
-	 * Optional argument type validation function.
-	 * If provided, this function will be called at planning time to validate
-	 * that the argument types are acceptable for this function.
-	 * Should return true if types are valid, false otherwise.
-	 */
-	validateArgTypes?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => boolean;
-}
-
-/**
- * Schema for table-valued functions that return rows.
- */
-export interface TableValuedFunctionSchema extends BaseFunctionSchema {
-	returnType: RelationType;
-	/** Table-valued function implementation */
-	implementation: TableValuedFunc | IntegratedTableValuedFunc;
-	/** Whether this TVF requires database access as first parameter */
-	isIntegrated?: boolean;
-}
-
-/**
- * Schema for aggregate functions.
- */
-export interface AggregateFunctionSchema extends BaseFunctionSchema {
-	returnType: ScalarType;
-	/** Aggregate step function */
-	stepFunction: AggregateReducer;
-	/** Aggregate finalizer function */
-	finalizeFunction: AggregateFinalizer;
-	/** Initial accumulator value for aggregates */
-	initialValue?: AggValue;
-	/**
-	 * Optional type inference function for polymorphic aggregate functions.
-	 * If provided, this function will be called at planning time to determine
-	 * the return type based on the actual argument types.
-	 */
-	inferReturnType?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => ScalarType;
-	/**
-	 * Optional argument type validation function.
-	 * If provided, this function will be called at planning time to validate
-	 * that the argument types are acceptable for this function.
-	 */
-	validateArgTypes?: (argTypes: ReadonlyArray<DeepReadonly<LogicalType>>) => boolean;
-}
-
-/**
- * Schema for window functions (for future use).
- */
-export interface WindowFunctionSchema extends BaseFunctionSchema {
-	returnType: ScalarType;
-	/** Window function implementation */
-	implementation: (...args: SqlValue[]) => SqlValue;
-}
-
-/**
- * Union type representing all possible function schemas.
- */
-export type FunctionSchema =
-	| ScalarFunctionSchema
-	| TableValuedFunctionSchema
-	| AggregateFunctionSchema
-	| WindowFunctionSchema;
-
-/**
- * Type guards for function schema types.
- */
-export function isScalarFunctionSchema(schema: FunctionSchema): schema is ScalarFunctionSchema {
-	return schema.returnType.typeClass === 'scalar' && 'implementation' in schema && typeof schema.implementation === 'function';
-}
-
-export function isTableValuedFunctionSchema(schema: FunctionSchema): schema is TableValuedFunctionSchema {
-	return schema.returnType.typeClass === 'relation';
-}
-
-export function isAggregateFunctionSchema(schema: FunctionSchema): schema is AggregateFunctionSchema {
-	return 'stepFunction' in schema && 'finalizeFunction' in schema;
-}
-
-export function isWindowFunctionSchema(schema: FunctionSchema): schema is WindowFunctionSchema {
-	return 'implementation' in schema && schema.returnType.typeClass === 'scalar' && !isScalarFunctionSchema(schema) && !isAggregateFunctionSchema(schema);
-}
-
-/**
- * Creates a consistent key for storing/looking up functions
- *
- * @param name Function name
- * @param numArgs Number of arguments (-1 for variable argument count)
- * @returns A string key in the format "name/numArgs"
- */
-export function getFunctionKey(name: string, numArgs: number): string {
-	return `${name.toLowerCase()}/${numArgs}`;
-}
-
-// Legacy compatibility - deprecated interfaces and column info
-/**
- * @deprecated Use RelationType.columns instead
- * Column information for table-valued functions.
- */
-export interface TVFColumnInfo {
-	name: string;
-	type: SqlDataType;
-	nullable?: boolean;
-}