taurusdb-core 0.1.0

package/dist/engine/helper-modules/parsers.js

@@ -0,0 +1,283 @@
+export function parseProcesslistRows(result) {
+    const columns = result.columns.map((column) => column.name);
+    return result.rows.map((row) => {
+        const mapped = Object.fromEntries(columns.map((name, index) => [name, row[index]]));
+        const timeValue = mapped.time_seconds;
+        return {
+            sessionId: mapped.session_id === undefined ? undefined : String(mapped.session_id),
+            user: typeof mapped.user === "string" ? mapped.user : undefined,
+            host: typeof mapped.host === "string" ? mapped.host : undefined,
+            databaseName: typeof mapped.database_name === "string"
+                ? mapped.database_name
+                : undefined,
+            command: typeof mapped.command === "string" ? mapped.command : undefined,
+            timeSeconds: typeof timeValue === "number"
+                ? timeValue
+                : typeof timeValue === "string" && timeValue.trim().length > 0
+                    ? Number.parseInt(timeValue, 10)
+                    : undefined,
+            state: typeof mapped.state === "string" ? mapped.state : undefined,
+            infoPreview: typeof mapped.info_preview === "string"
+                ? mapped.info_preview
+                : undefined,
+        };
+    });
+}
+export function parseOptionalInteger(value) {
+    return typeof value === "number"
+        ? value
+        : typeof value === "string" && value.trim().length > 0
+            ? Number.parseInt(value, 10)
+            : undefined;
+}
+export function parseLockWaitRows(result) {
+    const columns = result.columns.map((column) => column.name);
+    return result.rows.map((row) => {
+        const mapped = Object.fromEntries(columns.map((name, index) => [name, row[index]]));
+        return {
+            waitingSessionId: mapped.waiting_session_id === undefined
+                ? undefined
+                : String(mapped.waiting_session_id),
+            waitingUser: typeof mapped.waiting_user === "string"
+                ? mapped.waiting_user
+                : undefined,
+            waitingState: typeof mapped.waiting_state === "string"
+                ? mapped.waiting_state
+                : undefined,
+            waitingTrxState: typeof mapped.waiting_trx_state === "string"
+                ? mapped.waiting_trx_state
+                : undefined,
+            waitAgeSeconds: parseOptionalInteger(mapped.wait_age_seconds),
+            blockingSessionId: mapped.blocking_session_id === undefined
+                ? undefined
+                : String(mapped.blocking_session_id),
+            blockingUser: typeof mapped.blocking_user === "string"
+                ? mapped.blocking_user
+                : undefined,
+            blockingState: typeof mapped.blocking_state === "string"
+                ? mapped.blocking_state
+                : undefined,
+            blockingTrxState: typeof mapped.blocking_trx_state === "string"
+                ? mapped.blocking_trx_state
+                : undefined,
+            blockingTrxAgeSeconds: parseOptionalInteger(mapped.blocking_trx_age_seconds),
+            lockedSchema: typeof mapped.locked_schema === "string"
+                ? mapped.locked_schema
+                : undefined,
+            lockedTable: typeof mapped.locked_table === "string"
+                ? mapped.locked_table
+                : undefined,
+            lockedIndex: typeof mapped.locked_index === "string"
+                ? mapped.locked_index
+                : undefined,
+            waitingLockType: typeof mapped.waiting_lock_type === "string"
+                ? mapped.waiting_lock_type
+                : undefined,
+            waitingLockMode: typeof mapped.waiting_lock_mode === "string"
+                ? mapped.waiting_lock_mode
+                : undefined,
+            blockingLockType: typeof mapped.blocking_lock_type === "string"
+                ? mapped.blocking_lock_type
+                : undefined,
+            blockingLockMode: typeof mapped.blocking_lock_mode === "string"
+                ? mapped.blocking_lock_mode
+                : undefined,
+            waitingQuery: typeof mapped.waiting_query === "string"
+                ? mapped.waiting_query
+                : undefined,
+            blockingQuery: typeof mapped.blocking_query === "string"
+                ? mapped.blocking_query
+                : undefined,
+        };
+    });
+}
+export function isIdleTransactionBlocker(row) {
+    return (row.blockingSessionId !== undefined &&
+        row.blockingTrxState !== undefined &&
+        (row.blockingState === undefined || row.blockingState === "Sleep"));
+}
+export function parseOptionalNumber(value) {
+    return typeof value === "number"
+        ? value
+        : typeof value === "string" && value.trim().length > 0
+            ? Number.parseFloat(value)
+            : undefined;
+}
+export function parseMetadataLockRows(result) {
+    const columns = result.columns.map((column) => column.name);
+    return result.rows.map((row) => {
+        const mapped = Object.fromEntries(columns.map((name, index) => [name, row[index]]));
+        return {
+            waitingSessionId: mapped.waiting_session_id === undefined
+                ? undefined
+                : String(mapped.waiting_session_id),
+            waitingUser: typeof mapped.waiting_user === "string"
+                ? mapped.waiting_user
+                : undefined,
+            waitingState: typeof mapped.waiting_state === "string"
+                ? mapped.waiting_state
+                : undefined,
+            blockingSessionId: mapped.blocking_session_id === undefined
+                ? undefined
+                : String(mapped.blocking_session_id),
+            blockingUser: typeof mapped.blocking_user === "string"
+                ? mapped.blocking_user
+                : undefined,
+            blockingState: typeof mapped.blocking_state === "string"
+                ? mapped.blocking_state
+                : undefined,
+            objectType: typeof mapped.object_type === "string" ? mapped.object_type : undefined,
+            objectSchema: typeof mapped.object_schema === "string"
+                ? mapped.object_schema
+                : undefined,
+            objectName: typeof mapped.object_name === "string" ? mapped.object_name : undefined,
+            waitingLockType: typeof mapped.waiting_lock_type === "string"
+                ? mapped.waiting_lock_type
+                : undefined,
+            waitingLockDuration: typeof mapped.waiting_lock_duration === "string"
+                ? mapped.waiting_lock_duration
+                : undefined,
+            blockingLockType: typeof mapped.blocking_lock_type === "string"
+                ? mapped.blocking_lock_type
+                : undefined,
+            blockingLockDuration: typeof mapped.blocking_lock_duration === "string"
+                ? mapped.blocking_lock_duration
+                : undefined,
+        };
+    });
+}
+export function parseDeadlockSummary(result) {
+    const statusColumnIndex = result.columns.findIndex((column) => column.name.toLowerCase() === "status");
+    if (statusColumnIndex < 0 || result.rows.length === 0) {
+        return undefined;
+    }
+    const statusValue = result.rows[0]?.[statusColumnIndex];
+    if (typeof statusValue !== "string" || !statusValue.includes("DEADLOCK")) {
+        return undefined;
+    }
+    const startIndex = statusValue.indexOf("LATEST DETECTED DEADLOCK");
+    if (startIndex < 0) {
+        return undefined;
+    }
+    const deadlockText = statusValue.slice(startIndex);
+    const lines = deadlockText
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !/^[-*]{3,}$/.test(line));
+    const detectedAt = lines.find((line) => /^\d{4}-\d{2}-\d{2}/.test(line));
+    const transactionIds = Array.from(new Set([...deadlockText.matchAll(/TRANSACTION\s+(\d+)/g)].map((match) => match[1])));
+    const tableRefs = Array.from(new Set([...deadlockText.matchAll(/table\s+`([^`]+)`\.`([^`]+)`/gi)].map((match) => `${match[1]}.${match[2]}`)));
+    const summaryLines = lines
+        .filter((line) => !line.startsWith("LATEST DETECTED DEADLOCK") &&
+        !/^\d{4}-\d{2}-\d{2}/.test(line))
+        .slice(0, 3);
+    return {
+        detectedAt,
+        summary: summaryLines.join(" ").slice(0, 400) ||
+            "InnoDB reported a recent deadlock in SHOW ENGINE INNODB STATUS.",
+        waitingTables: tableRefs,
+        blockingTables: tableRefs,
+        transactionIds,
+    };
+}
+export function parseStatementDigestRows(result) {
+    const columns = result.columns.map((column) => column.name);
+    return result.rows.map((row) => {
+        const mapped = Object.fromEntries(columns.map((name, index) => [name, row[index]]));
+        return {
+            schemaName: typeof mapped.schema_name === "string" ? mapped.schema_name : undefined,
+            digest: typeof mapped.digest === "string" ? mapped.digest : undefined,
+            digestText: typeof mapped.digest_text === "string" ? mapped.digest_text : undefined,
+            querySampleText: typeof mapped.query_sample_text === "string"
+                ? mapped.query_sample_text
+                : undefined,
+            execCount: parseOptionalInteger(mapped.exec_count),
+            avgLatencyMs: parseOptionalNumber(mapped.avg_latency_ms),
+            totalLatencyMs: parseOptionalNumber(mapped.total_latency_ms),
+            maxLatencyMs: parseOptionalNumber(mapped.max_latency_ms),
+            avgLockTimeMs: parseOptionalNumber(mapped.avg_lock_time_ms),
+            avgRowsExamined: parseOptionalNumber(mapped.avg_rows_examined),
+            avgSortRows: parseOptionalNumber(mapped.avg_sort_rows),
+            avgTmpTables: parseOptionalNumber(mapped.avg_tmp_tables),
+            avgTmpDiskTables: parseOptionalNumber(mapped.avg_tmp_disk_tables),
+            selectScanCount: parseOptionalInteger(mapped.select_scan_count),
+            noIndexUsedCount: parseOptionalInteger(mapped.no_index_used_count),
+        };
+    });
+}
+export function parseStatementWaitEventRows(result) {
+    const columns = result.columns.map((column) => column.name);
+    return result.rows.map((row) => {
+        const mapped = Object.fromEntries(columns.map((name, index) => [name, row[index]]));
+        return {
+            eventName: typeof mapped.event_name === "string" ? mapped.event_name : undefined,
+            sampleCount: parseOptionalInteger(mapped.sample_count),
+            statementCount: parseOptionalInteger(mapped.statement_count),
+            totalWaitMs: parseOptionalNumber(mapped.total_wait_ms),
+            avgWaitMs: parseOptionalNumber(mapped.avg_wait_ms),
+        };
+    });
+}
+export function parseTableStorageRows(result) {
+    const columns = result.columns.map((column) => column.name);
+    return result.rows.map((row) => {
+        const mapped = Object.fromEntries(columns.map((name, index) => [name, row[index]]));
+        return {
+            schemaName: typeof mapped.schema_name === "string" ? mapped.schema_name : undefined,
+            tableName: typeof mapped.table_name === "string" ? mapped.table_name : undefined,
+            engine: typeof mapped.engine === "string" ? mapped.engine : undefined,
+            rowCountEstimate: parseOptionalInteger(mapped.row_count_estimate),
+            totalMb: parseOptionalNumber(mapped.total_mb),
+            dataMb: parseOptionalNumber(mapped.data_mb),
+            indexMb: parseOptionalNumber(mapped.index_mb),
+            dataFreeMb: parseOptionalNumber(mapped.data_free_mb),
+        };
+    });
+}
+export function parseReplicationStatusRows(result) {
+    const columns = result.columns.map((column) => column.name);
+    return result.rows
+        .map((row) => {
+        const mapped = Object.fromEntries(columns.map((name, index) => [name, row[index]]));
+        const parsed = {
+            channelName: typeof mapped.Channel_Name === "string"
+                ? mapped.Channel_Name
+                : typeof mapped.channel_name === "string"
+                    ? mapped.channel_name
+                    : undefined,
+            replicaIoRunning: typeof mapped.Replica_IO_Running === "string"
+                ? mapped.Replica_IO_Running
+                : typeof mapped.Slave_IO_Running === "string"
+                    ? mapped.Slave_IO_Running
+                    : undefined,
+            replicaSqlRunning: typeof mapped.Replica_SQL_Running === "string"
+                ? mapped.Replica_SQL_Running
+                : typeof mapped.Slave_SQL_Running === "string"
+                    ? mapped.Slave_SQL_Running
+                    : undefined,
+            secondsBehindSource: parseOptionalNumber(mapped.Seconds_Behind_Source) ??
+                parseOptionalNumber(mapped.Seconds_Behind_Master),
+            retrievedGtidSet: typeof mapped.Retrieved_Gtid_Set === "string"
+                ? mapped.Retrieved_Gtid_Set
+                : undefined,
+            executedGtidSet: typeof mapped.Executed_Gtid_Set === "string"
+                ? mapped.Executed_Gtid_Set
+                : undefined,
+            lastIoError: typeof mapped.Last_IO_Error === "string" &&
+                mapped.Last_IO_Error.length > 0
+                ? mapped.Last_IO_Error
+                : undefined,
+            lastSqlError: typeof mapped.Last_SQL_Error === "string" &&
+                mapped.Last_SQL_Error.length > 0
+                ? mapped.Last_SQL_Error
+                : undefined,
+        };
+        return parsed;
+    })
+        .filter((row) => row.channelName !== undefined ||
+        row.replicaIoRunning !== undefined ||
+        row.replicaSqlRunning !== undefined ||
+        row.secondsBehindSource !== undefined ||
+        row.lastIoError !== undefined ||
+        row.lastSqlError !== undefined);
+}

package/dist/engine/helper-modules/sql.d.ts

@@ -0,0 +1,12 @@
+import type { FindTopSlowSqlInput } from "../../diagnostics/types.js";
+import type { ExplainResult } from "../../executor/sql-executor.js";
+import type { StatementDigestRow } from "./types.js";
+export declare function withDatasourceSummary(prefix: string, datasource: string): string;
+export declare function quoteLiteral(value: string): string;
+export declare function escapeLikePrefix(value: string): string;
+export declare function clampInteger(value: number | undefined, fallback: number, min: number, max: number): number;
+export declare function topSlowSqlOrderBy(sortBy: FindTopSlowSqlInput["sortBy"]): string;
+export declare function normalizeSqlForDigestMatch(sql: string): string;
+export declare function digestMatchScore(sql: string, candidate: StatementDigestRow): number;
+export declare function extractPlanTableNames(plan: ExplainResult["plan"]): string[];
+export declare function extractSqlTableNameHints(sql: string): string[];

package/dist/engine/helper-modules/sql.js

@@ -0,0 +1,119 @@
+import { normalizeSql, sqlHash } from "../../utils/hash.js";
+export function withDatasourceSummary(prefix, datasource) {
+    return `${prefix} on datasource ${datasource}.`;
+}
+export function quoteLiteral(value) {
+    return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "''")}'`;
+}
+export function escapeLikePrefix(value) {
+    return value.replace(/\\/g, "\\\\").replace(/[%_]/g, "\\$&");
+}
+export function clampInteger(value, fallback, min, max) {
+    if (value === undefined || !Number.isInteger(value)) {
+        return fallback;
+    }
+    return Math.min(Math.max(value, min), max);
+}
+export function topSlowSqlOrderBy(sortBy) {
+    switch (sortBy) {
+        case "avg_latency":
+            return "AVG_TIMER_WAIT DESC, SUM_TIMER_WAIT DESC, COUNT_STAR DESC";
+        case "exec_count":
+            return "COUNT_STAR DESC, SUM_TIMER_WAIT DESC, AVG_TIMER_WAIT DESC";
+        case "lock_time":
+            return "SUM_LOCK_TIME DESC, SUM_TIMER_WAIT DESC, COUNT_STAR DESC";
+        case "total_latency":
+        default:
+            return "SUM_TIMER_WAIT DESC, AVG_TIMER_WAIT DESC, COUNT_STAR DESC";
+    }
+}
+export function normalizeSqlForDigestMatch(sql) {
+    const normalized = normalizeSql(sql).replace(/`([^`]+)`/g, "$1");
+    let result = "";
+    let index = 0;
+    let quoteState = "none";
+    while (index < normalized.length) {
+        const char = normalized[index];
+        if (quoteState === "none") {
+            if (char === "'" || char === '"') {
+                quoteState = char;
+                result += "?";
+                index += 1;
+                continue;
+            }
+            if (/[0-9]/.test(char) &&
+                (index === 0 || !/[A-Za-z0-9_$]/.test(normalized[index - 1] ?? ""))) {
+                result += "?";
+                index += 1;
+                while (index < normalized.length &&
+                    /[A-Za-z0-9_.+-]/.test(normalized[index])) {
+                    index += 1;
+                }
+                continue;
+            }
+            result += char;
+            index += 1;
+            continue;
+        }
+        if (char === quoteState) {
+            if (normalized[index + 1] === quoteState) {
+                index += 2;
+                continue;
+            }
+            quoteState = "none";
+        }
+        index += 1;
+    }
+    return result
+        .replace(/\bNULL\b/gi, "?")
+        .replace(/\b(TRUE|FALSE)\b/gi, "?")
+        .replace(/\s*([=<>!+\-*/%,()])\s*/g, "$1")
+        .replace(/\s+/g, " ")
+        .trim()
+        .toUpperCase();
+}
+export function digestMatchScore(sql, candidate) {
+    const normalizedSql = normalizeSql(sql);
+    const normalizedSqlHash = sqlHash(normalizedSql);
+    const sqlShape = normalizeSqlForDigestMatch(sql);
+    if (candidate.querySampleText &&
+        sqlHash(normalizeSql(candidate.querySampleText)) === normalizedSqlHash) {
+        return 100;
+    }
+    if (candidate.querySampleText &&
+        normalizeSqlForDigestMatch(candidate.querySampleText) === sqlShape) {
+        return 80;
+    }
+    if (candidate.digestText &&
+        normalizeSqlForDigestMatch(candidate.digestText) === sqlShape) {
+        return 70;
+    }
+    return 0;
+}
+export function extractPlanTableNames(plan) {
+    const names = plan
+        .map((row) => {
+        if (!row || typeof row !== "object") {
+            return undefined;
+        }
+        const candidate = row.table ??
+            row.table_name ??
+            row.TABLE;
+        return typeof candidate === "string" ? candidate.trim() : undefined;
+    })
+        .filter((value) => typeof value === "string" &&
+        value.length > 0 &&
+        value.toUpperCase() !== "NULL" &&
+        !value.startsWith("<"));
+    return [...new Set(names)];
+}
+export function extractSqlTableNameHints(sql) {
+    const hints = new Set();
+    const pattern = /\b(?:FROM|JOIN|UPDATE|INTO)\s+`?([A-Za-z0-9_$]+)`?(?:\s*\.\s*`?([A-Za-z0-9_$]+)`?)?/gi;
+    let match = pattern.exec(sql);
+    while (match) {
+        hints.add(match[2] ?? match[1]);
+        match = pattern.exec(sql);
+    }
+    return [...hints];
+}

package/dist/engine/helper-modules/types.d.ts

@@ -0,0 +1,103 @@
+export type ProcesslistRow = {
+    sessionId?: string;
+    user?: string;
+    host?: string;
+    databaseName?: string;
+    command?: string;
+    timeSeconds?: number;
+    state?: string;
+    infoPreview?: string;
+};
+export type LockWaitRow = {
+    waitingSessionId?: string;
+    waitingUser?: string;
+    waitingState?: string;
+    waitingTrxState?: string;
+    waitAgeSeconds?: number;
+    blockingSessionId?: string;
+    blockingUser?: string;
+    blockingState?: string;
+    blockingTrxState?: string;
+    blockingTrxAgeSeconds?: number;
+    lockedSchema?: string;
+    lockedTable?: string;
+    lockedIndex?: string;
+    waitingLockType?: string;
+    waitingLockMode?: string;
+    blockingLockType?: string;
+    blockingLockMode?: string;
+    waitingQuery?: string;
+    blockingQuery?: string;
+};
+export type MetadataLockRow = {
+    waitingSessionId?: string;
+    waitingUser?: string;
+    waitingState?: string;
+    blockingSessionId?: string;
+    blockingUser?: string;
+    blockingState?: string;
+    objectType?: string;
+    objectSchema?: string;
+    objectName?: string;
+    waitingLockType?: string;
+    waitingLockDuration?: string;
+    blockingLockType?: string;
+    blockingLockDuration?: string;
+};
+export type DeadlockSummary = {
+    detectedAt?: string;
+    summary: string;
+    waitingTables: string[];
+    blockingTables: string[];
+    transactionIds: string[];
+};
+export type StatementDigestRow = {
+    schemaName?: string;
+    digest?: string;
+    digestText?: string;
+    querySampleText?: string;
+    execCount?: number;
+    avgLatencyMs?: number;
+    totalLatencyMs?: number;
+    maxLatencyMs?: number;
+    avgLockTimeMs?: number;
+    avgRowsExamined?: number;
+    avgSortRows?: number;
+    avgTmpTables?: number;
+    avgTmpDiskTables?: number;
+    selectScanCount?: number;
+    noIndexUsedCount?: number;
+};
+export type StatementWaitEventRow = {
+    eventName?: string;
+    sampleCount?: number;
+    statementCount?: number;
+    totalWaitMs?: number;
+    avgWaitMs?: number;
+};
+export type PlanTableStats = {
+    table: string;
+    rowCountEstimate?: number;
+    indexCount: number;
+    primaryKey?: string[];
+};
+export type TableStorageRow = {
+    schemaName?: string;
+    tableName?: string;
+    engine?: string;
+    rowCountEstimate?: number;
+    totalMb?: number;
+    dataMb?: number;
+    indexMb?: number;
+    dataFreeMb?: number;
+};
+export type ReplicationStatusRow = {
+    channelName?: string;
+    replicaIoRunning?: string;
+    replicaSqlRunning?: string;
+    secondsBehindSource?: number;
+    retrievedGtidSet?: string;
+    executedGtidSet?: string;
+    lastIoError?: string;
+    lastSqlError?: string;
+};

package/dist/engine/helper-modules/types.js

@@ -0,0 +1 @@
+export {};

package/dist/engine/helpers.d.ts

@@ -0,0 +1,4 @@
+export * from "./helper-modules/types.js";
+export * from "./helper-modules/parsers.js";
+export * from "./helper-modules/sql.js";
+export * from "./helper-modules/diagnostics.js";

package/dist/engine/helpers.js

@@ -0,0 +1,4 @@
+export * from "./helper-modules/types.js";
+export * from "./helper-modules/parsers.js";
+export * from "./helper-modules/sql.js";
+export * from "./helper-modules/diagnostics.js";

package/dist/engine/runtime.d.ts

@@ -0,0 +1,20 @@
+import type { SessionContext } from "../context/session-context.js";
+import type { CancelResult, ExplainResult, MutationOptions, MutationResult, QueryResult, QueryStatus, ReadonlyOptions } from "../executor/sql-executor.js";
+import type { ConfirmationToken, ConfirmationValidationResult } from "../safety/confirmation-store.js";
+import type { GuardrailDecision } from "../safety/guardrail.js";
+import { type FlashbackInput } from "../taurus/flashback.js";
+import { type RestoreRecycleBinTableInput } from "../taurus/recycle-bin.js";
+import type { ConfirmationOutcome, EnhancedExplainResult, IssueConfirmationInput, TaurusDBEngine } from "../engine.js";
+export declare function explain(engine: TaurusDBEngine, sql: string, ctx: SessionContext): Promise<ExplainResult>;
+export declare function explainEnhanced(engine: TaurusDBEngine, sql: string, ctx: SessionContext): Promise<EnhancedExplainResult>;
+export declare function executeReadonly(engine: TaurusDBEngine, sql: string, ctx: SessionContext, opts?: ReadonlyOptions): Promise<QueryResult>;
+export declare function executeMutation(engine: TaurusDBEngine, sql: string, ctx: SessionContext, opts?: MutationOptions): Promise<MutationResult>;
+export declare function flashbackQuery(engine: TaurusDBEngine, input: FlashbackInput, ctx: SessionContext, opts?: ReadonlyOptions): Promise<QueryResult>;
+export declare function listRecycleBin(engine: TaurusDBEngine, ctx: SessionContext, opts?: ReadonlyOptions): Promise<QueryResult>;
+export declare function restoreRecycleBinTable(engine: TaurusDBEngine, input: RestoreRecycleBinTableInput, ctx: SessionContext, opts?: MutationOptions): Promise<MutationResult>;
+export declare function getQueryStatus(engine: TaurusDBEngine, queryId: string): Promise<QueryStatus>;
+export declare function cancelQuery(engine: TaurusDBEngine, queryId: string): Promise<CancelResult>;
+export declare function issueConfirmation(engine: TaurusDBEngine, input: IssueConfirmationInput): Promise<ConfirmationToken>;
+export declare function validateConfirmation(engine: TaurusDBEngine, token: string, sql: string, ctx: SessionContext): Promise<ConfirmationValidationResult>;
+export declare function handleConfirmation(engine: TaurusDBEngine, decision: GuardrailDecision, ctx: SessionContext): Promise<ConfirmationOutcome>;
+export declare function close(engine: TaurusDBEngine): Promise<void>;