@devrev/meerkat-core 0.0.77

package/src/types/duckdb-serialization-types/serialization/Expression.js

@@ -0,0 +1,130 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ExpressionType: function() {
+        return ExpressionType;
+    },
+    ExpressionClass: function() {
+        return ExpressionClass;
+    }
+});
+var ExpressionType;
+(function(ExpressionType) {
+    ExpressionType["INVALID"] = "INVALID";
+    ExpressionType["OPERATOR_CAST"] = "OPERATOR_CAST";
+    ExpressionType["OPERATOR_NOT"] = "OPERATOR_NOT";
+    ExpressionType["OPERATOR_IS_NULL"] = "OPERATOR_IS_NULL";
+    ExpressionType["OPERATOR_IS_NOT_NULL"] = "OPERATOR_IS_NOT_NULL";
+    ExpressionType["COMPARE_EQUAL"] = "COMPARE_EQUAL";
+    ExpressionType["COMPARE_BOUNDARY_START"] = "COMPARE_BOUNDARY_START";
+    ExpressionType["COMPARE_NOTEQUAL"] = "COMPARE_NOTEQUAL";
+    ExpressionType["COMPARE_LESSTHAN"] = "COMPARE_LESSTHAN";
+    ExpressionType["COMPARE_GREATERTHAN"] = "COMPARE_GREATERTHAN";
+    ExpressionType["COMPARE_LESSTHANOREQUALTO"] = "COMPARE_LESSTHANOREQUALTO";
+    ExpressionType["COMPARE_GREATERTHANOREQUALTO"] = "COMPARE_GREATERTHANOREQUALTO";
+    ExpressionType["COMPARE_IN"] = "COMPARE_IN";
+    ExpressionType["COMPARE_NOT_IN"] = "COMPARE_NOT_IN";
+    ExpressionType["COMPARE_DISTINCT_FROM"] = "COMPARE_DISTINCT_FROM";
+    ExpressionType["COMPARE_BETWEEN"] = "COMPARE_BETWEEN";
+    ExpressionType["COMPARE_NOT_BETWEEN"] = "COMPARE_NOT_BETWEEN";
+    ExpressionType["COMPARE_NOT_DISTINCT_FROM"] = "COMPARE_NOT_DISTINCT_FROM";
+    ExpressionType["COMPARE_BOUNDARY_END"] = "COMPARE_BOUNDARY_END";
+    ExpressionType["CONJUNCTION_AND"] = "CONJUNCTION_AND";
+    ExpressionType["CONJUNCTION_OR"] = "CONJUNCTION_OR";
+    ExpressionType["VALUE_CONSTANT"] = "VALUE_CONSTANT";
+    ExpressionType["VALUE_PARAMETER"] = "VALUE_PARAMETER";
+    ExpressionType["VALUE_TUPLE"] = "VALUE_TUPLE";
+    ExpressionType["VALUE_TUPLE_ADDRESS"] = "VALUE_TUPLE_ADDRESS";
+    ExpressionType["VALUE_NULL"] = "VALUE_NULL";
+    ExpressionType["VALUE_VECTOR"] = "VALUE_VECTOR";
+    ExpressionType["VALUE_SCALAR"] = "VALUE_SCALAR";
+    ExpressionType["VALUE_DEFAULT"] = "VALUE_DEFAULT";
+    ExpressionType["AGGREGATE"] = "AGGREGATE";
+    ExpressionType["BOUND_AGGREGATE"] = "BOUND_AGGREGATE";
+    ExpressionType["GROUPING_FUNCTION"] = "GROUPING_FUNCTION";
+    ExpressionType["WINDOW_AGGREGATE"] = "WINDOW_AGGREGATE";
+    ExpressionType["WINDOW_RANK"] = "WINDOW_RANK";
+    ExpressionType["WINDOW_RANK_DENSE"] = "WINDOW_RANK_DENSE";
+    ExpressionType["WINDOW_NTILE"] = "WINDOW_NTILE";
+    ExpressionType["WINDOW_PERCENT_RANK"] = "WINDOW_PERCENT_RANK";
+    ExpressionType["WINDOW_CUME_DIST"] = "WINDOW_CUME_DIST";
+    ExpressionType["WINDOW_ROW_NUMBER"] = "WINDOW_ROW_NUMBER";
+    ExpressionType["WINDOW_FIRST_VALUE"] = "WINDOW_FIRST_VALUE";
+    ExpressionType["WINDOW_LAST_VALUE"] = "WINDOW_LAST_VALUE";
+    ExpressionType["WINDOW_LEAD"] = "WINDOW_LEAD";
+    ExpressionType["WINDOW_LAG"] = "WINDOW_LAG";
+    ExpressionType["WINDOW_NTH_VALUE"] = "WINDOW_NTH_VALUE";
+    ExpressionType["FUNCTION"] = "FUNCTION";
+    ExpressionType["BOUND_FUNCTION"] = "BOUND_FUNCTION";
+    ExpressionType["CASE_EXPR"] = "CASE_EXPR";
+    ExpressionType["OPERATOR_NULLIF"] = "OPERATOR_NULLIF";
+    ExpressionType["OPERATOR_COALESCE"] = "OPERATOR_COALESCE";
+    ExpressionType["ARRAY_EXTRACT"] = "ARRAY_EXTRACT";
+    ExpressionType["ARRAY_SLICE"] = "ARRAY_SLICE";
+    ExpressionType["STRUCT_EXTRACT"] = "STRUCT_EXTRACT";
+    ExpressionType["ARRAY_CONSTRUCTOR"] = "ARRAY_CONSTRUCTOR";
+    ExpressionType["ARROW"] = "ARROW";
+    ExpressionType["SUBQUERY"] = "SUBQUERY";
+    ExpressionType["STAR"] = "STAR";
+    ExpressionType["TABLE_STAR"] = "TABLE_STAR";
+    ExpressionType["PLACEHOLDER"] = "PLACEHOLDER";
+    ExpressionType["COLUMN_REF"] = "COLUMN_REF";
+    ExpressionType["FUNCTION_REF"] = "FUNCTION_REF";
+    ExpressionType["TABLE_REF"] = "TABLE_REF";
+    ExpressionType["CAST"] = "CAST";
+    ExpressionType["BOUND_REF"] = "BOUND_REF";
+    ExpressionType["BOUND_COLUMN_REF"] = "BOUND_COLUMN_REF";
+    ExpressionType["BOUND_UNNEST"] = "BOUND_UNNEST";
+    ExpressionType["COLLATE"] = "COLLATE";
+    ExpressionType["LAMBDA"] = "LAMBDA";
+    ExpressionType["POSITIONAL_REFERENCE"] = "POSITIONAL_REFERENCE";
+    ExpressionType["BOUND_LAMBDA_REF"] = "BOUND_LAMBDA_REF";
+})(ExpressionType || (ExpressionType = {}));
+var ExpressionClass;
+(function(ExpressionClass) {
+    ExpressionClass["INVALID"] = "INVALID";
+    ExpressionClass["AGGREGATE"] = "AGGREGATE";
+    ExpressionClass["CASE"] = "CASE";
+    ExpressionClass["CAST"] = "CAST";
+    ExpressionClass["COLUMN_REF"] = "COLUMN_REF";
+    ExpressionClass["COMPARISON"] = "COMPARISON";
+    ExpressionClass["CONJUNCTION"] = "CONJUNCTION";
+    ExpressionClass["CONSTANT"] = "CONSTANT";
+    ExpressionClass["DEFAULT"] = "DEFAULT";
+    ExpressionClass["FUNCTION"] = "FUNCTION";
+    ExpressionClass["OPERATOR"] = "OPERATOR";
+    ExpressionClass["STAR"] = "STAR";
+    ExpressionClass["SUBQUERY"] = "SUBQUERY";
+    ExpressionClass["WINDOW"] = "WINDOW";
+    ExpressionClass["PARAMETER"] = "PARAMETER";
+    ExpressionClass["COLLATE"] = "COLLATE";
+    ExpressionClass["LAMBDA"] = "LAMBDA";
+    ExpressionClass["POSITIONAL_REFERENCE"] = "POSITIONAL_REFERENCE";
+    ExpressionClass["BETWEEN"] = "BETWEEN";
+    ExpressionClass["BOUND_AGGREGATE"] = "BOUND_AGGREGATE";
+    ExpressionClass["BOUND_CASE"] = "BOUND_CASE";
+    ExpressionClass["BOUND_CAST"] = "BOUND_CAST";
+    ExpressionClass["BOUND_COLUMN_REF"] = "BOUND_COLUMN_REF";
+    ExpressionClass["BOUND_COMPARISON"] = "BOUND_COMPARISON";
+    ExpressionClass["BOUND_CONJUNCTION"] = "BOUND_CONJUNCTION";
+    ExpressionClass["BOUND_CONSTANT"] = "BOUND_CONSTANT";
+    ExpressionClass["BOUND_DEFAULT"] = "BOUND_DEFAULT";
+    ExpressionClass["BOUND_FUNCTION"] = "BOUND_FUNCTION";
+    ExpressionClass["BOUND_OPERATOR"] = "BOUND_OPERATOR";
+    ExpressionClass["BOUND_PARAMETER"] = "BOUND_PARAMETER";
+    ExpressionClass["BOUND_REF"] = "BOUND_REF";
+    ExpressionClass["BOUND_SUBQUERY"] = "BOUND_SUBQUERY";
+    ExpressionClass["BOUND_WINDOW"] = "BOUND_WINDOW";
+    ExpressionClass["BOUND_BETWEEN"] = "BOUND_BETWEEN";
+    ExpressionClass["BOUND_UNNEST"] = "BOUND_UNNEST";
+    ExpressionClass["BOUND_LAMBDA"] = "BOUND_LAMBDA";
+    ExpressionClass["BOUND_LAMBDA_REF"] = "BOUND_LAMBDA_REF";
+    ExpressionClass["BOUND_EXPRESSION"] = "BOUND_EXPRESSION";
+})(ExpressionClass || (ExpressionClass = {}));
+
+//# sourceMappingURL=Expression.js.map

package/src/types/duckdb-serialization-types/serialization/Expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Expression.ts"],"sourcesContent":["import { Value } from './Misc';\nimport {\n  BoundCaseCheck,\n  BoundParameterData,\n  ColumnBinding,\n  LogicalType,\n} from './Nodes';\n\nexport enum ExpressionType {\n  INVALID = 'INVALID',\n  OPERATOR_CAST = 'OPERATOR_CAST',\n  OPERATOR_NOT = 'OPERATOR_NOT',\n  OPERATOR_IS_NULL = 'OPERATOR_IS_NULL',\n  OPERATOR_IS_NOT_NULL = 'OPERATOR_IS_NOT_NULL',\n  COMPARE_EQUAL = 'COMPARE_EQUAL',\n  COMPARE_BOUNDARY_START = 'COMPARE_BOUNDARY_START',\n  COMPARE_NOTEQUAL = 'COMPARE_NOTEQUAL',\n  COMPARE_LESSTHAN = 'COMPARE_LESSTHAN',\n  COMPARE_GREATERTHAN = 'COMPARE_GREATERTHAN',\n  COMPARE_LESSTHANOREQUALTO = 'COMPARE_LESSTHANOREQUALTO',\n  COMPARE_GREATERTHANOREQUALTO = 'COMPARE_GREATERTHANOREQUALTO',\n  COMPARE_IN = 'COMPARE_IN',\n  COMPARE_NOT_IN = 'COMPARE_NOT_IN',\n  COMPARE_DISTINCT_FROM = 'COMPARE_DISTINCT_FROM',\n  COMPARE_BETWEEN = 'COMPARE_BETWEEN',\n  COMPARE_NOT_BETWEEN = 'COMPARE_NOT_BETWEEN',\n  COMPARE_NOT_DISTINCT_FROM = 'COMPARE_NOT_DISTINCT_FROM',\n  COMPARE_BOUNDARY_END = 'COMPARE_BOUNDARY_END',\n  CONJUNCTION_AND = 'CONJUNCTION_AND',\n  CONJUNCTION_OR = 'CONJUNCTION_OR',\n  VALUE_CONSTANT = 'VALUE_CONSTANT',\n  VALUE_PARAMETER = 'VALUE_PARAMETER',\n  VALUE_TUPLE = 'VALUE_TUPLE',\n  VALUE_TUPLE_ADDRESS = 'VALUE_TUPLE_ADDRESS',\n  VALUE_NULL = 'VALUE_NULL',\n  VALUE_VECTOR = 'VALUE_VECTOR',\n  VALUE_SCALAR = 'VALUE_SCALAR',\n  VALUE_DEFAULT = 'VALUE_DEFAULT',\n  AGGREGATE = 'AGGREGATE',\n  BOUND_AGGREGATE = 'BOUND_AGGREGATE',\n  GROUPING_FUNCTION = 'GROUPING_FUNCTION',\n  WINDOW_AGGREGATE = 'WINDOW_AGGREGATE',\n  WINDOW_RANK = 'WINDOW_RANK',\n  WINDOW_RANK_DENSE = 'WINDOW_RANK_DENSE',\n  WINDOW_NTILE = 'WINDOW_NTILE',\n  WINDOW_PERCENT_RANK = 'WINDOW_PERCENT_RANK',\n  WINDOW_CUME_DIST = 'WINDOW_CUME_DIST',\n  WINDOW_ROW_NUMBER = 'WINDOW_ROW_NUMBER',\n  WINDOW_FIRST_VALUE = 'WINDOW_FIRST_VALUE',\n  WINDOW_LAST_VALUE = 'WINDOW_LAST_VALUE',\n  WINDOW_LEAD = 'WINDOW_LEAD',\n  WINDOW_LAG = 'WINDOW_LAG',\n  WINDOW_NTH_VALUE = 'WINDOW_NTH_VALUE',\n  FUNCTION = 'FUNCTION',\n  BOUND_FUNCTION = 'BOUND_FUNCTION',\n  CASE_EXPR = 'CASE_EXPR',\n  OPERATOR_NULLIF = 'OPERATOR_NULLIF',\n  OPERATOR_COALESCE = 'OPERATOR_COALESCE',\n  ARRAY_EXTRACT = 'ARRAY_EXTRACT',\n  ARRAY_SLICE = 'ARRAY_SLICE',\n  STRUCT_EXTRACT = 'STRUCT_EXTRACT',\n  ARRAY_CONSTRUCTOR = 'ARRAY_CONSTRUCTOR',\n  ARROW = 'ARROW',\n  SUBQUERY = 'SUBQUERY',\n  STAR = 'STAR',\n  TABLE_STAR = 'TABLE_STAR',\n  PLACEHOLDER = 'PLACEHOLDER',\n  COLUMN_REF = 'COLUMN_REF',\n  FUNCTION_REF = 'FUNCTION_REF',\n  TABLE_REF = 'TABLE_REF',\n  CAST = 'CAST',\n  BOUND_REF = 'BOUND_REF',\n  BOUND_COLUMN_REF = 'BOUND_COLUMN_REF',\n  BOUND_UNNEST = 'BOUND_UNNEST',\n  COLLATE = 'COLLATE',\n  LAMBDA = 'LAMBDA',\n  POSITIONAL_REFERENCE = 'POSITIONAL_REFERENCE',\n  BOUND_LAMBDA_REF = 'BOUND_LAMBDA_REF',\n}\n\nexport enum ExpressionClass {\n  INVALID = 'INVALID',\n  AGGREGATE = 'AGGREGATE',\n  CASE = 'CASE',\n  CAST = 'CAST',\n  COLUMN_REF = 'COLUMN_REF',\n  COMPARISON = 'COMPARISON',\n  CONJUNCTION = 'CONJUNCTION',\n  CONSTANT = 'CONSTANT',\n  DEFAULT = 'DEFAULT',\n  FUNCTION = 'FUNCTION',\n  OPERATOR = 'OPERATOR',\n  STAR = 'STAR',\n  SUBQUERY = 'SUBQUERY',\n  WINDOW = 'WINDOW',\n  PARAMETER = 'PARAMETER',\n  COLLATE = 'COLLATE',\n  LAMBDA = 'LAMBDA',\n  POSITIONAL_REFERENCE = 'POSITIONAL_REFERENCE',\n  BETWEEN = 'BETWEEN',\n  BOUND_AGGREGATE = 'BOUND_AGGREGATE',\n  BOUND_CASE = 'BOUND_CASE',\n  BOUND_CAST = 'BOUND_CAST',\n  BOUND_COLUMN_REF = 'BOUND_COLUMN_REF',\n  BOUND_COMPARISON = 'BOUND_COMPARISON',\n  BOUND_CONJUNCTION = 'BOUND_CONJUNCTION',\n  BOUND_CONSTANT = 'BOUND_CONSTANT',\n  BOUND_DEFAULT = 'BOUND_DEFAULT',\n  BOUND_FUNCTION = 'BOUND_FUNCTION',\n  BOUND_OPERATOR = 'BOUND_OPERATOR',\n  BOUND_PARAMETER = 'BOUND_PARAMETER',\n  BOUND_REF = 'BOUND_REF',\n  BOUND_SUBQUERY = 'BOUND_SUBQUERY',\n  BOUND_WINDOW = 'BOUND_WINDOW',\n  BOUND_BETWEEN = 'BOUND_BETWEEN',\n  BOUND_UNNEST = 'BOUND_UNNEST',\n  BOUND_LAMBDA = 'BOUND_LAMBDA',\n  BOUND_LAMBDA_REF = 'BOUND_LAMBDA_REF',\n  BOUND_EXPRESSION = 'BOUND_EXPRESSION',\n}\n\nexport interface BaseExpression {\n  expression_class: ExpressionClass;\n  type: ExpressionType;\n  alias: string;\n}\n\nexport type Expression =\n  | BoundBetweenExpression\n  | BoundCaseExpression\n  | BoundCastExpression\n  | BoundColumnRefExpression\n  | BoundComparisonExpression\n  | BoundConjunctionExpression\n  | BoundConstantExpression\n  | BoundDefaultExpression\n  | BoundLambdaExpression\n  | BoundLambdaRefExpression\n  | BoundOperatorExpression\n  | BoundParameterExpression\n  | BoundReferenceExpression\n  | BoundUnnestExpression\n  | BoundFunctionExpression\n  | BoundAggregateExpression\n  | BoundWindowExpression;\n\nexport interface BoundBetweenExpression extends BaseExpression {\n  input: Expression;\n  lower: Expression;\n  upper: Expression;\n  lower_inclusive: boolean;\n  upper_inclusive: boolean;\n}\n\nexport interface BoundCaseExpression extends BaseExpression {\n  return_type: LogicalType;\n  case_checks: BoundCaseCheck[];\n  else_expr: Expression;\n}\n\nexport interface BoundCastExpression extends BaseExpression {\n  child: Expression;\n  return_type: LogicalType;\n  try_cast: boolean;\n}\n\nexport interface BoundColumnRefExpression extends BaseExpression {\n  return_type: LogicalType;\n  binding: ColumnBinding;\n  depth: number;\n}\n\nexport interface BoundComparisonExpression extends BaseExpression {\n  left: Expression;\n  right: Expression;\n}\n\nexport interface BoundConjunctionExpression extends BaseExpression {\n  children: Expression[];\n}\n\nexport interface BoundConstantExpression extends BaseExpression {\n  value: Value;\n}\n\nexport interface BoundDefaultExpression extends BaseExpression {\n  return_type: LogicalType;\n}\n\nexport interface BoundLambdaExpression extends BaseExpression {\n  return_type: LogicalType;\n  lambda_expr: Expression;\n  captures: Expression[];\n  parameter_count: number;\n}\n\nexport interface BoundLambdaRefExpression extends BaseExpression {\n  return_type: LogicalType;\n  binding: ColumnBinding;\n  lambda_index: number;\n  depth: number;\n}\n\nexport interface BoundOperatorExpression extends BaseExpression {\n  return_type: LogicalType;\n  children: Expression[];\n}\n\nexport interface BoundParameterExpression extends BaseExpression {\n  identifier: string;\n  return_type: LogicalType;\n  parameter_data: BoundParameterData;\n}\n\nexport interface BoundReferenceExpression extends BaseExpression {\n  return_type: LogicalType;\n  index: number;\n}\n\nexport interface BoundUnnestExpression extends BaseExpression {\n  return_type: LogicalType;\n  child: Expression;\n}\n\nexport type BoundFunctionExpression = BaseExpression;\n\nexport type BoundAggregateExpression = BaseExpression;\n\nexport type BoundWindowExpression = BaseExpression;\n"],"names":["ExpressionType","INVALID","OPERATOR_CAST","OPERATOR_NOT","OPERATOR_IS_NULL","OPERATOR_IS_NOT_NULL","COMPARE_EQUAL","COMPARE_BOUNDARY_START","COMPARE_NOTEQUAL","COMPARE_LESSTHAN","COMPARE_GREATERTHAN","COMPARE_LESSTHANOREQUALTO","COMPARE_GREATERTHANOREQUALTO","COMPARE_IN","COMPARE_NOT_IN","COMPARE_DISTINCT_FROM","COMPARE_BETWEEN","COMPARE_NOT_BETWEEN","COMPARE_NOT_DISTINCT_FROM","COMPARE_BOUNDARY_END","CONJUNCTION_AND","CONJUNCTION_OR","VALUE_CONSTANT","VALUE_PARAMETER","VALUE_TUPLE","VALUE_TUPLE_ADDRESS","VALUE_NULL","VALUE_VECTOR","VALUE_SCALAR","VALUE_DEFAULT","AGGREGATE","BOUND_AGGREGATE","GROUPING_FUNCTION","WINDOW_AGGREGATE","WINDOW_RANK","WINDOW_RANK_DENSE","WINDOW_NTILE","WINDOW_PERCENT_RANK","WINDOW_CUME_DIST","WINDOW_ROW_NUMBER","WINDOW_FIRST_VALUE","WINDOW_LAST_VALUE","WINDOW_LEAD","WINDOW_LAG","WINDOW_NTH_VALUE","FUNCTION","BOUND_FUNCTION","CASE_EXPR","OPERATOR_NULLIF","OPERATOR_COALESCE","ARRAY_EXTRACT","ARRAY_SLICE","STRUCT_EXTRACT","ARRAY_CONSTRUCTOR","ARROW","SUBQUERY","STAR","TABLE_STAR","PLACEHOLDER","COLUMN_REF","FUNCTION_REF","TABLE_REF","CAST","BOUND_REF","BOUND_COLUMN_REF","BOUND_UNNEST","COLLATE","LAMBDA","POSITIONAL_REFERENCE","BOUND_LAMBDA_REF","ExpressionClass","CASE","COMPARISON","CONJUNCTION","CONSTANT","DEFAULT","OPERATOR","WINDOW","PARAMETER","BETWEEN","BOUND_CASE","BOUND_CAST","BOUND_COMPARISON","BOUND_CONJUNCTION","BOUND_CONSTANT","BOUND_DEFAULT","BOUND_OPERATOR","BOUND_PARAMETER","BOUND_SUBQUERY","BOUND_WINDOW","BOUND_BETWEEN","BOUND_LAMBDA","BOUND_EXPRESSION"],"mappings":"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"}

package/src/types/duckdb-serialization-types/serialization/LogicalOperator.d.ts

@@ -0,0 +1,231 @@
+import { PhysicalIndex } from './Constraint';
+import { CreateInfo } from './CreateInfo';
+import { Expression } from './Expression';
+import { ColumnDataCollection, Value } from './Misc';
+import { BoundOrderByNode, BoundPivotInfo, CTEMaterialize, ColumnBinding, JoinCondition, LogicalType, SampleOptions } from './Nodes';
+import { ParseInfo } from './ParseInfo';
+import { BoundOrderModifier } from './ResultModifier';
+import { JoinType } from './TableRef';
+export interface BaseLogicalOperator {
+    id?: number;
+    name?: string;
+    type: string;
+    children?: LogicalOperator[];
+}
+export type LogicalOperator = LogicalProjection | LogicalFilter | LogicalAggregate | LogicalWindow | LogicalUnnest | LogicalLimit | LogicalOrder | LogicalTopN | LogicalDistinct | LogicalSample | LogicalLimitPercent | LogicalColumnDataGet | LogicalDelimGet | LogicalExpressionGet | LogicalDummyScan | LogicalEmptyResult | LogicalCTERef | LogicalComparisonJoin | LogicalAnyJoin | LogicalCrossProduct | LogicalPositionalJoin | LogicalSetOperation | LogicalRecursiveCTE | LogicalMaterializedCTE | LogicalInsert | LogicalDelete | LogicalUpdate | LogicalCreateTable | LogicalCreate | LogicalExplain | LogicalShow | LogicalSet | LogicalReset | LogicalSimple | LogicalPivot | LogicalGet | LogicalCopyToFile | LogicalCreateIndex | LogicalExtensionOperator;
+export interface LogicalProjection extends BaseLogicalOperator {
+    table_index: number;
+    expressions: Expression[];
+}
+export interface LogicalFilter extends BaseLogicalOperator {
+    expressions: Expression[];
+    projection_map: number[];
+}
+export interface LogicalAggregate extends BaseLogicalOperator {
+    expressions: Expression[];
+    group_index: number;
+    aggregate_index: number;
+    groupings_index: number;
+    groups: Expression[];
+    grouping_sets: Set<number>[];
+    grouping_functions: number[][];
+}
+export interface LogicalWindow extends BaseLogicalOperator {
+    window_index: number;
+    expressions: Expression[];
+}
+export interface LogicalUnnest extends BaseLogicalOperator {
+    unnest_index: number;
+    expressions: Expression[];
+}
+export interface LogicalLimit extends BaseLogicalOperator {
+    limit_val: number;
+    offset_val: number;
+    limit?: Expression;
+    offset?: Expression;
+}
+export interface LogicalOrder extends BaseLogicalOperator {
+    orders: BoundOrderByNode[];
+    projections: number[];
+}
+export interface LogicalTopN extends BaseLogicalOperator {
+    orders: BoundOrderByNode[];
+    limit: number;
+    offset: number;
+}
+export declare enum DistinctType {
+    DISTINCT = "DISTINCT",
+    DISTINCT_ON = "DISTINCT_ON"
+}
+export interface LogicalDistinct extends BaseLogicalOperator {
+    distinct_type: DistinctType;
+    distinct_targets: Expression[];
+    order_by?: BoundOrderModifier;
+}
+export interface LogicalSample extends BaseLogicalOperator {
+    sample_options: SampleOptions;
+}
+export interface LogicalLimitPercent extends BaseLogicalOperator {
+    limit_percent: number;
+    offset_val: number;
+    limit?: Expression;
+    offset?: Expression;
+}
+export interface LogicalColumnDataGet extends BaseLogicalOperator {
+    table_index: number;
+    chunk_types: LogicalType[];
+    collection: ColumnDataCollection;
+}
+export interface LogicalDelimGet extends BaseLogicalOperator {
+    table_index: number;
+    chunk_types: LogicalType[];
+}
+export interface LogicalExpressionGet extends BaseLogicalOperator {
+    table_index: number;
+    expr_types: LogicalType[];
+    expressions: Expression[][];
+}
+export interface LogicalDummyScan extends BaseLogicalOperator {
+    table_index: number;
+}
+export interface LogicalEmptyResult extends BaseLogicalOperator {
+    return_types: LogicalType[];
+    bindings: ColumnBinding[];
+}
+export interface LogicalCTERef extends BaseLogicalOperator {
+    table_index: number;
+    cte_index: number;
+    chunk_types: LogicalType[];
+    bound_columns: string[];
+    materialized_cte: CTEMaterialize;
+}
+export interface LogicalComparisonJoin extends BaseLogicalOperator {
+    join_type: JoinType;
+    mark_index: number;
+    left_projection_map: number[];
+    right_projection_map: number[];
+    conditions: JoinCondition[];
+    mark_types: LogicalType[];
+    duplicate_eliminated_columns: Expression[];
+}
+export interface LogicalAnyJoin extends BaseLogicalOperator {
+    join_type: JoinType;
+    mark_index: number;
+    left_projection_map: number[];
+    right_projection_map: number[];
+    condition: Expression;
+}
+export type LogicalCrossProduct = BaseLogicalOperator;
+export type LogicalPositionalJoin = BaseLogicalOperator;
+export interface LogicalSetOperation extends BaseLogicalOperator {
+    table_index: number;
+    column_count: number;
+}
+export interface LogicalRecursiveCTE extends BaseLogicalOperator {
+    union_all: boolean;
+    ctename: string;
+    table_index: number;
+    column_count: number;
+}
+export interface LogicalMaterializedCTE extends BaseLogicalOperator {
+    table_index: number;
+    column_count: number;
+    ctename: string;
+}
+export declare enum OnConflictAction {
+    THROW = "THROW",
+    NOTHING = "NOTHING",
+    UPDATE = "UPDATE",
+    REPLACE = "REPLACE"
+}
+export interface LogicalInsert extends BaseLogicalOperator {
+    catalog: string;
+    schema: string;
+    table: string;
+    insert_values: Expression[][];
+    column_index_map: number[];
+    expected_types: LogicalType[];
+    table_index: number;
+    return_chunk: boolean;
+    bound_defaults: Expression[];
+    action_type: OnConflictAction;
+    expected_set_types: LogicalType[];
+    on_conflict_filter: Set<number>;
+    on_conflict_condition?: Expression;
+    do_update_condition?: Expression;
+    set_columns: number[];
+    set_types: LogicalType[];
+    excluded_table_index: number;
+    columns_to_fetch: number[];
+    source_columns: number[];
+}
+export interface LogicalDelete extends BaseLogicalOperator {
+    catalog: string;
+    schema: string;
+    table: string;
+    table_index: number;
+    return_chunk: boolean;
+    expressions: Expression[];
+}
+export interface LogicalUpdate extends BaseLogicalOperator {
+    catalog: string;
+    schema: string;
+    table: string;
+    table_index: number;
+    return_chunk: boolean;
+    expressions: Expression[];
+    columns: PhysicalIndex[];
+    bound_defaults: Expression[];
+    update_is_del_and_insert: boolean;
+}
+export interface LogicalCreateTable extends BaseLogicalOperator {
+    catalog: string;
+    schema: string;
+    info: CreateInfo;
+}
+export interface LogicalCreate extends BaseLogicalOperator {
+    info: CreateInfo;
+}
+export declare enum ExplainType {
+    EXPLAIN_STANDARD = "EXPLAIN_STANDARD",
+    EXPLAIN_ANALYZE = "EXPLAIN_ANALYZE"
+}
+export interface LogicalExplain extends BaseLogicalOperator {
+    explain_type: ExplainType;
+    physical_plan: string;
+    logical_plan_unopt: string;
+    logical_plan_opt: string;
+}
+export interface LogicalShow extends BaseLogicalOperator {
+    types_select: LogicalType[];
+    aliases: string[];
+}
+export declare enum SetScope {
+    AUTOMATIC = "AUTOMATIC",
+    LOCAL = "LOCAL",
+    SESSION = "SESSION",
+    GLOBAL = "GLOBAL"
+}
+export interface LogicalSet extends BaseLogicalOperator {
+    name: string;
+    value: Value;
+    scope: SetScope;
+}
+export interface LogicalReset extends BaseLogicalOperator {
+    name: string;
+    scope: SetScope;
+}
+export interface LogicalSimple extends BaseLogicalOperator {
+    info: ParseInfo;
+}
+export interface LogicalPivot extends BaseLogicalOperator {
+    pivot_index: number;
+    bound_pivot: BoundPivotInfo;
+}
+export type LogicalGet = BaseLogicalOperator;
+export type LogicalCopyToFile = BaseLogicalOperator;
+export interface LogicalCreateIndex extends BaseLogicalOperator {
+    info: CreateInfo;
+    unbound_expressions: Expression[];
+}
+export type LogicalExtensionOperator = BaseLogicalOperator;

package/src/types/duckdb-serialization-types/serialization/LogicalOperator.js

@@ -0,0 +1,47 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DistinctType: function() {
+        return DistinctType;
+    },
+    OnConflictAction: function() {
+        return OnConflictAction;
+    },
+    ExplainType: function() {
+        return ExplainType;
+    },
+    SetScope: function() {
+        return SetScope;
+    }
+});
+var DistinctType;
+(function(DistinctType) {
+    DistinctType["DISTINCT"] = "DISTINCT";
+    DistinctType["DISTINCT_ON"] = "DISTINCT_ON";
+})(DistinctType || (DistinctType = {}));
+var OnConflictAction;
+(function(OnConflictAction) {
+    OnConflictAction["THROW"] = "THROW";
+    OnConflictAction["NOTHING"] = "NOTHING";
+    OnConflictAction["UPDATE"] = "UPDATE";
+    OnConflictAction["REPLACE"] = "REPLACE";
+})(OnConflictAction || (OnConflictAction = {}));
+var ExplainType;
+(function(ExplainType) {
+    ExplainType["EXPLAIN_STANDARD"] = "EXPLAIN_STANDARD";
+    ExplainType["EXPLAIN_ANALYZE"] = "EXPLAIN_ANALYZE";
+})(ExplainType || (ExplainType = {}));
+var SetScope;
+(function(SetScope) {
+    SetScope["AUTOMATIC"] = "AUTOMATIC";
+    SetScope["LOCAL"] = "LOCAL";
+    SetScope["SESSION"] = "SESSION";
+    SetScope["GLOBAL"] = "GLOBAL";
+})(SetScope || (SetScope = {}));
+
+//# sourceMappingURL=LogicalOperator.js.map

package/src/types/duckdb-serialization-types/serialization/LogicalOperator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/LogicalOperator.ts"],"sourcesContent":["import { PhysicalIndex } from './Constraint';\nimport { CreateInfo } from './CreateInfo';\nimport { Expression } from './Expression';\nimport { ColumnDataCollection, Value } from './Misc';\nimport {\n  BoundOrderByNode,\n  BoundPivotInfo,\n  CTEMaterialize,\n  ColumnBinding,\n  JoinCondition,\n  LogicalType,\n  SampleOptions,\n} from './Nodes';\nimport { ParseInfo } from './ParseInfo';\nimport { BoundOrderModifier } from './ResultModifier';\nimport { JoinType } from './TableRef';\n\nexport interface BaseLogicalOperator {\n  id?: number;\n  name?: string;\n  type: string;\n  children?: LogicalOperator[];\n}\n\nexport type LogicalOperator =\n  | LogicalProjection\n  | LogicalFilter\n  | LogicalAggregate\n  | LogicalWindow\n  | LogicalUnnest\n  | LogicalLimit\n  | LogicalOrder\n  | LogicalTopN\n  | LogicalDistinct\n  | LogicalSample\n  | LogicalLimitPercent\n  | LogicalColumnDataGet\n  | LogicalDelimGet\n  | LogicalExpressionGet\n  | LogicalDummyScan\n  | LogicalEmptyResult\n  | LogicalCTERef\n  | LogicalComparisonJoin\n  | LogicalAnyJoin\n  | LogicalCrossProduct\n  | LogicalPositionalJoin\n  | LogicalSetOperation\n  | LogicalRecursiveCTE\n  | LogicalMaterializedCTE\n  | LogicalInsert\n  | LogicalDelete\n  | LogicalUpdate\n  | LogicalCreateTable\n  | LogicalCreate\n  | LogicalExplain\n  | LogicalShow\n  | LogicalSet\n  | LogicalReset\n  | LogicalSimple\n  | LogicalPivot\n  | LogicalGet\n  | LogicalCopyToFile\n  | LogicalCreateIndex\n  | LogicalExtensionOperator;\n\nexport interface LogicalProjection extends BaseLogicalOperator {\n  table_index: number;\n  expressions: Expression[];\n}\n\nexport interface LogicalFilter extends BaseLogicalOperator {\n  expressions: Expression[];\n  projection_map: number[];\n}\n\nexport interface LogicalAggregate extends BaseLogicalOperator {\n  expressions: Expression[];\n  group_index: number;\n  aggregate_index: number;\n  groupings_index: number;\n  groups: Expression[];\n  grouping_sets: Set<number>[];\n  grouping_functions: number[][];\n}\n\nexport interface LogicalWindow extends BaseLogicalOperator {\n  window_index: number;\n  expressions: Expression[];\n}\n\nexport interface LogicalUnnest extends BaseLogicalOperator {\n  unnest_index: number;\n  expressions: Expression[];\n}\n\nexport interface LogicalLimit extends BaseLogicalOperator {\n  limit_val: number;\n  offset_val: number;\n  limit?: Expression;\n  offset?: Expression;\n}\n\nexport interface LogicalOrder extends BaseLogicalOperator {\n  orders: BoundOrderByNode[];\n  projections: number[];\n}\n\nexport interface LogicalTopN extends BaseLogicalOperator {\n  orders: BoundOrderByNode[];\n  limit: number;\n  offset: number;\n}\n\nexport enum DistinctType {\n  DISTINCT = 'DISTINCT',\n  DISTINCT_ON = 'DISTINCT_ON',\n}\n\nexport interface LogicalDistinct extends BaseLogicalOperator {\n  distinct_type: DistinctType;\n  distinct_targets: Expression[];\n  order_by?: BoundOrderModifier;\n}\n\nexport interface LogicalSample extends BaseLogicalOperator {\n  sample_options: SampleOptions;\n}\n\nexport interface LogicalLimitPercent extends BaseLogicalOperator {\n  limit_percent: number;\n  offset_val: number;\n  limit?: Expression;\n  offset?: Expression;\n}\n\nexport interface LogicalColumnDataGet extends BaseLogicalOperator {\n  table_index: number;\n  chunk_types: LogicalType[];\n  collection: ColumnDataCollection;\n}\n\nexport interface LogicalDelimGet extends BaseLogicalOperator {\n  table_index: number;\n  chunk_types: LogicalType[];\n}\n\nexport interface LogicalExpressionGet extends BaseLogicalOperator {\n  table_index: number;\n  expr_types: LogicalType[];\n  expressions: Expression[][];\n}\n\nexport interface LogicalDummyScan extends BaseLogicalOperator {\n  table_index: number;\n}\n\nexport interface LogicalEmptyResult extends BaseLogicalOperator {\n  return_types: LogicalType[];\n  bindings: ColumnBinding[];\n}\n\nexport interface LogicalCTERef extends BaseLogicalOperator {\n  table_index: number;\n  cte_index: number;\n  chunk_types: LogicalType[];\n  bound_columns: string[];\n  materialized_cte: CTEMaterialize;\n}\n\nexport interface LogicalComparisonJoin extends BaseLogicalOperator {\n  join_type: JoinType;\n  mark_index: number;\n  left_projection_map: number[];\n  right_projection_map: number[];\n  conditions: JoinCondition[];\n  mark_types: LogicalType[];\n  duplicate_eliminated_columns: Expression[];\n}\n\nexport interface LogicalAnyJoin extends BaseLogicalOperator {\n  join_type: JoinType;\n  mark_index: number;\n  left_projection_map: number[];\n  right_projection_map: number[];\n  condition: Expression;\n}\n\nexport type LogicalCrossProduct = BaseLogicalOperator;\n\nexport type LogicalPositionalJoin = BaseLogicalOperator;\n\nexport interface LogicalSetOperation extends BaseLogicalOperator {\n  table_index: number;\n  column_count: number;\n}\n\nexport interface LogicalRecursiveCTE extends BaseLogicalOperator {\n  union_all: boolean;\n  ctename: string;\n  table_index: number;\n  column_count: number;\n}\n\nexport interface LogicalMaterializedCTE extends BaseLogicalOperator {\n  table_index: number;\n  column_count: number;\n  ctename: string;\n}\n\nexport enum OnConflictAction {\n  THROW = 'THROW',\n  NOTHING = 'NOTHING',\n  UPDATE = 'UPDATE',\n  REPLACE = 'REPLACE',\n}\n\nexport interface LogicalInsert extends BaseLogicalOperator {\n  catalog: string;\n  schema: string;\n  table: string;\n  insert_values: Expression[][];\n  column_index_map: number[];\n  expected_types: LogicalType[];\n  table_index: number;\n  return_chunk: boolean;\n  bound_defaults: Expression[];\n  action_type: OnConflictAction;\n  expected_set_types: LogicalType[];\n  on_conflict_filter: Set<number>;\n  on_conflict_condition?: Expression;\n  do_update_condition?: Expression;\n  set_columns: number[];\n  set_types: LogicalType[];\n  excluded_table_index: number;\n  columns_to_fetch: number[];\n  source_columns: number[];\n}\n\nexport interface LogicalDelete extends BaseLogicalOperator {\n  catalog: string;\n  schema: string;\n  table: string;\n  table_index: number;\n  return_chunk: boolean;\n  expressions: Expression[];\n}\n\nexport interface LogicalUpdate extends BaseLogicalOperator {\n  catalog: string;\n  schema: string;\n  table: string;\n  table_index: number;\n  return_chunk: boolean;\n  expressions: Expression[];\n  columns: PhysicalIndex[];\n  bound_defaults: Expression[];\n  update_is_del_and_insert: boolean;\n}\n\nexport interface LogicalCreateTable extends BaseLogicalOperator {\n  catalog: string;\n  schema: string;\n  info: CreateInfo;\n}\n\nexport interface LogicalCreate extends BaseLogicalOperator {\n  info: CreateInfo;\n}\n\nexport enum ExplainType {\n  EXPLAIN_STANDARD = 'EXPLAIN_STANDARD',\n  EXPLAIN_ANALYZE = 'EXPLAIN_ANALYZE',\n}\n\nexport interface LogicalExplain extends BaseLogicalOperator {\n  explain_type: ExplainType;\n  physical_plan: string;\n  logical_plan_unopt: string;\n  logical_plan_opt: string;\n}\n\nexport interface LogicalShow extends BaseLogicalOperator {\n  types_select: LogicalType[];\n  aliases: string[];\n}\n\nexport enum SetScope {\n  AUTOMATIC = 'AUTOMATIC',\n  LOCAL = 'LOCAL',\n  SESSION = 'SESSION',\n  GLOBAL = 'GLOBAL',\n}\n\nexport interface LogicalSet extends BaseLogicalOperator {\n  name: string;\n  value: Value;\n  scope: SetScope;\n}\n\nexport interface LogicalReset extends BaseLogicalOperator {\n  name: string;\n  scope: SetScope;\n}\n\nexport interface LogicalSimple extends BaseLogicalOperator {\n  info: ParseInfo;\n}\n\nexport interface LogicalPivot extends BaseLogicalOperator {\n  pivot_index: number;\n  bound_pivot: BoundPivotInfo;\n}\n\nexport type LogicalGet = BaseLogicalOperator;\n\nexport type LogicalCopyToFile = BaseLogicalOperator;\n\nexport interface LogicalCreateIndex extends BaseLogicalOperator {\n  info: CreateInfo;\n  unbound_expressions: Expression[];\n}\n\nexport type LogicalExtensionOperator = BaseLogicalOperator;\n"],"names":["DistinctType","DISTINCT","DISTINCT_ON","OnConflictAction","THROW","NOTHING","UPDATE","REPLACE","ExplainType","EXPLAIN_STANDARD","EXPLAIN_ANALYZE","SetScope","AUTOMATIC","LOCAL","SESSION","GLOBAL"],"mappings":";;;;;;;;;;;;;;;;;;;;;IAiHO;UAAKA,YAAY;IAAZA,aACVC,cAAAA;IADUD,aAEVE,iBAAAA;GAFUF,iBAAAA;IAgGL;UAAKG,gBAAgB;IAAhBA,iBACVC,WAAAA;IADUD,iBAEVE,aAAAA;IAFUF,iBAGVG,YAAAA;IAHUH,iBAIVI,aAAAA;GAJUJ,qBAAAA;IA4DL;UAAKK,WAAW;IAAXA,YACVC,sBAAAA;IADUD,YAEVE,qBAAAA;GAFUF,gBAAAA;IAiBL;UAAKG,QAAQ;IAARA,SACVC,eAAAA;IADUD,SAEVE,WAAAA;IAFUF,SAGVG,aAAAA;IAHUH,SAIVI,YAAAA;GAJUJ,aAAAA"}

package/src/types/duckdb-serialization-types/serialization/MacroFunction.d.ts

@@ -0,0 +1,20 @@
+import { ParsedExpression } from './ParsedExpression';
+import { BaseQueryNode } from './QueryNode';
+export declare enum MacroType {
+    VOID_MACRO = "VOID_MACRO",
+    TABLE_MACRO = "TABLE_MACRO",
+    SCALAR_MACRO = "SCALAR_MACRO"
+}
+export interface MacroFunction {
+    type: MacroType;
+    parameters: ParsedExpression[];
+    default_parameters: {
+        [key: string]: ParsedExpression;
+    };
+}
+export interface ScalarMacroFunction extends MacroFunction {
+    expression: ParsedExpression;
+}
+export interface TableMacroFunction extends MacroFunction {
+    query_node: BaseQueryNode;
+}

package/src/types/duckdb-serialization-types/serialization/MacroFunction.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "MacroType", {
+    enumerable: true,
+    get: function() {
+        return MacroType;
+    }
+});
+var MacroType;
+(function(MacroType) {
+    MacroType["VOID_MACRO"] = "VOID_MACRO";
+    MacroType["TABLE_MACRO"] = "TABLE_MACRO";
+    MacroType["SCALAR_MACRO"] = "SCALAR_MACRO";
+})(MacroType || (MacroType = {}));
+
+//# sourceMappingURL=MacroFunction.js.map

package/src/types/duckdb-serialization-types/serialization/MacroFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/MacroFunction.ts"],"sourcesContent":["import { ParsedExpression } from './ParsedExpression';\nimport { BaseQueryNode } from './QueryNode';\n\nexport enum MacroType {\n  VOID_MACRO = 'VOID_MACRO',\n  TABLE_MACRO = 'TABLE_MACRO',\n  SCALAR_MACRO = 'SCALAR_MACRO',\n}\n\nexport interface MacroFunction {\n  type: MacroType;\n  parameters: ParsedExpression[];\n  default_parameters: { [key: string]: ParsedExpression };\n}\n\nexport interface ScalarMacroFunction extends MacroFunction {\n  expression: ParsedExpression;\n}\n\nexport interface TableMacroFunction extends MacroFunction {\n  query_node: BaseQueryNode;\n}\n"],"names":["MacroType","VOID_MACRO","TABLE_MACRO","SCALAR_MACRO"],"mappings":";;;;;;;IAGO;UAAKA,SAAS;IAATA,UACVC,gBAAAA;IADUD,UAEVE,iBAAAA;IAFUF,UAGVG,kBAAAA;GAHUH,cAAAA"}

package/src/types/duckdb-serialization-types/serialization/Misc.d.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=Misc.d.js.map

package/src/types/duckdb-serialization-types/serialization/Misc.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Misc.d.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/Misc.d.ts

@@ -0,0 +1,3 @@
+export type Value = any;
+export type CacheCheck = any;
+export type ColumnDataCollection = any;

package/src/types/duckdb-serialization-types/serialization/Misc.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=Misc.js.map

package/src/types/duckdb-serialization-types/serialization/Misc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Misc.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/Nodes.d.js

@@ -0,0 +1,10 @@
+"use strict";
+var FileCompressionType;
+(function(FileCompressionType) {
+    FileCompressionType["AUTO_DETECT"] = "AUTO_DETECT";
+    FileCompressionType["UNCOMPRESSED"] = "UNCOMPRESSED";
+    FileCompressionType["GZIP"] = "GZIP";
+    FileCompressionType["ZSTD"] = "ZSTD";
+})(FileCompressionType || (FileCompressionType = {}));
+
+//# sourceMappingURL=Nodes.d.js.map

package/src/types/duckdb-serialization-types/serialization/Nodes.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Nodes.d.ts"],"sourcesContent":["import { Expression, ExpressionType } from './Expression';\nimport { Value } from './Misc';\nimport { ParsedExpression } from './ParsedExpression';\nimport { SelectStatement } from './Statement';\nimport { TableFilter } from './TableFilter';\nimport { ExtraTypeInfo } from './Types';\nexport interface LogicalType {\n    id?: number;\n    type_info?: ExtraTypeInfo;\n}\nexport declare enum CTEMaterialize {\n    CTE_MATERIALIZE_DEFAULT = \"CTE_MATERIALIZE_DEFAULT\",\n    CTE_MATERIALIZE_ALWAYS = \"CTE_MATERIALIZE_ALWAYS\",\n    CTE_MATERIALIZE_NEVER = \"CTE_MATERIALIZE_NEVER\"\n}\nexport interface CommonTableExpressionInfo {\n    aliases: string[];\n    query: SelectStatement;\n    materialized: CTEMaterialize;\n}\nexport interface CommonTableExpressionMap {\n    map: Record<string, CommonTableExpressionInfo> | Array<CommonTableExpressionInfo>;\n}\nexport declare enum OrderType {\n    INVALID = \"INVALID\",\n    ORDER_DEFAULT = \"ORDER_DEFAULT\",\n    ASCENDING = \"ASCENDING\",\n    DESCENDING = \"DESCENDING\"\n}\nexport declare enum OrderByNullType {\n    INVALID = \"INVALID\",\n    ORDER_DEFAULT = \"ORDER_DEFAULT\",\n    NULLS_FIRST = \"NULLS_FIRST\",\n    NULLS_LAST = \"NULLS_LAST\"\n}\nexport declare enum DefaultOrderByNullType {\n    INVALID = \"INVALID\",\n    NULLS_FIRST = \"NULLS_FIRST\",\n    NULLS_LAST = \"NULLS_LAST\",\n    NULLS_FIRST_ON_ASC_LAST_ON_DESC = \"NULLS_FIRST_ON_ASC_LAST_ON_DESC\",\n    NULLS_LAST_ON_ASC_FIRST_ON_DESC = \"NULLS_LAST_ON_ASC_FIRST_ON_DESC\"\n}\nexport interface OrderByNode {\n    type: OrderType;\n    null_order: OrderByNullType;\n    expression: ParsedExpression;\n}\nexport interface BoundOrderByNode {\n    type: OrderType;\n    null_order: OrderByNullType;\n    expression: Expression;\n}\nexport interface CaseCheck {\n    when_expr: ParsedExpression;\n    then_expr: ParsedExpression;\n}\nexport interface BoundCaseCheck {\n    when_expr: Expression;\n    then_expr: Expression;\n}\nexport declare enum SampleMethod {\n    SYSTEM_SAMPLE = \"SYSTEM_SAMPLE\",\n    BERNOULLI_SAMPLE = \"BERNOULLI_SAMPLE\",\n    RESERVOIR_SAMPLE = \"RESERVOIR_SAMPLE\"\n}\nexport interface SampleOptions {\n    sample_size: Value;\n    is_percentage: boolean;\n    method: SampleMethod;\n    seed: number;\n}\nexport interface PivotColumn {\n    pivot_expressions: ParsedExpression[];\n    unpivot_names: string[];\n    entries: PivotColumnEntry[];\n    pivot_enum: string;\n}\nexport interface PivotColumnEntry {\n    values: Value[];\n    star_expr?: ParsedExpression;\n    alias: string;\n}\nexport interface BoundPivotInfo {\n    group_count: number;\n    types: LogicalType[];\n    pivot_values: string[];\n    aggregates: Expression[];\n}\nexport declare enum TableColumnType {\n    STANDARD = \"STANDARD\",\n    GENERATED = \"GENERATED\"\n}\nexport declare enum CompressionType {\n    COMPRESSION_AUTO = \"COMPRESSION_AUTO\",\n    COMPRESSION_UNCOMPRESSED = \"COMPRESSION_UNCOMPRESSED\",\n    COMPRESSION_CONSTANT = \"COMPRESSION_CONSTANT\",\n    COMPRESSION_RLE = \"COMPRESSION_RLE\",\n    COMPRESSION_DICTIONARY = \"COMPRESSION_DICTIONARY\",\n    COMPRESSION_PFOR_DELTA = \"COMPRESSION_PFOR_DELTA\",\n    COMPRESSION_BITPACKING = \"COMPRESSION_BITPACKING\",\n    COMPRESSION_FSST = \"COMPRESSION_FSST\",\n    COMPRESSION_CHIMP = \"COMPRESSION_CHIMP\",\n    COMPRESSION_PATAS = \"COMPRESSION_PATAS\",\n    COMPRESSION_COUNT = \"COMPRESSION_COUNT\"\n}\nexport interface ColumnDefinition {\n    name: string;\n    type: LogicalType;\n    expression?: ParsedExpression;\n    category: TableColumnType;\n    compression_type: CompressionType;\n}\nexport interface ColumnList {\n    columns: ColumnDefinition[];\n}\nexport interface ColumnBinding {\n    table_index: number;\n    column_index: number;\n}\nexport interface BoundParameterData {\n    value: Value;\n    return_type: LogicalType;\n}\nexport interface JoinCondition {\n    left: Expression;\n    right: Expression;\n    comparison: ExpressionType;\n}\nexport interface VacuumOptions {\n    vacuum: boolean;\n    analyze: boolean;\n}\nexport interface TableFilterSet {\n    filters: Record<number, TableFilter>;\n}\nexport interface MultiFileReaderOptions {\n    filename: boolean;\n    hive_partitioning: boolean;\n    auto_detect_hive_partitioning: boolean;\n    union_by_name: boolean;\n    hive_types_autocast: boolean;\n    hive_types_schema: Record<string, LogicalType>;\n}\nexport interface MultiFileReaderBindData {\n    filename_idx: number;\n    hive_partitioning_indexes: HivePartitioningIndex[];\n}\nexport interface HivePartitioningIndex {\n    value: string;\n    index: number;\n}\ndeclare enum FileCompressionType {\n    AUTO_DETECT = \"AUTO_DETECT\",\n    UNCOMPRESSED = \"UNCOMPRESSED\",\n    GZIP = \"GZIP\",\n    ZSTD = \"ZSTD\"\n}\nexport interface CSVReaderOptions {\n    has_delimiter: boolean;\n    has_quote: boolean;\n    has_escape: boolean;\n    has_header: boolean;\n    ignore_errors: boolean;\n    buffer_sample_size: number;\n    null_str: string;\n    compression: FileCompressionType;\n    allow_quoted_nulls: boolean;\n    skip_rows_set: boolean;\n    maximum_line_size: number;\n    normalize_names: boolean;\n    force_not_null: boolean[];\n    all_varchar: boolean;\n    sample_chunk_size: number;\n    sample_chunks: number;\n    auto_detect: boolean;\n    file_path: string;\n    decimal_separator: string;\n    null_padding: boolean;\n    buffer_size: number;\n    file_options: MultiFileReaderOptions;\n    force_quote: boolean[];\n    rejects_table_name: string;\n    rejects_limit: number;\n    rejects_recovery_columns: string[];\n    rejects_recovery_column_ids: number[];\n    dialect_options: any;\n}\nexport interface StrpTimeFormat {\n    format_specifier: string;\n}\nexport interface ReadCSVData {\n    files: string[];\n    csv_types: LogicalType[];\n    csv_names: string[];\n    return_types: LogicalType[];\n    return_names: string[];\n    filename_col_idx: number;\n    options: any;\n    single_threaded: boolean;\n    reader_bind: MultiFileReaderBindData;\n    column_info: ColumnInfo[];\n}\nexport interface ColumnInfo {\n    names: string[];\n    types: LogicalType[];\n}\nexport interface IntervalT {\n    months: number;\n    days: number;\n    micros: number;\n}\nexport {};\n"],"names":["FileCompressionType","AUTO_DETECT","UNCOMPRESSED","GZIP","ZSTD"],"mappings":";IAuJA;UAAaA,mBAAmB;IAAnBA,oBACTC,iBAAAA;IADSD,oBAETE,kBAAAA;IAFSF,oBAGTG,UAAAA;IAHSH,oBAITI,UAAAA;GAJSJ,wBAAAA"}