@devrev/meerkat-core 0.0.77

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

@@ -0,0 +1,114 @@
+import { ExpressionClass, ExpressionType } from './Expression';
+import { CacheCheck, Value } from './Misc';
+import { LogicalType, OrderByNode } from './Nodes';
+import { OrderModifier } from './ResultModifier';
+import { SelectStatement } from './Statement';
+export interface BaseParsedExpression {
+    class: ExpressionClass;
+    type: ExpressionType;
+    alias: string;
+}
+export type ParsedExpression = BetweenExpression | CaseExpression | CastExpression | CollateExpression | ColumnRefExpression | ComparisonExpression | ConjunctionExpression | ConstantExpression | DefaultExpression | FunctionExpression | LambdaExpression | OperatorExpression | ParameterExpression | PositionalReferenceExpression | StarExpression | SubqueryExpression | WindowExpression;
+export interface BetweenExpression extends BaseParsedExpression {
+    input: ParsedExpression;
+    lower: ParsedExpression;
+    upper: ParsedExpression;
+}
+export interface CaseExpression extends BaseParsedExpression {
+    case_checks: CacheCheck[];
+    else_expr: BaseParsedExpression;
+}
+export interface CastExpression extends BaseParsedExpression {
+    child: ParsedExpression;
+    cast_type: LogicalType;
+    try_cast: boolean;
+}
+export interface CollateExpression extends BaseParsedExpression {
+    child: ParsedExpression;
+    collation: string;
+}
+export interface ColumnRefExpression extends BaseParsedExpression {
+    column_names: string[];
+}
+export interface ComparisonExpression extends BaseParsedExpression {
+    left: ParsedExpression;
+    right: ParsedExpression;
+}
+export interface ConjunctionExpression extends BaseParsedExpression {
+    children: ParsedExpression[];
+}
+export interface ConstantExpression extends BaseParsedExpression {
+    value: Value;
+}
+export type DefaultExpression = BaseParsedExpression;
+export interface FunctionExpression extends BaseParsedExpression {
+    function_name: string;
+    schema: string;
+    children: ParsedExpression[];
+    filter: ParsedExpression | null;
+    order_bys: OrderModifier;
+    distinct: boolean;
+    is_operator: boolean;
+    export_state: boolean;
+    catalog: string;
+}
+export interface LambdaExpression extends BaseParsedExpression {
+    lhs: ParsedExpression;
+    expr: ParsedExpression | null;
+}
+export interface OperatorExpression extends BaseParsedExpression {
+    children: ParsedExpression[];
+}
+export interface ParameterExpression extends BaseParsedExpression {
+    identifier: string;
+}
+export interface PositionalReferenceExpression extends BaseParsedExpression {
+    index: number;
+}
+export interface StarExpression extends BaseParsedExpression {
+    relation_name: string;
+    exclude_list: Set<string> | Array<string>;
+    replace_list: Set<ParsedExpression> | Array<ParsedExpression>;
+    columns: boolean;
+    expr?: ParsedExpression;
+}
+export declare enum SubqueryType {
+    INVALID = "INVALID",
+    SCALAR = "SCALAR",
+    EXISTS = "EXISTS",
+    NOT_EXISTS = "NOT_EXISTS",
+    ANY = "ANY"
+}
+export interface SubqueryExpression extends BaseParsedExpression {
+    subquery_type: SubqueryType;
+    subquery: SelectStatement;
+    child?: ParsedExpression;
+    comparison_type: ExpressionType;
+}
+export declare enum WindowBoundary {
+    INVALID = "INVALID",
+    UNBOUNDED_PRECEDING = "UNBOUNDED_PRECEDING",
+    UNBOUNDED_FOLLOWING = "UNBOUNDED_FOLLOWING",
+    CURRENT_ROW_RANGE = "CURRENT_ROW_RANGE",
+    CURRENT_ROW_ROWS = "CURRENT_ROW_ROWS",
+    EXPR_PRECEDING_ROWS = "EXPR_PRECEDING_ROWS",
+    EXPR_FOLLOWING_ROWS = "EXPR_FOLLOWING_ROWS",
+    EXPR_PRECEDING_RANGE = "EXPR_PRECEDING_RANGE",
+    EXPR_FOLLOWING_RANGE = "EXPR_FOLLOWING_RANGE"
+}
+export interface WindowExpression extends BaseParsedExpression {
+    function_name: string;
+    schema: string;
+    catalog: string;
+    children: ParsedExpression[];
+    partitions: ParsedExpression[];
+    orders: OrderByNode[];
+    start: WindowBoundary;
+    end: WindowBoundary;
+    start_expr?: ParsedExpression;
+    end_expr?: ParsedExpression;
+    offset_expr?: ParsedExpression;
+    default_expr?: ParsedExpression;
+    ignore_nulls: boolean;
+    filter_expr?: ParsedExpression;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    SubqueryType: function() {
+        return SubqueryType;
+    },
+    WindowBoundary: function() {
+        return WindowBoundary;
+    }
+});
+var SubqueryType;
+(function(SubqueryType) {
+    SubqueryType["INVALID"] = "INVALID";
+    SubqueryType["SCALAR"] = "SCALAR";
+    SubqueryType["EXISTS"] = "EXISTS";
+    SubqueryType["NOT_EXISTS"] = "NOT_EXISTS";
+    SubqueryType["ANY"] = "ANY";
+})(SubqueryType || (SubqueryType = {}));
+var WindowBoundary;
+(function(WindowBoundary) {
+    WindowBoundary["INVALID"] = "INVALID";
+    WindowBoundary["UNBOUNDED_PRECEDING"] = "UNBOUNDED_PRECEDING";
+    WindowBoundary["UNBOUNDED_FOLLOWING"] = "UNBOUNDED_FOLLOWING";
+    WindowBoundary["CURRENT_ROW_RANGE"] = "CURRENT_ROW_RANGE";
+    WindowBoundary["CURRENT_ROW_ROWS"] = "CURRENT_ROW_ROWS";
+    WindowBoundary["EXPR_PRECEDING_ROWS"] = "EXPR_PRECEDING_ROWS";
+    WindowBoundary["EXPR_FOLLOWING_ROWS"] = "EXPR_FOLLOWING_ROWS";
+    WindowBoundary["EXPR_PRECEDING_RANGE"] = "EXPR_PRECEDING_RANGE";
+    WindowBoundary["EXPR_FOLLOWING_RANGE"] = "EXPR_FOLLOWING_RANGE";
+})(WindowBoundary || (WindowBoundary = {}));
+
+//# sourceMappingURL=ParsedExpression.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/ParsedExpression.ts"],"sourcesContent":["import { ExpressionClass, ExpressionType } from './Expression';\nimport { CacheCheck, Value } from './Misc';\nimport { LogicalType, OrderByNode } from './Nodes';\nimport { OrderModifier } from './ResultModifier';\nimport { SelectStatement } from './Statement';\n\nexport interface BaseParsedExpression {\n  class: ExpressionClass;\n  type: ExpressionType;\n  alias: string;\n}\n\nexport type ParsedExpression =\n  | BetweenExpression\n  | CaseExpression\n  | CastExpression\n  | CollateExpression\n  | ColumnRefExpression\n  | ComparisonExpression\n  | ConjunctionExpression\n  | ConstantExpression\n  | DefaultExpression\n  | FunctionExpression\n  | LambdaExpression\n  | OperatorExpression\n  | ParameterExpression\n  | PositionalReferenceExpression\n  | StarExpression\n  | SubqueryExpression\n  | WindowExpression;\n\nexport interface BetweenExpression extends BaseParsedExpression {\n  input: ParsedExpression;\n  lower: ParsedExpression;\n  upper: ParsedExpression;\n}\n\nexport interface CaseExpression extends BaseParsedExpression {\n  case_checks: CacheCheck[];\n  else_expr: BaseParsedExpression;\n}\n\nexport interface CastExpression extends BaseParsedExpression {\n  child: ParsedExpression;\n  cast_type: LogicalType;\n  try_cast: boolean;\n}\n\nexport interface CollateExpression extends BaseParsedExpression {\n  child: ParsedExpression;\n  collation: string;\n}\n\nexport interface ColumnRefExpression extends BaseParsedExpression {\n  column_names: string[];\n}\n\nexport interface ComparisonExpression extends BaseParsedExpression {\n  left: ParsedExpression;\n  right: ParsedExpression;\n}\n\nexport interface ConjunctionExpression extends BaseParsedExpression {\n  children: ParsedExpression[];\n}\n\nexport interface ConstantExpression extends BaseParsedExpression {\n  value: Value;\n}\n\nexport type DefaultExpression = BaseParsedExpression;\n\nexport interface FunctionExpression extends BaseParsedExpression {\n  function_name: string;\n  schema: string;\n  children: ParsedExpression[];\n  filter: ParsedExpression | null;\n  order_bys: OrderModifier;\n  distinct: boolean;\n  is_operator: boolean;\n  export_state: boolean;\n  catalog: string;\n}\n\nexport interface LambdaExpression extends BaseParsedExpression {\n  lhs: ParsedExpression;\n  expr: ParsedExpression | null;\n}\n\nexport interface OperatorExpression extends BaseParsedExpression {\n  children: ParsedExpression[];\n}\n\nexport interface ParameterExpression extends BaseParsedExpression {\n  identifier: string;\n}\n\nexport interface PositionalReferenceExpression extends BaseParsedExpression {\n  index: number;\n}\n\nexport interface StarExpression extends BaseParsedExpression {\n  relation_name: string;\n  exclude_list: Set<string> | Array<string>;\n  replace_list: Set<ParsedExpression> | Array<ParsedExpression>;\n  columns: boolean;\n  expr?: ParsedExpression;\n}\n\nexport enum SubqueryType {\n  INVALID = 'INVALID',\n  SCALAR = 'SCALAR',\n  EXISTS = 'EXISTS',\n  NOT_EXISTS = 'NOT_EXISTS',\n  ANY = 'ANY',\n}\n\nexport interface SubqueryExpression extends BaseParsedExpression {\n  subquery_type: SubqueryType;\n  subquery: SelectStatement;\n  child?: ParsedExpression;\n  comparison_type: ExpressionType;\n}\n\nexport enum WindowBoundary {\n  INVALID = 'INVALID',\n  UNBOUNDED_PRECEDING = 'UNBOUNDED_PRECEDING',\n  UNBOUNDED_FOLLOWING = 'UNBOUNDED_FOLLOWING',\n  CURRENT_ROW_RANGE = 'CURRENT_ROW_RANGE',\n  CURRENT_ROW_ROWS = 'CURRENT_ROW_ROWS',\n  EXPR_PRECEDING_ROWS = 'EXPR_PRECEDING_ROWS',\n  EXPR_FOLLOWING_ROWS = 'EXPR_FOLLOWING_ROWS',\n  EXPR_PRECEDING_RANGE = 'EXPR_PRECEDING_RANGE',\n  EXPR_FOLLOWING_RANGE = 'EXPR_FOLLOWING_RANGE',\n}\n\nexport interface WindowExpression extends BaseParsedExpression {\n  function_name: string;\n  schema: string;\n  catalog: string;\n  children: ParsedExpression[];\n  partitions: ParsedExpression[];\n  orders: OrderByNode[];\n  start: WindowBoundary;\n  end: WindowBoundary;\n  start_expr?: ParsedExpression;\n  end_expr?: ParsedExpression;\n  offset_expr?: ParsedExpression;\n  default_expr?: ParsedExpression;\n  ignore_nulls: boolean;\n  filter_expr?: ParsedExpression;\n}\n"],"names":["SubqueryType","INVALID","SCALAR","EXISTS","NOT_EXISTS","ANY","WindowBoundary","UNBOUNDED_PRECEDING","UNBOUNDED_FOLLOWING","CURRENT_ROW_RANGE","CURRENT_ROW_ROWS","EXPR_PRECEDING_ROWS","EXPR_FOLLOWING_ROWS","EXPR_PRECEDING_RANGE","EXPR_FOLLOWING_RANGE"],"mappings":";;;;;;;;;;;;;;;IA6GO;UAAKA,YAAY;IAAZA,aACVC,aAAAA;IADUD,aAEVE,YAAAA;IAFUF,aAGVG,YAAAA;IAHUH,aAIVI,gBAAAA;IAJUJ,aAKVK,SAAAA;GALUL,iBAAAA;IAeL;UAAKM,cAAc;IAAdA,eACVL,aAAAA;IADUK,eAEVC,yBAAAA;IAFUD,eAGVE,yBAAAA;IAHUF,eAIVG,uBAAAA;IAJUH,eAKVI,sBAAAA;IALUJ,eAMVK,yBAAAA;IANUL,eAOVM,yBAAAA;IAPUN,eAQVO,0BAAAA;IARUP,eASVQ,0BAAAA;GATUR,mBAAAA"}

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

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

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

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

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

@@ -0,0 +1,62 @@
+import { CommonTableExpressionMap, SampleOptions } from './Nodes';
+import { ParsedExpression } from './ParsedExpression';
+import { ResultModifier } from './ResultModifier';
+import { TableRef } from './TableRef';
+export declare enum QueryNodeType {
+    SELECT_NODE = "SELECT_NODE",
+    SET_OPERATION_NODE = "SET_OPERATION_NODE",
+    BOUND_SUBQUERY_NODE = "BOUND_SUBQUERY_NODE",
+    RECURSIVE_CTE_NODE = "RECURSIVE_CTE_NODE",
+    CTE_NODE = "CTE_NODE"
+}
+export interface BaseQueryNode {
+    type: QueryNodeType;
+    modifiers: ResultModifier[];
+    cte_map: CommonTableExpressionMap;
+}
+export type QueryNode = SelectNode | SetOperationNode | RecursiveCTENode | CTENode;
+export declare enum AggregateHandling {
+    STANDARD_HANDLING = "STANDARD_HANDLING",
+    NO_AGGREGATES_ALLOWED = "NO_AGGREGATES_ALLOWED",
+    FORCE_AGGREGATES = "FORCE_AGGREGATES"
+}
+export interface SelectNode extends BaseQueryNode {
+    type: QueryNodeType.SELECT_NODE;
+    select_list: ParsedExpression[];
+    from_table?: TableRef;
+    where_clause?: ParsedExpression;
+    group_expressions: ParsedExpression[];
+    group_sets: Set<number> | Array<Array<number>>;
+    aggregate_handling: AggregateHandling;
+    having: ParsedExpression | null;
+    sample: SampleOptions | null;
+    qualify: ParsedExpression | null;
+}
+export declare enum SetOperationType {
+    NONE = "NONE",
+    UNION = "UNION",
+    EXCEPT = "EXCEPT",
+    INTERSECT = "INTERSECT",
+    UNION_BY_NAME = "UNION_BY_NAME"
+}
+export interface SetOperationNode extends BaseQueryNode {
+    type: QueryNodeType.SET_OPERATION_NODE;
+    setop_type: SetOperationType;
+    left: QueryNode;
+    right: QueryNode;
+}
+export interface RecursiveCTENode extends BaseQueryNode {
+    type: QueryNodeType.RECURSIVE_CTE_NODE;
+    cte_name: string;
+    union_all: boolean;
+    left: QueryNode;
+    right: QueryNode;
+    aliases: string[];
+}
+export interface CTENode extends BaseQueryNode {
+    type: QueryNodeType.CTE_NODE;
+    cte_name: string;
+    query: QueryNode;
+    child: QueryNode;
+    aliases: string[];
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    QueryNodeType: function() {
+        return QueryNodeType;
+    },
+    AggregateHandling: function() {
+        return AggregateHandling;
+    },
+    SetOperationType: function() {
+        return SetOperationType;
+    }
+});
+var QueryNodeType;
+(function(QueryNodeType) {
+    QueryNodeType["SELECT_NODE"] = "SELECT_NODE";
+    QueryNodeType["SET_OPERATION_NODE"] = "SET_OPERATION_NODE";
+    QueryNodeType["BOUND_SUBQUERY_NODE"] = "BOUND_SUBQUERY_NODE";
+    QueryNodeType["RECURSIVE_CTE_NODE"] = "RECURSIVE_CTE_NODE";
+    QueryNodeType["CTE_NODE"] = "CTE_NODE";
+})(QueryNodeType || (QueryNodeType = {}));
+var AggregateHandling;
+(function(AggregateHandling) {
+    AggregateHandling["STANDARD_HANDLING"] = "STANDARD_HANDLING";
+    AggregateHandling["NO_AGGREGATES_ALLOWED"] = "NO_AGGREGATES_ALLOWED";
+    AggregateHandling["FORCE_AGGREGATES"] = "FORCE_AGGREGATES";
+})(AggregateHandling || (AggregateHandling = {}));
+var SetOperationType;
+(function(SetOperationType) {
+    SetOperationType["NONE"] = "NONE";
+    SetOperationType["UNION"] = "UNION";
+    SetOperationType["EXCEPT"] = "EXCEPT";
+    SetOperationType["INTERSECT"] = "INTERSECT";
+    SetOperationType["UNION_BY_NAME"] = "UNION_BY_NAME";
+})(SetOperationType || (SetOperationType = {}));
+
+//# sourceMappingURL=QueryNode.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/QueryNode.ts"],"sourcesContent":["import { CommonTableExpressionMap, SampleOptions } from './Nodes';\nimport { ParsedExpression } from './ParsedExpression';\nimport { ResultModifier } from './ResultModifier';\nimport { TableRef } from './TableRef';\n\nexport enum QueryNodeType {\n  SELECT_NODE = 'SELECT_NODE',\n  SET_OPERATION_NODE = 'SET_OPERATION_NODE',\n  BOUND_SUBQUERY_NODE = 'BOUND_SUBQUERY_NODE',\n  RECURSIVE_CTE_NODE = 'RECURSIVE_CTE_NODE',\n  CTE_NODE = 'CTE_NODE',\n}\n\nexport interface BaseQueryNode {\n  type: QueryNodeType;\n  modifiers: ResultModifier[];\n  cte_map: CommonTableExpressionMap;\n}\n\nexport type QueryNode =\n  | SelectNode\n  | SetOperationNode\n  | RecursiveCTENode\n  | CTENode;\n\nexport enum AggregateHandling {\n  STANDARD_HANDLING = 'STANDARD_HANDLING',\n  NO_AGGREGATES_ALLOWED = 'NO_AGGREGATES_ALLOWED',\n  FORCE_AGGREGATES = 'FORCE_AGGREGATES',\n}\n\nexport interface SelectNode extends BaseQueryNode {\n  type: QueryNodeType.SELECT_NODE;\n  select_list: ParsedExpression[];\n  from_table?: TableRef;\n  where_clause?: ParsedExpression;\n  group_expressions: ParsedExpression[];\n  group_sets: Set<number> | Array<Array<number>>;\n  aggregate_handling: AggregateHandling;\n  having: ParsedExpression | null;\n  sample: SampleOptions | null;\n  qualify: ParsedExpression | null;\n}\n\nexport enum SetOperationType {\n  NONE = 'NONE',\n  UNION = 'UNION',\n  EXCEPT = 'EXCEPT',\n  INTERSECT = 'INTERSECT',\n  UNION_BY_NAME = 'UNION_BY_NAME',\n}\n\nexport interface SetOperationNode extends BaseQueryNode {\n  type: QueryNodeType.SET_OPERATION_NODE;\n  setop_type: SetOperationType;\n  left: QueryNode;\n  right: QueryNode;\n}\n\nexport interface RecursiveCTENode extends BaseQueryNode {\n  type: QueryNodeType.RECURSIVE_CTE_NODE;\n  cte_name: string;\n  union_all: boolean;\n  left: QueryNode;\n  right: QueryNode;\n  aliases: string[];\n}\n\nexport interface CTENode extends BaseQueryNode {\n  type: QueryNodeType.CTE_NODE;\n  cte_name: string;\n  query: QueryNode;\n  child: QueryNode;\n  aliases: string[];\n}\n"],"names":["QueryNodeType","SELECT_NODE","SET_OPERATION_NODE","BOUND_SUBQUERY_NODE","RECURSIVE_CTE_NODE","CTE_NODE","AggregateHandling","STANDARD_HANDLING","NO_AGGREGATES_ALLOWED","FORCE_AGGREGATES","SetOperationType","NONE","UNION","EXCEPT","INTERSECT","UNION_BY_NAME"],"mappings":";;;;;;;;;;;;;;;;;;IAKO;UAAKA,aAAa;IAAbA,cACVC,iBAAAA;IADUD,cAEVE,wBAAAA;IAFUF,cAGVG,yBAAAA;IAHUH,cAIVI,wBAAAA;IAJUJ,cAKVK,cAAAA;GALUL,kBAAAA;IAoBL;UAAKM,iBAAiB;IAAjBA,kBACVC,uBAAAA;IADUD,kBAEVE,2BAAAA;IAFUF,kBAGVG,sBAAAA;GAHUH,sBAAAA;IAmBL;UAAKI,gBAAgB;IAAhBA,iBACVC,UAAAA;IADUD,iBAEVE,WAAAA;IAFUF,iBAGVG,YAAAA;IAHUH,iBAIVI,eAAAA;IAJUJ,iBAKVK,mBAAAA;GALUL,qBAAAA"}

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

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

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

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

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

@@ -0,0 +1,29 @@
+import { BoundOrderByNode, OrderByNode } from './Nodes';
+import { ParsedExpression } from './ParsedExpression';
+export declare enum ResultModifierType {
+    LIMIT_MODIFIER = "LIMIT_MODIFIER",
+    ORDER_MODIFIER = "ORDER_MODIFIER",
+    DISTINCT_MODIFIER = "DISTINCT_MODIFIER",
+    LIMIT_PERCENT_MODIFIER = "LIMIT_PERCENT_MODIFIER"
+}
+export interface BaseResultModifier {
+    type: ResultModifierType;
+}
+export type ResultModifier = LimitModifier | OrderModifier | DistinctModifier | LimitPercentModifier;
+export interface LimitModifier extends BaseResultModifier {
+    limit?: ParsedExpression;
+    offset?: ParsedExpression;
+}
+export interface DistinctModifier extends BaseResultModifier {
+    distinct_on_targets: ParsedExpression[];
+}
+export interface OrderModifier extends BaseResultModifier {
+    orders: OrderByNode[];
+}
+export interface LimitPercentModifier extends BaseResultModifier {
+    limit?: ParsedExpression;
+    offset?: ParsedExpression;
+}
+export interface BoundOrderModifier {
+    orders: BoundOrderByNode[];
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "ResultModifierType", {
+    enumerable: true,
+    get: function() {
+        return ResultModifierType;
+    }
+});
+var ResultModifierType;
+(function(ResultModifierType) {
+    ResultModifierType["LIMIT_MODIFIER"] = "LIMIT_MODIFIER";
+    ResultModifierType["ORDER_MODIFIER"] = "ORDER_MODIFIER";
+    ResultModifierType["DISTINCT_MODIFIER"] = "DISTINCT_MODIFIER";
+    ResultModifierType["LIMIT_PERCENT_MODIFIER"] = "LIMIT_PERCENT_MODIFIER";
+})(ResultModifierType || (ResultModifierType = {}));
+
+//# sourceMappingURL=ResultModifier.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/ResultModifier.ts"],"sourcesContent":["import { BoundOrderByNode, OrderByNode } from './Nodes';\nimport { ParsedExpression } from './ParsedExpression';\n\nexport enum ResultModifierType {\n  LIMIT_MODIFIER = 'LIMIT_MODIFIER',\n  ORDER_MODIFIER = 'ORDER_MODIFIER',\n  DISTINCT_MODIFIER = 'DISTINCT_MODIFIER',\n  LIMIT_PERCENT_MODIFIER = 'LIMIT_PERCENT_MODIFIER',\n}\n\nexport interface BaseResultModifier {\n  type: ResultModifierType;\n}\n\nexport type ResultModifier = LimitModifier | OrderModifier | DistinctModifier | LimitPercentModifier;\n\nexport interface LimitModifier extends BaseResultModifier {\n  limit?: ParsedExpression;\n  offset?: ParsedExpression;\n}\n\nexport interface DistinctModifier extends BaseResultModifier {\n  distinct_on_targets: ParsedExpression[];\n}\n\nexport interface OrderModifier extends BaseResultModifier {\n  orders: OrderByNode[];\n}\n\nexport interface LimitPercentModifier extends BaseResultModifier {\n  limit?: ParsedExpression;\n  offset?: ParsedExpression;\n}\n\nexport interface BoundOrderModifier {\n  orders: BoundOrderByNode[];\n}\n"],"names":["ResultModifierType","LIMIT_MODIFIER","ORDER_MODIFIER","DISTINCT_MODIFIER","LIMIT_PERCENT_MODIFIER"],"mappings":";;;;;;;IAGO;UAAKA,kBAAkB;IAAlBA,mBACVC,oBAAAA;IADUD,mBAEVE,oBAAAA;IAFUF,mBAGVG,uBAAAA;IAHUH,mBAIVI,4BAAAA;GAJUJ,uBAAAA"}

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

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

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

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

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

@@ -0,0 +1,4 @@
+import { QueryNode } from './QueryNode';
+export interface SelectStatement {
+    node: QueryNode;
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+import { ExpressionType } from './Expression';
+import { Value } from './Misc';
+export declare enum TableFilterType {
+    CONSTANT_COMPARISON = "CONSTANT_COMPARISON",
+    IS_NULL = "IS_NULL",
+    IS_NOT_NULL = "IS_NOT_NULL",
+    CONJUNCTION_OR = "CONJUNCTION_OR",
+    CONJUNCTION_AND = "CONJUNCTION_AND"
+}
+export interface BaseTableFilter {
+    filter_type: TableFilterType;
+}
+export type TableFilter = ConstantFilter | IsNullFilter | IsNotNullFilter | ConjunctionOrFilter | ConjunctionAndFilter;
+export interface IsNullFilter extends BaseTableFilter {
+    filter_type: TableFilterType.IS_NULL;
+}
+export interface IsNotNullFilter extends BaseTableFilter {
+    filter_type: TableFilterType.IS_NOT_NULL;
+}
+export interface ConstantFilter extends BaseTableFilter {
+    filter_type: TableFilterType.CONSTANT_COMPARISON;
+    comparison_type: ExpressionType;
+    constant: Value;
+}
+export interface ConjunctionOrFilter extends BaseTableFilter {
+    filter_type: TableFilterType.CONJUNCTION_OR;
+    child_filters: TableFilter[];
+}
+export interface ConjunctionAndFilter extends BaseTableFilter {
+    filter_type: TableFilterType.CONJUNCTION_AND;
+    child_filters: TableFilter[];
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "TableFilterType", {
+    enumerable: true,
+    get: function() {
+        return TableFilterType;
+    }
+});
+var TableFilterType;
+(function(TableFilterType) {
+    TableFilterType["CONSTANT_COMPARISON"] = "CONSTANT_COMPARISON";
+    TableFilterType["IS_NULL"] = "IS_NULL";
+    TableFilterType["IS_NOT_NULL"] = "IS_NOT_NULL";
+    TableFilterType["CONJUNCTION_OR"] = "CONJUNCTION_OR";
+    TableFilterType["CONJUNCTION_AND"] = "CONJUNCTION_AND";
+})(TableFilterType || (TableFilterType = {}));
+
+//# sourceMappingURL=TableFilter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/TableFilter.ts"],"sourcesContent":["import { ExpressionType } from './Expression';\nimport { Value } from './Misc';\n\nexport enum TableFilterType {\n  CONSTANT_COMPARISON = 'CONSTANT_COMPARISON',\n  IS_NULL = 'IS_NULL',\n  IS_NOT_NULL = 'IS_NOT_NULL',\n  CONJUNCTION_OR = 'CONJUNCTION_OR',\n  CONJUNCTION_AND = 'CONJUNCTION_AND',\n}\n\nexport interface BaseTableFilter {\n  filter_type: TableFilterType;\n}\n\nexport type TableFilter = ConstantFilter | IsNullFilter | IsNotNullFilter | ConjunctionOrFilter | ConjunctionAndFilter;\n\nexport interface IsNullFilter extends BaseTableFilter {\n  filter_type: TableFilterType.IS_NULL;\n}\n\nexport interface IsNotNullFilter extends BaseTableFilter {\n  filter_type: TableFilterType.IS_NOT_NULL;\n}\n\nexport interface ConstantFilter extends BaseTableFilter {\n  filter_type: TableFilterType.CONSTANT_COMPARISON;\n  comparison_type: ExpressionType;\n  constant: Value;\n}\n\nexport interface ConjunctionOrFilter extends BaseTableFilter {\n  filter_type: TableFilterType.CONJUNCTION_OR;\n  child_filters: TableFilter[];\n}\n\nexport interface ConjunctionAndFilter extends BaseTableFilter {\n  filter_type: TableFilterType.CONJUNCTION_AND;\n  child_filters: TableFilter[];\n}\n"],"names":["TableFilterType","CONSTANT_COMPARISON","IS_NULL","IS_NOT_NULL","CONJUNCTION_OR","CONJUNCTION_AND"],"mappings":";;;;;;;IAGO;UAAKA,eAAe;IAAfA,gBACVC,yBAAAA;IADUD,gBAEVE,aAAAA;IAFUF,gBAGVG,iBAAAA;IAHUH,gBAIVI,oBAAAA;IAJUJ,gBAKVK,qBAAAA;GALUL,oBAAAA"}

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

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

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

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

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

@@ -0,0 +1,84 @@
+import { LogicalType, PivotColumn, SampleOptions } from './Nodes';
+import { ParsedExpression } from './ParsedExpression';
+import { SelectStatement } from './Statement';
+export declare enum TableReferenceType {
+    INVALID = "INVALID",
+    BASE_TABLE = "BASE_TABLE",
+    SUBQUERY = "SUBQUERY",
+    JOIN = "JOIN",
+    TABLE_FUNCTION = "TABLE_FUNCTION",
+    EXPRESSION_LIST = "EXPRESSION_LIST",
+    CTE = "CTE",
+    EMPTY = "EMPTY",
+    PIVOT = "PIVOT"
+}
+export interface BaseTableRef {
+    type: TableReferenceType;
+    alias: string;
+    sample: SampleOptions | null;
+}
+export type TableRef = BaseTypeTableRef | SubqueryRef | JoinRef | TableFunctionRef | ExpressionListRef | EmptyTableRef | PivotRef;
+export interface BaseTypeTableRef extends BaseTableRef {
+    type: TableReferenceType.BASE_TABLE;
+    schema_name: string;
+    table_name: string;
+    column_name_alias: string[];
+    catalog_name: string;
+}
+export declare enum JoinType {
+    INVALID = "INVALID",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT",
+    INNER = "INNER",
+    OUTER = "OUTER",
+    SEMI = "SEMI",
+    ANTI = "ANTI",
+    MARK = "MARK",
+    SINGLE = "SINGLE"
+}
+export declare enum JoinRefType {
+    REGULAR = "REGULAR",
+    NATURAL = "NATURAL",
+    CROSS = "CROSS",
+    POSITIONAL = "POSITIONAL",
+    ASOF = "ASOF",
+    DEPENDENT = "DEPENDENT"
+}
+export interface JoinRef extends BaseTableRef {
+    type: TableReferenceType.JOIN;
+    left: TableRef;
+    right: TableRef;
+    condition?: ParsedExpression;
+    join_type: JoinType;
+    ref_type: JoinRefType;
+    using_columns: string[];
+}
+export interface SubqueryRef extends BaseTableRef {
+    type: TableReferenceType.SUBQUERY;
+    subquery: SelectStatement;
+    column_name_alias: string[];
+}
+export interface TableFunctionRef extends BaseTableRef {
+    type: TableReferenceType.TABLE_FUNCTION;
+    function: ParsedExpression;
+    column_name_alias: string[];
+}
+export interface EmptyTableRef extends BaseTableRef {
+    type: TableReferenceType.EMPTY;
+}
+export interface ExpressionListRef extends BaseTableRef {
+    type: TableReferenceType.EXPRESSION_LIST;
+    expected_names: string[];
+    expected_types: LogicalType[];
+    values: ParsedExpression[][];
+}
+export interface PivotRef extends BaseTableRef {
+    type: TableReferenceType.PIVOT;
+    source: TableRef;
+    aggregates: ParsedExpression[];
+    unpivot_names: string[];
+    pivots: PivotColumn[];
+    groups: string[];
+    column_name_alias: string[];
+    include_nulls: boolean;
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TableReferenceType: function() {
+        return TableReferenceType;
+    },
+    JoinType: function() {
+        return JoinType;
+    },
+    JoinRefType: function() {
+        return JoinRefType;
+    }
+});
+var TableReferenceType;
+(function(TableReferenceType) {
+    TableReferenceType["INVALID"] = "INVALID";
+    TableReferenceType["BASE_TABLE"] = "BASE_TABLE";
+    TableReferenceType["SUBQUERY"] = "SUBQUERY";
+    TableReferenceType["JOIN"] = "JOIN";
+    TableReferenceType["TABLE_FUNCTION"] = "TABLE_FUNCTION";
+    TableReferenceType["EXPRESSION_LIST"] = "EXPRESSION_LIST";
+    TableReferenceType["CTE"] = "CTE";
+    TableReferenceType["EMPTY"] = "EMPTY";
+    TableReferenceType["PIVOT"] = "PIVOT";
+})(TableReferenceType || (TableReferenceType = {}));
+var JoinType;
+(function(JoinType) {
+    JoinType["INVALID"] = "INVALID";
+    JoinType["LEFT"] = "LEFT";
+    JoinType["RIGHT"] = "RIGHT";
+    JoinType["INNER"] = "INNER";
+    JoinType["OUTER"] = "OUTER";
+    JoinType["SEMI"] = "SEMI";
+    JoinType["ANTI"] = "ANTI";
+    JoinType["MARK"] = "MARK";
+    JoinType["SINGLE"] = "SINGLE";
+})(JoinType || (JoinType = {}));
+var JoinRefType;
+(function(JoinRefType) {
+    JoinRefType["REGULAR"] = "REGULAR";
+    JoinRefType["NATURAL"] = "NATURAL";
+    JoinRefType["CROSS"] = "CROSS";
+    JoinRefType["POSITIONAL"] = "POSITIONAL";
+    JoinRefType["ASOF"] = "ASOF";
+    JoinRefType["DEPENDENT"] = "DEPENDENT";
+})(JoinRefType || (JoinRefType = {}));
+
+//# sourceMappingURL=TableRef.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/TableRef.ts"],"sourcesContent":["import { LogicalType, PivotColumn, SampleOptions } from './Nodes';\nimport { ParsedExpression } from './ParsedExpression';\nimport { SelectStatement } from './Statement';\n\nexport enum TableReferenceType {\n  INVALID = 'INVALID',\n  BASE_TABLE = 'BASE_TABLE',\n  SUBQUERY = 'SUBQUERY',\n  JOIN = 'JOIN',\n  TABLE_FUNCTION = 'TABLE_FUNCTION',\n  EXPRESSION_LIST = 'EXPRESSION_LIST',\n  CTE = 'CTE',\n  EMPTY = 'EMPTY',\n  PIVOT = 'PIVOT',\n}\n\nexport interface BaseTableRef {\n  type: TableReferenceType;\n  alias: string;\n  sample: SampleOptions | null;\n}\n\nexport type TableRef =\n  | BaseTypeTableRef\n  | SubqueryRef\n  | JoinRef\n  | TableFunctionRef\n  | ExpressionListRef\n  | EmptyTableRef\n  | PivotRef;\n\nexport interface BaseTypeTableRef extends BaseTableRef {\n  type: TableReferenceType.BASE_TABLE;\n  schema_name: string;\n  table_name: string;\n  column_name_alias: string[];\n  catalog_name: string;\n}\n\nexport enum JoinType {\n  INVALID = 'INVALID',\n  LEFT = 'LEFT',\n  RIGHT = 'RIGHT',\n  INNER = 'INNER',\n  OUTER = 'OUTER',\n  SEMI = 'SEMI',\n  ANTI = 'ANTI',\n  MARK = 'MARK',\n  SINGLE = 'SINGLE',\n}\n\nexport enum JoinRefType {\n  REGULAR = 'REGULAR',\n  NATURAL = 'NATURAL',\n  CROSS = 'CROSS',\n  POSITIONAL = 'POSITIONAL',\n  ASOF = 'ASOF',\n  DEPENDENT = 'DEPENDENT',\n}\n\nexport interface JoinRef extends BaseTableRef {\n  type: TableReferenceType.JOIN;\n  left: TableRef;\n  right: TableRef;\n  condition?: ParsedExpression;\n  join_type: JoinType;\n  ref_type: JoinRefType;\n  using_columns: string[];\n}\n\nexport interface SubqueryRef extends BaseTableRef {\n  type: TableReferenceType.SUBQUERY;\n  subquery: SelectStatement;\n  column_name_alias: string[];\n}\n\nexport interface TableFunctionRef extends BaseTableRef {\n  type: TableReferenceType.TABLE_FUNCTION;\n  function: ParsedExpression;\n  column_name_alias: string[];\n}\n\nexport interface EmptyTableRef extends BaseTableRef {\n  type: TableReferenceType.EMPTY;\n}\n\nexport interface ExpressionListRef extends BaseTableRef {\n  type: TableReferenceType.EXPRESSION_LIST;\n  expected_names: string[];\n  expected_types: LogicalType[];\n  values: ParsedExpression[][];\n}\n\nexport interface PivotRef extends BaseTableRef {\n  type: TableReferenceType.PIVOT;\n  source: TableRef;\n  aggregates: ParsedExpression[];\n  unpivot_names: string[];\n  pivots: PivotColumn[];\n  groups: string[];\n  column_name_alias: string[];\n  include_nulls: boolean;\n}\n"],"names":["TableReferenceType","INVALID","BASE_TABLE","SUBQUERY","JOIN","TABLE_FUNCTION","EXPRESSION_LIST","CTE","EMPTY","PIVOT","JoinType","LEFT","RIGHT","INNER","OUTER","SEMI","ANTI","MARK","SINGLE","JoinRefType","REGULAR","NATURAL","CROSS","POSITIONAL","ASOF","DEPENDENT"],"mappings":";;;;;;;;;;;;;;;;;;IAIO;UAAKA,kBAAkB;IAAlBA,mBACVC,aAAAA;IADUD,mBAEVE,gBAAAA;IAFUF,mBAGVG,cAAAA;IAHUH,mBAIVI,UAAAA;IAJUJ,mBAKVK,oBAAAA;IALUL,mBAMVM,qBAAAA;IANUN,mBAOVO,SAAAA;IAPUP,mBAQVQ,WAAAA;IARUR,mBASVS,WAAAA;GATUT,uBAAAA;IAmCL;UAAKU,QAAQ;IAARA,SACVT,aAAAA;IADUS,SAEVC,UAAAA;IAFUD,SAGVE,WAAAA;IAHUF,SAIVG,WAAAA;IAJUH,SAKVI,WAAAA;IALUJ,SAMVK,UAAAA;IANUL,SAOVM,UAAAA;IAPUN,SAQVO,UAAAA;IARUP,SASVQ,YAAAA;GATUR,aAAAA;IAYL;UAAKS,WAAW;IAAXA,YACVC,aAAAA;IADUD,YAEVE,aAAAA;IAFUF,YAGVG,WAAAA;IAHUH,YAIVI,gBAAAA;IAJUJ,YAKVK,UAAAA;IALUL,YAMVM,eAAAA;GANUN,gBAAAA"}

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

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

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

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