duckdb 0.3.2-dev722.0 → 0.3.2-dev741.0

package/src/duckdb.hpp

@@ -10,8 +10,9 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "f9e6e8675"
-#define DUCKDB_VERSION "0.3.2-dev722"
+#define DUCKDB_AMALGAMATION_EXTENDED 1
+#define DUCKDB_SOURCE_ID "3a66c6b20"
+#define DUCKDB_VERSION "0.3.2-dev741"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -17586,3 +17587,4548 @@ public:
 };
 
 } // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_scalar_function_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+struct CreateScalarFunctionInfo : public CreateFunctionInfo {
+	explicit CreateScalarFunctionInfo(ScalarFunction function)
+	    : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY) {
+		this->name = function.name;
+		functions.push_back(function);
+	}
+	explicit CreateScalarFunctionInfo(ScalarFunctionSet set)
+	    : CreateFunctionInfo(CatalogType::SCALAR_FUNCTION_ENTRY), functions(move(set.functions)) {
+		this->name = set.name;
+		for (auto &func : functions) {
+			func.name = set.name;
+		}
+	}
+
+	vector<ScalarFunction> functions;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		ScalarFunctionSet set(name);
+		set.functions = functions;
+		auto result = make_unique<CreateScalarFunctionInfo>(move(set));
+		CopyProperties(*result);
+		return move(result);
+	}
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+//! A table function in the catalog
+class ScalarFunctionCatalogEntry : public StandardEntry {
+public:
+	ScalarFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateScalarFunctionInfo *info)
+	    : StandardEntry(CatalogType::SCALAR_FUNCTION_ENTRY, schema, catalog, info->name), functions(info->functions) {
+	}
+
+	//! The scalar functions
+	vector<ScalarFunction> functions;
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_table_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+
+namespace duckdb {
+
+struct CreateTableInfo : public CreateInfo {
+	CreateTableInfo() : CreateInfo(CatalogType::TABLE_ENTRY, INVALID_SCHEMA) {
+	}
+	CreateTableInfo(string schema, string name) : CreateInfo(CatalogType::TABLE_ENTRY, schema), table(name) {
+	}
+
+	//! Table name to insert to
+	string table;
+	//! List of columns of the table
+	vector<ColumnDefinition> columns;
+	//! List of constraints on the table
+	vector<unique_ptr<Constraint>> constraints;
+	//! CREATE TABLE from QUERY
+	unique_ptr<SelectStatement> query;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateTableInfo>(schema, table);
+		CopyProperties(*result);
+		for (auto &column : columns) {
+			result->columns.push_back(column.Copy());
+		}
+		for (auto &constraint : constraints) {
+			result->constraints.push_back(constraint->Copy());
+		}
+		if (query) {
+			result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
+		}
+		return move(result);
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/parsed_data/bound_create_table_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/persistent_table_data.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/segment_tree.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/segment_base.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+class SegmentBase {
+public:
+	SegmentBase(idx_t start, idx_t count) : start(start), count(count) {
+	}
+	virtual ~SegmentBase() {
+		// destroy the chain of segments iteratively (rather than recursively)
+		while (next && next->next) {
+			next = move(next->next);
+		}
+	}
+
+	//! The start row id of this chunk
+	const idx_t start;
+	//! The amount of entries in this storage chunk
+	atomic<idx_t> count;
+	//! The next segment after this one
+	unique_ptr<SegmentBase> next;
+};
+
+} // namespace duckdb
+
+
+
+
+namespace duckdb {
+
+struct SegmentNode {
+	idx_t row_start;
+	SegmentBase *node;
+};
+
+//! The SegmentTree maintains a list of all segments of a specific column in a table, and allows searching for a segment
+//! by row number
+class SegmentTree {
+public:
+	//! The initial segment of the tree
+	unique_ptr<SegmentBase> root_node;
+	//! The nodes in the tree, can be binary searched
+	vector<SegmentNode> nodes;
+	//! Lock to access or modify the nodes
+	mutex node_lock;
+
+public:
+	//! Gets a pointer to the first segment. Useful for scans.
+	SegmentBase *GetRootSegment();
+	//! Gets a pointer to the last segment. Useful for appends.
+	SegmentBase *GetLastSegment();
+	//! Gets a pointer to a specific column segment for the given row
+	SegmentBase *GetSegment(idx_t row_number);
+	//! Append a column segment to the tree
+	void AppendSegment(unique_ptr<SegmentBase> segment);
+
+	//! Replace this tree with another tree, taking over its nodes in-place
+	void Replace(SegmentTree &other);
+
+	//! Get the segment index of the column segment for the given row (does not lock the segment tree!)
+	idx_t GetSegmentIndex(idx_t row_number);
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/data_pointer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/block.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+class Block : public FileBuffer {
+public:
+	Block(Allocator &allocator, block_id_t id);
+	Block(FileBuffer &source, block_id_t id);
+
+	block_id_t id;
+};
+
+struct BlockPointer {
+	block_id_t block_id;
+	uint32_t offset;
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/row_group.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/chunk_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+class RowGroup;
+struct SelectionVector;
+class Transaction;
+
+enum class ChunkInfoType : uint8_t { CONSTANT_INFO, VECTOR_INFO, EMPTY_INFO };
+
+class ChunkInfo {
+public:
+	ChunkInfo(idx_t start, ChunkInfoType type) : start(start), type(type) {
+	}
+	virtual ~ChunkInfo() {
+	}
+
+	//! The row index of the first row
+	idx_t start;
+	//! The ChunkInfo type
+	ChunkInfoType type;
+
+public:
+	//! Gets up to max_count entries from the chunk info. If the ret is 0>ret>max_count, the selection vector is filled
+	//! with the tuples
+	virtual idx_t GetSelVector(Transaction &transaction, SelectionVector &sel_vector, idx_t max_count) = 0;
+	virtual idx_t GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
+	                                    SelectionVector &sel_vector, idx_t max_count) = 0;
+	//! Returns whether or not a single row in the ChunkInfo should be used or not for the given transaction
+	virtual bool Fetch(Transaction &transaction, row_t row) = 0;
+	virtual void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) = 0;
+
+	virtual void Serialize(Serializer &serialize) = 0;
+	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
+};
+
+class ChunkConstantInfo : public ChunkInfo {
+public:
+	ChunkConstantInfo(idx_t start);
+
+	atomic<transaction_t> insert_id;
+	atomic<transaction_t> delete_id;
+
+public:
+	idx_t GetSelVector(Transaction &transaction, SelectionVector &sel_vector, idx_t max_count) override;
+	idx_t GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
+	                            SelectionVector &sel_vector, idx_t max_count) override;
+	bool Fetch(Transaction &transaction, row_t row) override;
+	void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) override;
+
+	void Serialize(Serializer &serialize) override;
+	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
+
+private:
+	template <class OP>
+	idx_t TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
+	                            idx_t max_count);
+};
+
+class ChunkVectorInfo : public ChunkInfo {
+public:
+	ChunkVectorInfo(idx_t start);
+
+	//! The transaction ids of the transactions that inserted the tuples (if any)
+	atomic<transaction_t> inserted[STANDARD_VECTOR_SIZE];
+	atomic<transaction_t> insert_id;
+	atomic<bool> same_inserted_id;
+
+	//! The transaction ids of the transactions that deleted the tuples (if any)
+	atomic<transaction_t> deleted[STANDARD_VECTOR_SIZE];
+	atomic<bool> any_deleted;
+
+public:
+	idx_t GetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
+	                   idx_t max_count);
+	idx_t GetSelVector(Transaction &transaction, SelectionVector &sel_vector, idx_t max_count) override;
+	idx_t GetCommittedSelVector(transaction_t min_start_id, transaction_t min_transaction_id,
+	                            SelectionVector &sel_vector, idx_t max_count) override;
+	bool Fetch(Transaction &transaction, row_t row) override;
+	void CommitAppend(transaction_t commit_id, idx_t start, idx_t end) override;
+
+	void Append(idx_t start, idx_t end, transaction_t commit_id);
+	idx_t Delete(Transaction &transaction, row_t rows[], idx_t count);
+	void CommitDelete(transaction_t commit_id, row_t rows[], idx_t count);
+
+	void Serialize(Serializer &serialize) override;
+	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
+
+private:
+	template <class OP>
+	idx_t TemplatedGetSelVector(transaction_t start_time, transaction_t transaction_id, SelectionVector &sel_vector,
+	                            idx_t max_count);
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/append_state.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+class ColumnSegment;
+class DataTable;
+class RowGroup;
+class UpdateSegment;
+class ValiditySegment;
+
+struct TableAppendState;
+
+struct ColumnAppendState {
+	//! The current segment of the append
+	ColumnSegment *current;
+	//! Child append states
+	vector<ColumnAppendState> child_appends;
+	//! The write lock that is held by the append
+	unique_ptr<StorageLockKey> lock;
+};
+
+struct RowGroupAppendState {
+	RowGroupAppendState(TableAppendState &parent_p) : parent(parent_p) {
+	}
+
+	//! The parent append state
+	TableAppendState &parent;
+	//! The current row_group we are appending to
+	RowGroup *row_group;
+	//! The column append states
+	unique_ptr<ColumnAppendState[]> states;
+	//! Offset within the row_group
+	idx_t offset_in_row_group;
+};
+
+struct IndexLock {
+	unique_lock<mutex> index_lock;
+};
+
+struct TableAppendState {
+	TableAppendState() : row_group_append_state(*this) {
+	}
+
+	RowGroupAppendState row_group_append_state;
+	unique_lock<mutex> append_lock;
+	row_t row_start;
+	row_t current_row;
+	idx_t remaining_append_count;
+};
+
+} // namespace duckdb
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/segment_statistics.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+class SegmentStatistics {
+public:
+	SegmentStatistics(LogicalType type);
+	SegmentStatistics(LogicalType type, unique_ptr<BaseStatistics> statistics);
+
+	LogicalType type;
+
+	//! Type-specific statistics of the segment
+	unique_ptr<BaseStatistics> statistics;
+
+public:
+	void Reset();
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/scan_options.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class TableScanType : uint8_t {
+	//! Regular table scan: scan all tuples that are relevant for the current transaction
+	TABLE_SCAN_REGULAR = 0,
+	//! Scan all rows, including any deleted rows. Committed updates are merged in.
+	TABLE_SCAN_COMMITTED_ROWS = 1,
+	//! Scan all rows, including any deleted rows. Throws an exception if there are any uncommitted updates.
+	TABLE_SCAN_COMMITTED_ROWS_DISALLOW_UPDATES = 2,
+	//! Scan all rows, excluding any permanently deleted rows.
+	//! Permanently deleted rows are rows which no transaction will ever need again.
+	TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED = 3
+};
+
+} // namespace duckdb
+
+
+
+namespace duckdb {
+class ColumnData;
+class DatabaseInstance;
+class DataTable;
+struct DataTableInfo;
+class ExpressionExecutor;
+class TableDataWriter;
+class UpdateSegment;
+class Vector;
+struct RowGroupPointer;
+struct VersionNode;
+
+class RowGroup : public SegmentBase {
+public:
+	friend class ColumnData;
+	friend class VersionDeleteState;
+
+public:
+	static constexpr const idx_t ROW_GROUP_VECTOR_COUNT = 120;
+	static constexpr const idx_t ROW_GROUP_SIZE = STANDARD_VECTOR_SIZE * ROW_GROUP_VECTOR_COUNT;
+
+public:
+	RowGroup(DatabaseInstance &db, DataTableInfo &table_info, idx_t start, idx_t count);
+	RowGroup(DatabaseInstance &db, DataTableInfo &table_info, const vector<LogicalType> &types,
+	         RowGroupPointer &pointer);
+	~RowGroup();
+
+private:
+	//! The database instance
+	DatabaseInstance &db;
+	//! The table info of this row_group
+	DataTableInfo &table_info;
+	//! The version info of the row_group (inserted and deleted tuple info)
+	shared_ptr<VersionNode> version_info;
+	//! The column data of the row_group
+	vector<shared_ptr<ColumnData>> columns;
+	//! The segment statistics for each of the columns
+	vector<shared_ptr<SegmentStatistics>> stats;
+
+public:
+	DatabaseInstance &GetDatabase() {
+		return db;
+	}
+	DataTableInfo &GetTableInfo() {
+		return table_info;
+	}
+	idx_t GetColumnIndex(ColumnData *data) {
+		for (idx_t i = 0; i < columns.size(); i++) {
+			if (columns[i].get() == data) {
+				return i;
+			}
+		}
+		return 0;
+	}
+
+	unique_ptr<RowGroup> AlterType(ClientContext &context, const LogicalType &target_type, idx_t changed_idx,
+	                               ExpressionExecutor &executor, TableScanState &scan_state, DataChunk &scan_chunk);
+	unique_ptr<RowGroup> AddColumn(ClientContext &context, ColumnDefinition &new_column, ExpressionExecutor &executor,
+	                               Expression *default_value, Vector &intermediate);
+	unique_ptr<RowGroup> RemoveColumn(idx_t removed_column);
+
+	void CommitDrop();
+	void CommitDropColumn(idx_t index);
+
+	void InitializeEmpty(const vector<LogicalType> &types);
+
+	//! Initialize a scan over this row_group
+	bool InitializeScan(RowGroupScanState &state);
+	bool InitializeScanWithOffset(RowGroupScanState &state, idx_t vector_offset);
+	//! Checks the given set of table filters against the row-group statistics. Returns false if the entire row group
+	//! can be skipped.
+	bool CheckZonemap(TableFilterSet &filters, const vector<column_t> &column_ids);
+	//! Checks the given set of table filters against the per-segment statistics. Returns false if any segments were
+	//! skipped.
+	bool CheckZonemapSegments(RowGroupScanState &state);
+	void Scan(Transaction &transaction, RowGroupScanState &state, DataChunk &result);
+	void ScanCommitted(RowGroupScanState &state, DataChunk &result, TableScanType type);
+
+	idx_t GetSelVector(Transaction &transaction, idx_t vector_idx, SelectionVector &sel_vector, idx_t max_count);
+	idx_t GetCommittedSelVector(transaction_t start_time, transaction_t transaction_id, idx_t vector_idx,
+	                            SelectionVector &sel_vector, idx_t max_count);
+
+	//! For a specific row, returns true if it should be used for the transaction and false otherwise.
+	bool Fetch(Transaction &transaction, idx_t row);
+	//! Fetch a specific row from the row_group and insert it into the result at the specified index
+	void FetchRow(Transaction &transaction, ColumnFetchState &state, const vector<column_t> &column_ids, row_t row_id,
+	              DataChunk &result, idx_t result_idx);
+
+	//! Append count rows to the version info
+	void AppendVersionInfo(Transaction &transaction, idx_t start, idx_t count, transaction_t commit_id);
+	//! Commit a previous append made by RowGroup::AppendVersionInfo
+	void CommitAppend(transaction_t commit_id, idx_t start, idx_t count);
+	//! Revert a previous append made by RowGroup::AppendVersionInfo
+	void RevertAppend(idx_t start);
+
+	//! Delete the given set of rows in the version manager
+	idx_t Delete(Transaction &transaction, DataTable *table, row_t *row_ids, idx_t count);
+
+	RowGroupPointer Checkpoint(TableDataWriter &writer, vector<unique_ptr<BaseStatistics>> &global_stats);
+	static void Serialize(RowGroupPointer &pointer, Serializer &serializer);
+	static RowGroupPointer Deserialize(Deserializer &source, const vector<ColumnDefinition> &columns);
+
+	void InitializeAppend(Transaction &transaction, RowGroupAppendState &append_state, idx_t remaining_append_count);
+	void Append(RowGroupAppendState &append_state, DataChunk &chunk, idx_t append_count);
+
+	void Update(Transaction &transaction, DataChunk &updates, row_t *ids, idx_t offset, idx_t count,
+	            const vector<column_t> &column_ids);
+	//! Update a single column; corresponds to DataTable::UpdateColumn
+	//! This method should only be called from the WAL
+	void UpdateColumn(Transaction &transaction, DataChunk &updates, Vector &row_ids,
+	                  const vector<column_t> &column_path);
+
+	void MergeStatistics(idx_t column_idx, BaseStatistics &other);
+	unique_ptr<BaseStatistics> GetStatistics(idx_t column_idx);
+
+	void GetStorageInfo(idx_t row_group_index, vector<vector<Value>> &result);
+
+	void Verify();
+
+	void NextVector(RowGroupScanState &state);
+
+private:
+	ChunkInfo *GetChunkInfo(idx_t vector_idx);
+
+	template <TableScanType TYPE>
+	void TemplatedScan(Transaction *transaction, RowGroupScanState &state, DataChunk &result);
+
+	static void CheckpointDeletes(VersionNode *versions, Serializer &serializer);
+	static shared_ptr<VersionNode> DeserializeDeletes(Deserializer &source);
+
+private:
+	mutex row_group_lock;
+	mutex stats_lock;
+};
+
+struct VersionNode {
+	unique_ptr<ChunkInfo> info[RowGroup::ROW_GROUP_VECTOR_COUNT];
+};
+
+} // namespace duckdb
+
+
+
+namespace duckdb {
+
+struct DataPointer {
+	uint64_t row_start;
+	uint64_t tuple_count;
+	BlockPointer block_pointer;
+	CompressionType compression_type;
+	//! Type-specific statistics of the segment
+	unique_ptr<BaseStatistics> statistics;
+};
+
+struct RowGroupPointer {
+	uint64_t row_start;
+	uint64_t tuple_count;
+	//! The data pointers of the column segments stored in the row group
+	vector<BlockPointer> data_pointers;
+	//! The per-column statistics of the row group
+	vector<unique_ptr<BaseStatistics>> statistics;
+	//! The versions information of the row group (if any)
+	shared_ptr<VersionNode> versions;
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+class BaseStatistics;
+
+class PersistentTableData {
+public:
+	explicit PersistentTableData(idx_t column_count);
+	~PersistentTableData();
+
+	vector<RowGroupPointer> row_groups;
+	vector<unique_ptr<BaseStatistics>> column_stats;
+};
+
+} // namespace duckdb
+
+
+
+namespace duckdb {
+class CatalogEntry;
+
+struct BoundCreateTableInfo {
+	explicit BoundCreateTableInfo(unique_ptr<CreateInfo> base) : base(move(base)) {
+	}
+
+	//! The schema to create the table in
+	SchemaCatalogEntry *schema;
+	//! The base CreateInfo object
+	unique_ptr<CreateInfo> base;
+	//! The map of column names -> column index, used during binding
+	case_insensitive_map_t<column_t> name_map;
+	//! List of constraints on the table
+	vector<unique_ptr<Constraint>> constraints;
+	//! List of bound constraints on the table
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
+	//! Bound default values
+	vector<unique_ptr<Expression>> bound_defaults;
+	//! Dependents of the table (in e.g. default values)
+	unordered_set<CatalogEntry *> dependencies;
+	//! The existing table data on disk (if any)
+	unique_ptr<PersistentTableData> data;
+	//! CREATE TABLE from QUERY
+	unique_ptr<LogicalOperator> query;
+
+	CreateTableInfo &Base() {
+		return (CreateTableInfo &)*base;
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/constraints/not_null_constraint.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+class NotNullConstraint : public Constraint {
+public:
+	DUCKDB_API explicit NotNullConstraint(column_t index);
+	DUCKDB_API ~NotNullConstraint() override;
+
+	//! Column index this constraint pertains to
+	column_t index;
+
+public:
+	DUCKDB_API string ToString() const override;
+
+	DUCKDB_API unique_ptr<Constraint> Copy() override;
+
+	//! Serialize to a stand-alone binary blob
+	DUCKDB_API void Serialize(Serializer &serializer) override;
+	//! Deserializes a NotNullConstraint
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/data_table.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/index_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Index Types
+//===--------------------------------------------------------------------===//
+enum class IndexType {
+	INVALID = 0, // invalid index type
+	ART = 1      // Adaptive Radix Tree
+};
+
+} // namespace duckdb
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/index.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/expression_executor.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+class ExecutionContext;
+//! ExpressionExecutor is responsible for executing a set of expressions and storing the result in a data chunk
+class ExpressionExecutor {
+public:
+	DUCKDB_API ExpressionExecutor();
+	DUCKDB_API explicit ExpressionExecutor(const Expression *expression);
+	DUCKDB_API explicit ExpressionExecutor(const Expression &expression);
+	DUCKDB_API explicit ExpressionExecutor(const vector<unique_ptr<Expression>> &expressions);
+
+	//! Add an expression to the set of to-be-executed expressions of the executor
+	DUCKDB_API void AddExpression(const Expression &expr);
+
+	//! Execute the set of expressions with the given input chunk and store the result in the output chunk
+	DUCKDB_API void Execute(DataChunk *input, DataChunk &result);
+	inline void Execute(DataChunk &input, DataChunk &result) {
+		Execute(&input, result);
+	}
+	inline void Execute(DataChunk &result) {
+		Execute(nullptr, result);
+	}
+
+	//! Execute the ExpressionExecutor and put the result in the result vector; this should only be used for expression
+	//! executors with a single expression
+	DUCKDB_API void ExecuteExpression(DataChunk &input, Vector &result);
+	//! Execute the ExpressionExecutor and put the result in the result vector; this should only be used for expression
+	//! executors with a single expression
+	DUCKDB_API void ExecuteExpression(Vector &result);
+	//! Execute the ExpressionExecutor and generate a selection vector from all true values in the result; this should
+	//! only be used with a single boolean expression
+	DUCKDB_API idx_t SelectExpression(DataChunk &input, SelectionVector &sel);
+
+	//! Execute the expression with index `expr_idx` and store the result in the result vector
+	DUCKDB_API void ExecuteExpression(idx_t expr_idx, Vector &result);
+	//! Evaluate a scalar expression and fold it into a single value
+	DUCKDB_API static Value EvaluateScalar(const Expression &expr);
+	//! Try to evaluate a scalar expression and fold it into a single value, returns false if an exception is thrown
+	DUCKDB_API static bool TryEvaluateScalar(const Expression &expr, Value &result);
+
+	//! Initialize the state of a given expression
+	static unique_ptr<ExpressionState> InitializeState(const Expression &expr, ExpressionExecutorState &state);
+
+	inline void SetChunk(DataChunk *chunk) {
+		this->chunk = chunk;
+	}
+	inline void SetChunk(DataChunk &chunk) {
+		SetChunk(&chunk);
+	}
+
+	DUCKDB_API vector<unique_ptr<ExpressionExecutorState>> &GetStates();
+
+	//! The expressions of the executor
+	vector<const Expression *> expressions;
+	//! The data chunk of the current physical operator, used to resolve
+	//! column references and determines the output cardinality
+	DataChunk *chunk = nullptr;
+
+protected:
+	void Initialize(const Expression &expr, ExpressionExecutorState &state);
+
+	static unique_ptr<ExpressionState> InitializeState(const BoundReferenceExpression &expr,
+	                                                   ExpressionExecutorState &state);
+	static unique_ptr<ExpressionState> InitializeState(const BoundBetweenExpression &expr,
+	                                                   ExpressionExecutorState &state);
+	static unique_ptr<ExpressionState> InitializeState(const BoundCaseExpression &expr, ExpressionExecutorState &state);
+	static unique_ptr<ExpressionState> InitializeState(const BoundCastExpression &expr, ExpressionExecutorState &state);
+	static unique_ptr<ExpressionState> InitializeState(const BoundComparisonExpression &expr,
+	                                                   ExpressionExecutorState &state);
+	static unique_ptr<ExpressionState> InitializeState(const BoundConjunctionExpression &expr,
+	                                                   ExpressionExecutorState &state);
+	static unique_ptr<ExpressionState> InitializeState(const BoundConstantExpression &expr,
+	                                                   ExpressionExecutorState &state);
+	static unique_ptr<ExpressionState> InitializeState(const BoundFunctionExpression &expr,
+	                                                   ExpressionExecutorState &state);
+	static unique_ptr<ExpressionState> InitializeState(const BoundOperatorExpression &expr,
+	                                                   ExpressionExecutorState &state);
+	static unique_ptr<ExpressionState> InitializeState(const BoundParameterExpression &expr,
+	                                                   ExpressionExecutorState &state);
+
+	void Execute(const Expression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             Vector &result);
+
+	void Execute(const BoundBetweenExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             Vector &result);
+	void Execute(const BoundCaseExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             Vector &result);
+	void Execute(const BoundCastExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             Vector &result);
+
+	void Execute(const BoundComparisonExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             Vector &result);
+	void Execute(const BoundConjunctionExpression &expr, ExpressionState *state, const SelectionVector *sel,
+	             idx_t count, Vector &result);
+	void Execute(const BoundConstantExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             Vector &result);
+	void Execute(const BoundFunctionExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             Vector &result);
+	void Execute(const BoundOperatorExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             Vector &result);
+	void Execute(const BoundParameterExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             Vector &result);
+	void Execute(const BoundReferenceExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             Vector &result);
+
+	//! Execute the (boolean-returning) expression and generate a selection vector with all entries that are "true" in
+	//! the result
+	idx_t Select(const Expression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             SelectionVector *true_sel, SelectionVector *false_sel);
+	idx_t DefaultSelect(const Expression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	                    SelectionVector *true_sel, SelectionVector *false_sel);
+
+	idx_t Select(const BoundBetweenExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             SelectionVector *true_sel, SelectionVector *false_sel);
+	idx_t Select(const BoundComparisonExpression &expr, ExpressionState *state, const SelectionVector *sel, idx_t count,
+	             SelectionVector *true_sel, SelectionVector *false_sel);
+	idx_t Select(const BoundConjunctionExpression &expr, ExpressionState *state, const SelectionVector *sel,
+	             idx_t count, SelectionVector *true_sel, SelectionVector *false_sel);
+
+	//! Verify that the output of a step in the ExpressionExecutor is correct
+	void Verify(const Expression &expr, Vector &result, idx_t count);
+
+	void FillSwitch(Vector &vector, Vector &result, const SelectionVector &sel, sel_t count);
+
+private:
+	//! The states of the expression executor; this holds any intermediates and temporary states of expressions
+	vector<unique_ptr<ExpressionExecutorState>> states;
+};
+} // namespace duckdb
+
+
+namespace duckdb {
+
+class ClientContext;
+class Transaction;
+
+struct IndexLock;
+
+//! The index is an abstract base class that serves as the basis for indexes
+class Index {
+public:
+	Index(IndexType type, const vector<column_t> &column_ids, const vector<unique_ptr<Expression>> &unbound_expressions,
+	      bool is_unique, bool is_primary);
+	virtual ~Index() = default;
+
+	//! The type of the index
+	IndexType type;
+	//! Column identifiers to extract from the base table
+	vector<column_t> column_ids;
+	//! unordered_set of column_ids used by the index
+	unordered_set<column_t> column_id_set;
+	//! Unbound expressions used by the index
+	vector<unique_ptr<Expression>> unbound_expressions;
+	//! The physical types stored in the index
+	vector<PhysicalType> types;
+	//! The logical types of the expressions
+	vector<LogicalType> logical_types;
+	//! Whether or not the index is an index built to enforce a UNIQUE or PRIMARY KEY constraint
+	bool is_unique;
+	//! Whether or not the index is an index built to enforce a PRIMARY KEY constraint
+	bool is_primary;
+
+public:
+	//! Initialize a scan on the index with the given expression and column ids
+	//! to fetch from the base table when we only have one query predicate
+	virtual unique_ptr<IndexScanState> InitializeScanSinglePredicate(Transaction &transaction, Value value,
+	                                                                 ExpressionType expressionType) = 0;
+	//! Initialize a scan on the index with the given expression and column ids
+	//! to fetch from the base table for two query predicates
+	virtual unique_ptr<IndexScanState> InitializeScanTwoPredicates(Transaction &transaction, Value low_value,
+	                                                               ExpressionType low_expression_type, Value high_value,
+	                                                               ExpressionType high_expression_type) = 0;
+	//! Perform a lookup on the index, fetching up to max_count result ids. Returns true if all row ids were fetched,
+	//! and false otherwise.
+	virtual bool Scan(Transaction &transaction, DataTable &table, IndexScanState &state, idx_t max_count,
+	                  vector<row_t> &result_ids) = 0;
+
+	//! Obtain a lock on the index
+	virtual void InitializeLock(IndexLock &state);
+	//! Called when data is appended to the index. The lock obtained from InitializeAppend must be held
+	virtual bool Append(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
+	bool Append(DataChunk &entries, Vector &row_identifiers);
+	//! Verify that data can be appended to the index
+	virtual void VerifyAppend(DataChunk &chunk) = 0;
+
+	//! Called when data inside the index is Deleted
+	virtual void Delete(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
+	void Delete(DataChunk &entries, Vector &row_identifiers);
+
+	//! Insert data into the index. Does not lock the index.
+	virtual bool Insert(IndexLock &lock, DataChunk &input, Vector &row_identifiers) = 0;
+
+	//! Returns true if the index is affected by updates on the specified column ids, and false otherwise
+	bool IndexIsUpdated(const vector<column_t> &column_ids) const;
+
+protected:
+	void ExecuteExpressions(DataChunk &input, DataChunk &result);
+
+	//! Lock used for updating the index
+	mutex lock;
+
+private:
+	//! Bound expressions used by the index
+	vector<unique_ptr<Expression>> bound_expressions;
+	//! Expression executor for the index expressions
+	ExpressionExecutor executor;
+
+	unique_ptr<Expression> BindExpression(unique_ptr<Expression> expr);
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table_statistics.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct TableStatistics {
+	idx_t estimated_cardinality;
+};
+
+} // namespace duckdb
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/column_segment.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/buffer_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/block_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+class ClientContext;
+class DatabaseInstance;
+
+//! BlockManager is an abstract representation to manage blocks on DuckDB. When writing or reading blocks, the
+//! BlockManager creates and accesses blocks. The concrete types implements how blocks are stored.
+class BlockManager {
+public:
+	virtual ~BlockManager() = default;
+
+	virtual void StartCheckpoint() = 0;
+	//! Creates a new block inside the block manager
+	virtual unique_ptr<Block> CreateBlock(block_id_t block_id) = 0;
+	//! Return the next free block id
+	virtual block_id_t GetFreeBlockId() = 0;
+	//! Returns whether or not a specified block is the root block
+	virtual bool IsRootBlock(block_id_t root) = 0;
+	//! Mark a block as "modified"; modified blocks are added to the free list after a checkpoint (i.e. their data is
+	//! assumed to be rewritten)
+	virtual void MarkBlockAsModified(block_id_t block_id) = 0;
+	//! Increase the reference count of a block. The block should hold at least one reference before this method is
+	//! called.
+	virtual void IncreaseBlockReferenceCount(block_id_t block_id) = 0;
+	//! Get the first meta block id
+	virtual block_id_t GetMetaBlock() = 0;
+	//! Read the content of the block from disk
+	virtual void Read(Block &block) = 0;
+	//! Writes the block to disk
+	virtual void Write(FileBuffer &block, block_id_t block_id) = 0;
+	//! Writes the block to disk
+	void Write(Block &block) {
+		Write(block, block.id);
+	}
+	//! Write the header; should be the final step of a checkpoint
+	virtual void WriteHeader(DatabaseHeader header) = 0;
+
+	//! Returns the number of total blocks
+	virtual idx_t TotalBlocks() = 0;
+	//! Returns the number of free blocks
+	virtual idx_t FreeBlocks() = 0;
+
+	static BlockManager &GetBlockManager(ClientContext &context);
+	static BlockManager &GetBlockManager(DatabaseInstance &db);
+};
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/buffer/block_handle.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+class BufferHandle;
+class BufferManager;
+class DatabaseInstance;
+class FileBuffer;
+
+enum class BlockState : uint8_t { BLOCK_UNLOADED = 0, BLOCK_LOADED = 1 };
+
+class BlockHandle {
+	friend struct BufferEvictionNode;
+	friend class BufferHandle;
+	friend class BufferManager;
+
+public:
+	BlockHandle(DatabaseInstance &db, block_id_t block_id);
+	BlockHandle(DatabaseInstance &db, block_id_t block_id, unique_ptr<FileBuffer> buffer, bool can_destroy,
+	            idx_t block_size);
+	~BlockHandle();
+
+	DatabaseInstance &db;
+
+public:
+	block_id_t BlockId() {
+		return block_id;
+	}
+
+	int32_t Readers() const {
+		return readers;
+	}
+
+private:
+	static unique_ptr<BufferHandle> Load(shared_ptr<BlockHandle> &handle);
+	void Unload();
+	bool CanUnload();
+
+	//! The block-level lock
+	mutex lock;
+	//! Whether or not the block is loaded/unloaded
+	BlockState state;
+	//! Amount of concurrent readers
+	atomic<int32_t> readers;
+	//! The block id of the block
+	const block_id_t block_id;
+	//! Pointer to loaded data (if any)
+	unique_ptr<FileBuffer> buffer;
+	//! Internal eviction timestamp
+	atomic<idx_t> eviction_timestamp;
+	//! Whether or not the buffer can be destroyed (only used for temporary buffers)
+	const bool can_destroy;
+	//! The memory usage of the block
+	idx_t memory_usage;
+};
+
+} // namespace duckdb
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/buffer/managed_buffer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+class DatabaseInstance;
+
+//! Managed buffer is an arbitrarily-sized buffer that is at least of size >= BLOCK_SIZE
+class ManagedBuffer : public FileBuffer {
+public:
+	ManagedBuffer(DatabaseInstance &db, idx_t size, bool can_destroy, block_id_t id);
+
+	DatabaseInstance &db;
+	//! Whether or not the managed buffer can be freely destroyed when unpinned.
+	//! - If can_destroy is true, the buffer can be destroyed when unpinned and hence be unrecoverable. After being
+	//! destroyed, Pin() will return false.
+	//! - If can_destroy is false, the buffer will instead be written to a temporary file on disk when unloaded from
+	//! memory, and read back into memory when Pin() is called.
+	bool can_destroy;
+	//! The internal id of the buffer
+	block_id_t id;
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+class DatabaseInstance;
+class TemporaryDirectoryHandle;
+struct EvictionQueue;
+
+//! The buffer manager is in charge of handling memory management for the database. It hands out memory buffers that can
+//! be used by the database internally.
+class BufferManager {
+	friend class BufferHandle;
+	friend class BlockHandle;
+
+public:
+	BufferManager(DatabaseInstance &db, string temp_directory, idx_t maximum_memory);
+	~BufferManager();
+
+	//! Register a block with the given block id in the base file
+	shared_ptr<BlockHandle> RegisterBlock(block_id_t block_id);
+
+	//! Register an in-memory buffer of arbitrary size, as long as it is >= BLOCK_SIZE. can_destroy signifies whether or
+	//! not the buffer can be destroyed when unpinned, or whether or not it needs to be written to a temporary file so
+	//! it can be reloaded. The resulting buffer will already be allocated, but needs to be pinned in order to be used.
+	shared_ptr<BlockHandle> RegisterMemory(idx_t block_size, bool can_destroy);
+
+	//! Convert an existing in-memory buffer into a persistent disk-backed block
+	shared_ptr<BlockHandle> ConvertToPersistent(BlockManager &block_manager, block_id_t block_id,
+	                                            shared_ptr<BlockHandle> old_block);
+
+	//! Allocate an in-memory buffer with a single pin.
+	//! The allocated memory is released when the buffer handle is destroyed.
+	unique_ptr<BufferHandle> Allocate(idx_t block_size);
+
+	//! Reallocate an in-memory buffer that is pinned.
+	void ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size);
+
+	unique_ptr<BufferHandle> Pin(shared_ptr<BlockHandle> &handle);
+	void Unpin(shared_ptr<BlockHandle> &handle);
+
+	void UnregisterBlock(block_id_t block_id, bool can_destroy);
+
+	//! Set a new memory limit to the buffer manager, throws an exception if the new limit is too low and not enough
+	//! blocks can be evicted
+	void SetLimit(idx_t limit = (idx_t)-1);
+
+	static BufferManager &GetBufferManager(ClientContext &context);
+	static BufferManager &GetBufferManager(DatabaseInstance &db);
+
+	idx_t GetUsedMemory() {
+		return current_memory;
+	}
+	idx_t GetMaxMemory() {
+		return maximum_memory;
+	}
+
+	const string &GetTemporaryDirectory() {
+		return temp_directory;
+	}
+
+	void SetTemporaryDirectory(string new_dir);
+
+private:
+	//! Evict blocks until the currently used memory + extra_memory fit, returns false if this was not possible
+	//! (i.e. not enough blocks could be evicted)
+	bool EvictBlocks(idx_t extra_memory, idx_t memory_limit);
+
+	//! Garbage collect eviction queue
+	void PurgeQueue();
+
+	//! Write a temporary buffer to disk
+	void WriteTemporaryBuffer(ManagedBuffer &buffer);
+	//! Read a temporary buffer from disk
+	unique_ptr<FileBuffer> ReadTemporaryBuffer(block_id_t id);
+	//! Get the path of the temporary buffer
+	string GetTemporaryPath(block_id_t id);
+
+	void DeleteTemporaryFile(block_id_t id);
+
+	void RequireTemporaryDirectory();
+
+	void AddToEvictionQueue(shared_ptr<BlockHandle> &handle);
+
+	string InMemoryWarning();
+
+private:
+	//! The database instance
+	DatabaseInstance &db;
+	//! The lock for changing the memory limit
+	mutex limit_lock;
+	//! The current amount of memory that is occupied by the buffer manager (in bytes)
+	atomic<idx_t> current_memory;
+	//! The maximum amount of memory that the buffer manager can keep (in bytes)
+	atomic<idx_t> maximum_memory;
+	//! The directory name where temporary files are stored
+	string temp_directory;
+	//! Lock for creating the temp handle
+	mutex temp_handle_lock;
+	//! Handle for the temporary directory
+	unique_ptr<TemporaryDirectoryHandle> temp_directory_handle;
+	//! The lock for the set of blocks
+	mutex blocks_lock;
+	//! A mapping of block id -> BlockHandle
+	unordered_map<block_id_t, weak_ptr<BlockHandle>> blocks;
+	//! Eviction queue
+	unique_ptr<EvictionQueue> queue;
+	//! The temporary id used for managed buffers
+	atomic<block_id_t> temporary_id;
+};
+} // namespace duckdb
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/compression_function.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/map.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include <map>
+
+namespace duckdb {
+using std::map;
+using std::multimap;
+} // namespace duckdb
+
+
+
+namespace duckdb {
+class DatabaseInstance;
+class ColumnData;
+class ColumnDataCheckpointer;
+class ColumnSegment;
+class SegmentStatistics;
+
+struct ColumnFetchState;
+struct ColumnScanState;
+struct SegmentScanState;
+
+struct AnalyzeState {
+	virtual ~AnalyzeState() {
+	}
+};
+
+struct CompressionState {
+	virtual ~CompressionState() {
+	}
+};
+
+struct CompressedSegmentState {
+	virtual ~CompressedSegmentState() {
+	}
+};
+
+//===--------------------------------------------------------------------===//
+// Analyze
+//===--------------------------------------------------------------------===//
+//! The analyze functions are used to determine whether or not to use this compression method
+//! The system first determines the potential compression methods to use based on the physical type of the column
+//! After that the following steps are taken:
+//! 1. The init_analyze is called to initialize the analyze state of every candidate compression method
+//! 2. The analyze method is called with all of the input data in the order in which it must be stored.
+//!    analyze can return "false". In that case, the compression method is taken out of consideration early.
+//! 3. The final_analyze method is called, which should return a score for the compression method
+
+//! The system then decides which compression function to use based on the analyzed score (returned from final_analyze)
+typedef unique_ptr<AnalyzeState> (*compression_init_analyze_t)(ColumnData &col_data, PhysicalType type);
+typedef bool (*compression_analyze_t)(AnalyzeState &state, Vector &input, idx_t count);
+typedef idx_t (*compression_final_analyze_t)(AnalyzeState &state);
+
+//===--------------------------------------------------------------------===//
+// Compress
+//===--------------------------------------------------------------------===//
+typedef unique_ptr<CompressionState> (*compression_init_compression_t)(ColumnDataCheckpointer &checkpointer,
+                                                                       unique_ptr<AnalyzeState> state);
+typedef void (*compression_compress_data_t)(CompressionState &state, Vector &scan_vector, idx_t count);
+typedef void (*compression_compress_finalize_t)(CompressionState &state);
+
+//===--------------------------------------------------------------------===//
+// Uncompress / Scan
+//===--------------------------------------------------------------------===//
+typedef unique_ptr<SegmentScanState> (*compression_init_segment_scan_t)(ColumnSegment &segment);
+typedef void (*compression_scan_vector_t)(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
+                                          Vector &result);
+typedef void (*compression_scan_partial_t)(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count,
+                                           Vector &result, idx_t result_offset);
+typedef void (*compression_fetch_row_t)(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
+                                        idx_t result_idx);
+typedef void (*compression_skip_t)(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count);
+
+//===--------------------------------------------------------------------===//
+// Append (optional)
+//===--------------------------------------------------------------------===//
+typedef unique_ptr<CompressedSegmentState> (*compression_init_segment_t)(ColumnSegment &segment, block_id_t block_id);
+typedef idx_t (*compression_append_t)(ColumnSegment &segment, SegmentStatistics &stats, VectorData &data, idx_t offset,
+                                      idx_t count);
+typedef idx_t (*compression_finalize_append_t)(ColumnSegment &segment, SegmentStatistics &stats);
+typedef void (*compression_revert_append_t)(ColumnSegment &segment, idx_t start_row);
+
+class CompressionFunction {
+public:
+	CompressionFunction(CompressionType type, PhysicalType data_type, compression_init_analyze_t init_analyze,
+	                    compression_analyze_t analyze, compression_final_analyze_t final_analyze,
+	                    compression_init_compression_t init_compression, compression_compress_data_t compress,
+	                    compression_compress_finalize_t compress_finalize, compression_init_segment_scan_t init_scan,
+	                    compression_scan_vector_t scan_vector, compression_scan_partial_t scan_partial,
+	                    compression_fetch_row_t fetch_row, compression_skip_t skip,
+	                    compression_init_segment_t init_segment = nullptr, compression_append_t append = nullptr,
+	                    compression_finalize_append_t finalize_append = nullptr,
+	                    compression_revert_append_t revert_append = nullptr)
+	    : type(type), data_type(data_type), init_analyze(init_analyze), analyze(analyze), final_analyze(final_analyze),
+	      init_compression(init_compression), compress(compress), compress_finalize(compress_finalize),
+	      init_scan(init_scan), scan_vector(scan_vector), scan_partial(scan_partial), fetch_row(fetch_row), skip(skip),
+	      init_segment(init_segment), append(append), finalize_append(finalize_append), revert_append(revert_append) {
+	}
+
+	//! Compression type
+	CompressionType type;
+	//! The data type this function can compress
+	PhysicalType data_type;
+
+	//! Analyze step: determine which compression function is the most effective
+	//! init_analyze is called once to set up the analyze state
+	compression_init_analyze_t init_analyze;
+	//! analyze is called several times (once per vector in the row group)
+	//! analyze should return true, unless compression is no longer possible with this compression method
+	//! in that case false should be returned
+	compression_analyze_t analyze;
+	//! final_analyze should return the score of the compression function
+	//! ideally this is the exact number of bytes required to store the data
+	//! this is not required/enforced: it can be an estimate as well
+	compression_final_analyze_t final_analyze;
+
+	//! Compression step: actually compress the data
+	//! init_compression is called once to set up the comperssion state
+	compression_init_compression_t init_compression;
+	//! compress is called several times (once per vector in the row group)
+	compression_compress_data_t compress;
+	//! compress_finalize is called after
+	compression_compress_finalize_t compress_finalize;
+
+	//! init_scan is called to set up the scan state
+	compression_init_segment_scan_t init_scan;
+	//! scan_vector scans an entire vector using the scan state
+	compression_scan_vector_t scan_vector;
+	//! scan_partial scans a subset of a vector
+	//! this can request > vector_size as well
+	//! this is used if a vector crosses segment boundaries, or for child columns of lists
+	compression_scan_partial_t scan_partial;
+	//! fetch an individual row from the compressed vector
+	//! used for index lookups
+	compression_fetch_row_t fetch_row;
+	//! Skip forward in the compressed segment
+	compression_skip_t skip;
+
+	// Append functions
+	//! This only really needs to be defined for uncompressed segments
+
+	//! Initialize a compressed segment (optional)
+	compression_init_segment_t init_segment;
+	//! Append to the compressed segment (optional)
+	compression_append_t append;
+	//! Finalize an append to the segment
+	compression_finalize_append_t finalize_append;
+	//! Revert append (optional)
+	compression_revert_append_t revert_append;
+};
+
+//! The set of compression functions
+struct CompressionFunctionSet {
+	map<CompressionType, map<PhysicalType, CompressionFunction>> functions;
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+class ColumnSegment;
+class BlockManager;
+class ColumnSegment;
+class ColumnData;
+class DatabaseInstance;
+class Transaction;
+class BaseStatistics;
+class UpdateSegment;
+class TableFilter;
+struct ColumnFetchState;
+struct ColumnScanState;
+struct ColumnAppendState;
+
+enum class ColumnSegmentType : uint8_t { TRANSIENT, PERSISTENT };
+//! TableFilter represents a filter pushed down into the table scan.
+
+class ColumnSegment : public SegmentBase {
+public:
+	~ColumnSegment() override;
+
+	//! The database instance
+	DatabaseInstance &db;
+	//! The type stored in the column
+	LogicalType type;
+	//! The size of the type
+	idx_t type_size;
+	//! The column segment type (transient or persistent)
+	ColumnSegmentType segment_type;
+	//! The compression function
+	CompressionFunction *function;
+	//! The statistics for the segment
+	SegmentStatistics stats;
+	//! The block that this segment relates to
+	shared_ptr<BlockHandle> block;
+
+	static unique_ptr<ColumnSegment> CreatePersistentSegment(DatabaseInstance &db, block_id_t id, idx_t offset,
+	                                                         const LogicalType &type_p, idx_t start, idx_t count,
+	                                                         CompressionType compression_type,
+	                                                         unique_ptr<BaseStatistics> statistics);
+	static unique_ptr<ColumnSegment> CreateTransientSegment(DatabaseInstance &db, const LogicalType &type, idx_t start);
+
+public:
+	void InitializeScan(ColumnScanState &state);
+	//! Scan one vector from this segment
+	void Scan(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset, bool entire_vector);
+	//! Fetch a value of the specific row id and append it to the result
+	void FetchRow(ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx);
+
+	static void FilterSelection(SelectionVector &sel, Vector &result, const TableFilter &filter,
+	                            idx_t &approved_tuple_count, ValidityMask &mask);
+
+	//! Skip a scan forward to the row_index specified in the scan state
+	void Skip(ColumnScanState &state);
+
+	//! Initialize an append of this segment. Appends are only supported on transient segments.
+	void InitializeAppend(ColumnAppendState &state);
+	//! Appends a (part of) vector to the segment, returns the amount of entries successfully appended
+	idx_t Append(ColumnAppendState &state, VectorData &data, idx_t offset, idx_t count);
+	//! Finalize the segment for appending - no more appends can follow on this segment
+	//! The segment should be compacted as much as possible
+	//! Returns the number of bytes occupied within the segment
+	idx_t FinalizeAppend();
+	//! Revert an append made to this segment
+	void RevertAppend(idx_t start_row);
+
+	//! Convert a transient in-memory segment into a persistent segment blocked by an on-disk block.
+	//! Only used during checkpointing.
+	void ConvertToPersistent(block_id_t block_id);
+	//! Convert a transient in-memory segment into a persistent segment blocked by an on-disk block.
+	void ConvertToPersistent(shared_ptr<BlockHandle> block, block_id_t block_id, uint32_t offset_in_block);
+
+	block_id_t GetBlockId() {
+		D_ASSERT(segment_type == ColumnSegmentType::PERSISTENT);
+		return block_id;
+	}
+
+	idx_t GetBlockOffset() {
+		D_ASSERT(segment_type == ColumnSegmentType::PERSISTENT || offset == 0);
+		return offset;
+	}
+
+	idx_t GetRelativeIndex(idx_t row_index) {
+		D_ASSERT(row_index >= this->start);
+		D_ASSERT(row_index <= this->start + this->count);
+		return row_index - this->start;
+	}
+
+	CompressedSegmentState *GetSegmentState() {
+		return segment_state.get();
+	}
+
+public:
+	ColumnSegment(DatabaseInstance &db, LogicalType type, ColumnSegmentType segment_type, idx_t start, idx_t count,
+	              CompressionFunction *function, unique_ptr<BaseStatistics> statistics, block_id_t block_id,
+	              idx_t offset);
+
+private:
+	void Scan(ColumnScanState &state, idx_t scan_count, Vector &result);
+	void ScanPartial(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset);
+
+private:
+	//! The block id that this segment relates to (persistent segment only)
+	block_id_t block_id;
+	//! The offset into the block (persistent segment only)
+	idx_t offset;
+	//! Storage associated with the compressed segment
+	unique_ptr<CompressedSegmentState> segment_state;
+};
+
+} // namespace duckdb
+
+
+
+
+
+
+
+
+
+namespace duckdb {
+class ClientContext;
+class ColumnDefinition;
+class DataTable;
+class RowGroup;
+class StorageManager;
+class TableCatalogEntry;
+class Transaction;
+class WriteAheadLog;
+class TableDataWriter;
+
+class TableIndexList {
+public:
+	//! Scan the catalog set, invoking the callback method for every entry
+	template <class T>
+	void Scan(T &&callback) {
+		// lock the catalog set
+		lock_guard<mutex> lock(indexes_lock);
+		for (auto &index : indexes) {
+			if (callback(*index)) {
+				break;
+			}
+		}
+	}
+
+	void AddIndex(unique_ptr<Index> index) {
+		D_ASSERT(index);
+		lock_guard<mutex> lock(indexes_lock);
+		indexes.push_back(move(index));
+	}
+
+	void RemoveIndex(Index *index) {
+		D_ASSERT(index);
+		lock_guard<mutex> lock(indexes_lock);
+
+		for (idx_t index_idx = 0; index_idx < indexes.size(); index_idx++) {
+			auto &index_entry = indexes[index_idx];
+			if (index_entry.get() == index) {
+				indexes.erase(indexes.begin() + index_idx);
+				break;
+			}
+		}
+	}
+
+	bool Empty() {
+		lock_guard<mutex> lock(indexes_lock);
+		return indexes.empty();
+	}
+
+	idx_t Count() {
+		lock_guard<mutex> lock(indexes_lock);
+		return indexes.size();
+	}
+
+private:
+	//! Indexes associated with the current table
+	mutex indexes_lock;
+	vector<unique_ptr<Index>> indexes;
+};
+
+struct DataTableInfo {
+	DataTableInfo(DatabaseInstance &db, string schema, string table)
+	    : db(db), cardinality(0), schema(move(schema)), table(move(table)) {
+	}
+
+	//! The database instance of the table
+	DatabaseInstance &db;
+	//! The amount of elements in the table. Note that this number signifies the amount of COMMITTED entries in the
+	//! table. It can be inaccurate inside of transactions. More work is needed to properly support that.
+	atomic<idx_t> cardinality;
+	// schema of the table
+	string schema;
+	// name of the table
+	string table;
+
+	TableIndexList indexes;
+
+	bool IsTemporary() {
+		return schema == TEMP_SCHEMA;
+	}
+};
+
+struct ParallelTableScanState {
+	RowGroup *current_row_group;
+	idx_t vector_index;
+	idx_t max_row;
+	LocalScanState local_state;
+	bool transaction_local_data;
+};
+
+//! DataTable represents a physical table on disk
+class DataTable {
+public:
+	//! Constructs a new data table from an (optional) set of persistent segments
+	DataTable(DatabaseInstance &db, const string &schema, const string &table,
+	          vector<ColumnDefinition> column_definitions_p, unique_ptr<PersistentTableData> data = nullptr);
+	//! Constructs a DataTable as a delta on an existing data table with a newly added column
+	DataTable(ClientContext &context, DataTable &parent, ColumnDefinition &new_column, Expression *default_value);
+	//! Constructs a DataTable as a delta on an existing data table but with one column removed
+	DataTable(ClientContext &context, DataTable &parent, idx_t removed_column);
+	//! Constructs a DataTable as a delta on an existing data table but with one column changed type
+	DataTable(ClientContext &context, DataTable &parent, idx_t changed_idx, const LogicalType &target_type,
+	          vector<column_t> bound_columns, Expression &cast_expr);
+
+	shared_ptr<DataTableInfo> info;
+
+	vector<ColumnDefinition> column_definitions;
+
+	//! A reference to the database instance
+	DatabaseInstance &db;
+
+public:
+	//! Returns a list of types of the table
+	vector<LogicalType> GetTypes();
+
+	void InitializeScan(TableScanState &state, const vector<column_t> &column_ids,
+	                    TableFilterSet *table_filter = nullptr);
+	void InitializeScan(Transaction &transaction, TableScanState &state, const vector<column_t> &column_ids,
+	                    TableFilterSet *table_filters = nullptr);
+
+	//! Returns the maximum amount of threads that should be assigned to scan this data table
+	idx_t MaxThreads(ClientContext &context);
+	void InitializeParallelScan(ClientContext &context, ParallelTableScanState &state);
+	bool NextParallelScan(ClientContext &context, ParallelTableScanState &state, TableScanState &scan_state,
+	                      const vector<column_t> &column_ids);
+
+	//! Scans up to STANDARD_VECTOR_SIZE elements from the table starting
+	//! from offset and store them in result. Offset is incremented with how many
+	//! elements were returned.
+	//! Returns true if all pushed down filters were executed during data fetching
+	void Scan(Transaction &transaction, DataChunk &result, TableScanState &state, vector<column_t> &column_ids);
+
+	//! Fetch data from the specific row identifiers from the base table
+	void Fetch(Transaction &transaction, DataChunk &result, const vector<column_t> &column_ids, Vector &row_ids,
+	           idx_t fetch_count, ColumnFetchState &state);
+
+	//! Append a DataChunk to the table. Throws an exception if the columns don't match the tables' columns.
+	void Append(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk);
+	//! Delete the entries with the specified row identifier from the table
+	idx_t Delete(TableCatalogEntry &table, ClientContext &context, Vector &row_ids, idx_t count);
+	//! Update the entries with the specified row identifier from the table
+	void Update(TableCatalogEntry &table, ClientContext &context, Vector &row_ids, const vector<column_t> &column_ids,
+	            DataChunk &data);
+	//! Update a single (sub-)column along a column path
+	//! The column_path vector is a *path* towards a column within the table
+	//! i.e. if we have a table with a single column S STRUCT(A INT, B INT)
+	//! and we update the validity mask of "S.B"
+	//! the column path is:
+	//! 0 (first column of table)
+	//! -> 1 (second subcolumn of struct)
+	//! -> 0 (first subcolumn of INT)
+	//! This method should only be used from the WAL replay. It does not verify update constraints.
+	void UpdateColumn(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
+	                  const vector<column_t> &column_path, DataChunk &updates);
+
+	//! Add an index to the DataTable
+	void AddIndex(unique_ptr<Index> index, const vector<unique_ptr<Expression>> &expressions);
+
+	//! Begin appending structs to this table, obtaining necessary locks, etc
+	void InitializeAppend(Transaction &transaction, TableAppendState &state, idx_t append_count);
+	//! Append a chunk to the table using the AppendState obtained from BeginAppend
+	void Append(Transaction &transaction, DataChunk &chunk, TableAppendState &state);
+	//! Commit the append
+	void CommitAppend(transaction_t commit_id, idx_t row_start, idx_t count);
+	//! Write a segment of the table to the WAL
+	void WriteToLog(WriteAheadLog &log, idx_t row_start, idx_t count);
+	//! Revert a set of appends made by the given AppendState, used to revert appends in the event of an error during
+	//! commit (e.g. because of an I/O exception)
+	void RevertAppend(idx_t start_row, idx_t count);
+	void RevertAppendInternal(idx_t start_row, idx_t count);
+
+	void ScanTableSegment(idx_t start_row, idx_t count, const std::function<void(DataChunk &chunk)> &function);
+
+	//! Append a chunk with the row ids [row_start, ..., row_start + chunk.size()] to all indexes of the table, returns
+	//! whether or not the append succeeded
+	bool AppendToIndexes(TableAppendState &state, DataChunk &chunk, row_t row_start);
+	//! Remove a chunk with the row ids [row_start, ..., row_start + chunk.size()] from all indexes of the table
+	void RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, row_t row_start);
+	//! Remove the chunk with the specified set of row identifiers from all indexes of the table
+	void RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, Vector &row_identifiers);
+	//! Remove the row identifiers from all the indexes of the table
+	void RemoveFromIndexes(Vector &row_identifiers, idx_t count);
+
+	void SetAsRoot() {
+		this->is_root = true;
+	}
+
+	unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id);
+
+	//! Checkpoint the table to the specified table data writer
+	BlockPointer Checkpoint(TableDataWriter &writer);
+	void CommitDropTable();
+	void CommitDropColumn(idx_t index);
+
+	idx_t GetTotalRows();
+
+	//! Appends an empty row_group to the table
+	void AppendRowGroup(idx_t start_row);
+
+	vector<vector<Value>> GetStorageInfo();
+
+private:
+	//! Verify constraints with a chunk from the Append containing all columns of the table
+	void VerifyAppendConstraints(TableCatalogEntry &table, DataChunk &chunk);
+	//! Verify constraints with a chunk from the Update containing only the specified column_ids
+	void VerifyUpdateConstraints(TableCatalogEntry &table, DataChunk &chunk, const vector<column_t> &column_ids);
+
+	void InitializeScanWithOffset(TableScanState &state, const vector<column_t> &column_ids, idx_t start_row,
+	                              idx_t end_row);
+	bool InitializeScanInRowGroup(TableScanState &state, const vector<column_t> &column_ids,
+	                              TableFilterSet *table_filters, RowGroup *row_group, idx_t vector_index,
+	                              idx_t max_row);
+	bool ScanBaseTable(Transaction &transaction, DataChunk &result, TableScanState &state);
+
+	//! The CreateIndexScan is a special scan that is used to create an index on the table, it keeps locks on the table
+	void InitializeCreateIndexScan(CreateIndexScanState &state, const vector<column_t> &column_ids);
+	bool ScanCreateIndex(CreateIndexScanState &state, DataChunk &result, TableScanType type);
+
+private:
+	//! Lock for appending entries to the table
+	mutex append_lock;
+	//! The number of rows in the table
+	atomic<idx_t> total_rows;
+	//! The segment trees holding the various row_groups of the table
+	shared_ptr<SegmentTree> row_groups;
+	//! Column statistics
+	vector<unique_ptr<BaseStatistics>> column_stats;
+	//! The statistics lock
+	mutex stats_lock;
+	//! Whether or not the data table is the root DataTable for this table; the root DataTable is the newest version
+	//! that can be appended to
+	atomic<bool> is_root;
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/pragma_function.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/pragma_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+
+enum class PragmaType : uint8_t { PRAGMA_STATEMENT, PRAGMA_CALL };
+
+struct PragmaInfo : public ParseInfo {
+	//! Name of the PRAGMA statement
+	string name;
+	//! Parameter list (if any)
+	vector<Value> parameters;
+	//! Named parameter list (if any)
+	unordered_map<string, Value> named_parameters;
+
+public:
+	unique_ptr<PragmaInfo> Copy() const {
+		auto result = make_unique<PragmaInfo>();
+		result->name = name;
+		result->parameters = parameters;
+		result->named_parameters = named_parameters;
+		return result;
+	}
+};
+
+} // namespace duckdb
+
+
+
+namespace duckdb {
+class ClientContext;
+
+//! Return a substitute query to execute instead of this pragma statement
+typedef string (*pragma_query_t)(ClientContext &context, const FunctionParameters &parameters);
+//! Execute the main pragma function
+typedef void (*pragma_function_t)(ClientContext &context, const FunctionParameters &parameters);
+
+//! Pragma functions are invoked by calling PRAGMA x
+//! Pragma functions come in three types:
+//! * Call: function call, e.g. PRAGMA table_info('tbl')
+//!   -> call statements can take multiple parameters
+//! * Statement: statement without parameters, e.g. PRAGMA show_tables
+//!   -> this is similar to a call pragma but without parameters
+//! Pragma functions can either return a new query to execute (pragma_query_t)
+//! or they can
+class PragmaFunction : public SimpleNamedParameterFunction {
+public:
+	// Call
+	DUCKDB_API static PragmaFunction PragmaCall(const string &name, pragma_query_t query, vector<LogicalType> arguments,
+	                                            LogicalType varargs = LogicalType::INVALID);
+	DUCKDB_API static PragmaFunction PragmaCall(const string &name, pragma_function_t function,
+	                                            vector<LogicalType> arguments,
+	                                            LogicalType varargs = LogicalType::INVALID);
+	// Statement
+	DUCKDB_API static PragmaFunction PragmaStatement(const string &name, pragma_query_t query);
+	DUCKDB_API static PragmaFunction PragmaStatement(const string &name, pragma_function_t function);
+
+	DUCKDB_API string ToString() override;
+
+public:
+	PragmaType type;
+
+	pragma_query_t query;
+	pragma_function_t function;
+	unordered_map<string, LogicalType> named_parameters;
+
+private:
+	PragmaFunction(string name, PragmaType pragma_type, pragma_query_t query, pragma_function_t function,
+	               vector<LogicalType> arguments, LogicalType varargs);
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parser.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/simplified_token.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+//! Simplified tokens are a simplified (dense) representation of the lexer
+//! Used for simple syntax highlighting in the tests
+enum class SimplifiedTokenType : uint8_t {
+	SIMPLIFIED_TOKEN_IDENTIFIER,
+	SIMPLIFIED_TOKEN_NUMERIC_CONSTANT,
+	SIMPLIFIED_TOKEN_STRING_CONSTANT,
+	SIMPLIFIED_TOKEN_OPERATOR,
+	SIMPLIFIED_TOKEN_KEYWORD,
+	SIMPLIFIED_TOKEN_COMMENT
+};
+
+struct SimplifiedToken {
+	SimplifiedTokenType type;
+	idx_t start;
+};
+
+} // namespace duckdb
+
+
+namespace duckdb_libpgquery {
+struct PGNode;
+struct PGList;
+} // namespace duckdb_libpgquery
+
+namespace duckdb {
+
+//! The parser is responsible for parsing the query and converting it into a set
+//! of parsed statements. The parsed statements can then be converted into a
+//! plan and executed.
+class Parser {
+public:
+	Parser();
+
+	//! Attempts to parse a query into a series of SQL statements. Returns
+	//! whether or not the parsing was successful. If the parsing was
+	//! successful, the parsed statements will be stored in the statements
+	//! variable.
+	void ParseQuery(const string &query);
+
+	//! Tokenize a query, returning the raw tokens together with their locations
+	static vector<SimplifiedToken> Tokenize(const string &query);
+
+	//! Returns true if the given text matches a keyword of the parser
+	static bool IsKeyword(const string &text);
+
+	//! Parses a list of expressions (i.e. the list found in a SELECT clause)
+	static vector<unique_ptr<ParsedExpression>> ParseExpressionList(const string &select_list);
+	//! Parses a list as found in an ORDER BY expression (i.e. including optional ASCENDING/DESCENDING modifiers)
+	static vector<OrderByNode> ParseOrderList(const string &select_list);
+	//! Parses an update list (i.e. the list found in the SET clause of an UPDATE statement)
+	static void ParseUpdateList(const string &update_list, vector<string> &update_columns,
+	                            vector<unique_ptr<ParsedExpression>> &expressions);
+	//! Parses a VALUES list (i.e. the list of expressions after a VALUES clause)
+	static vector<vector<unique_ptr<ParsedExpression>>> ParseValuesList(const string &value_list);
+	//! Parses a column list (i.e. as found in a CREATE TABLE statement)
+	static vector<ColumnDefinition> ParseColumnList(const string &column_list);
+
+	//! The parsed SQL statements from an invocation to ParseQuery.
+	vector<unique_ptr<SQLStatement>> statements;
+
+private:
+	//! Transform a Postgres parse tree into a set of SQL Statements
+	bool TransformList(duckdb_libpgquery::PGList *tree);
+	//! Transform a single Postgres parse node into a SQL Statement.
+	unique_ptr<SQLStatement> TransformNode(duckdb_libpgquery::PGNode *stmt);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/object_cache.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+
+
+namespace duckdb {
+class ClientContext;
+
+//! ObjectCache is the base class for objects caches in DuckDB
+class ObjectCacheEntry {
+public:
+	virtual ~ObjectCacheEntry() {
+	}
+
+	virtual string GetObjectType() = 0;
+};
+
+class ObjectCache {
+public:
+	shared_ptr<ObjectCacheEntry> GetObject(const string &key) {
+		lock_guard<mutex> glock(lock);
+		auto entry = cache.find(key);
+		if (entry == cache.end()) {
+			return nullptr;
+		}
+		return entry->second;
+	}
+
+	template <class T>
+	shared_ptr<T> Get(const string &key) {
+		shared_ptr<ObjectCacheEntry> object = GetObject(key);
+		if (!object || object->GetObjectType() != T::ObjectType()) {
+			return nullptr;
+		}
+		return std::static_pointer_cast<T, ObjectCacheEntry>(object);
+	}
+
+	void Put(string key, shared_ptr<ObjectCacheEntry> value) {
+		lock_guard<mutex> glock(lock);
+		cache[key] = move(value);
+	}
+
+	static ObjectCache &GetObjectCache(ClientContext &context);
+	static bool ObjectCacheEnabled(ClientContext &context);
+
+private:
+	//! Object Cache
+	unordered_map<string, shared_ptr<ObjectCacheEntry>> cache;
+	mutex lock;
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/table_filter.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/filter_propagate_result.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class FilterPropagateResult : uint8_t {
+	NO_PRUNING_POSSIBLE = 0,
+	FILTER_ALWAYS_TRUE = 1,
+	FILTER_ALWAYS_FALSE = 2,
+	FILTER_TRUE_OR_NULL = 3,
+	FILTER_FALSE_OR_NULL = 4
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+class BaseStatistics;
+
+enum class TableFilterType : uint8_t {
+	CONSTANT_COMPARISON = 0, // constant comparison (e.g. =C, >C, >=C, <C, <=C)
+	IS_NULL = 1,
+	IS_NOT_NULL = 2,
+	CONJUNCTION_OR = 3,
+	CONJUNCTION_AND = 4
+};
+
+//! TableFilter represents a filter pushed down into the table scan.
+class TableFilter {
+public:
+	TableFilter(TableFilterType filter_type_p) : filter_type(filter_type_p) {
+	}
+	virtual ~TableFilter() {
+	}
+
+	TableFilterType filter_type;
+
+public:
+	//! Returns true if the statistics indicate that the segment can contain values that satisfy that filter
+	virtual FilterPropagateResult CheckStatistics(BaseStatistics &stats) = 0;
+	virtual string ToString(const string &column_name) = 0;
+	virtual bool Equals(const TableFilter &other) const {
+		return filter_type != other.filter_type;
+	}
+};
+
+class TableFilterSet {
+public:
+	unordered_map<idx_t, unique_ptr<TableFilter>> filters;
+
+public:
+	void PushFilter(idx_t table_index, unique_ptr<TableFilter> filter);
+
+	bool Equals(TableFilterSet &other) {
+		if (filters.size() != other.filters.size()) {
+			return false;
+		}
+		for (auto &entry : filters) {
+			auto other_entry = other.filters.find(entry.first);
+			if (other_entry == other.filters.end()) {
+				return false;
+			}
+			if (!entry.second->Equals(*other_entry->second)) {
+				return false;
+			}
+		}
+		return true;
+	}
+	static bool Equals(TableFilterSet *left, TableFilterSet *right) {
+		if (left == right) {
+			return true;
+		}
+		if (!left || !right) {
+			return false;
+		}
+		return left->Equals(*right);
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/string_statistics.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/validity_statistics.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+class Serializer;
+class Deserializer;
+class Vector;
+
+class ValidityStatistics : public BaseStatistics {
+public:
+	ValidityStatistics(bool has_null = false, bool has_no_null = true);
+
+	//! Whether or not the segment can contain NULL values
+	bool has_null;
+	//! Whether or not the segment can contain values that are not null
+	bool has_no_null;
+
+public:
+	void Merge(const BaseStatistics &other) override;
+
+	bool IsConstant() override;
+
+	unique_ptr<BaseStatistics> Copy() override;
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source);
+	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) override;
+
+	static unique_ptr<BaseStatistics> Combine(const unique_ptr<BaseStatistics> &lstats,
+	                                          const unique_ptr<BaseStatistics> &rstats);
+
+	string ToString() override;
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+class StringStatistics : public BaseStatistics {
+public:
+	constexpr static uint32_t MAX_STRING_MINMAX_SIZE = 8;
+
+public:
+	explicit StringStatistics(LogicalType type);
+
+	//! The minimum value of the segment, potentially truncated
+	data_t min[MAX_STRING_MINMAX_SIZE];
+	//! The maximum value of the segment, potentially truncated
+	data_t max[MAX_STRING_MINMAX_SIZE];
+	//! Whether or not the column can contain unicode characters
+	bool has_unicode;
+	//! The maximum string length in bytes
+	uint32_t max_string_length;
+	//! Whether or not the segment contains any big strings in overflow blocks
+	bool has_overflow_strings;
+
+public:
+	void Update(const string_t &value);
+	void Merge(const BaseStatistics &other) override;
+
+	unique_ptr<BaseStatistics> Copy() override;
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source, LogicalType type);
+	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) override;
+
+	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const string &value);
+
+	string ToString() override;
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/numeric_statistics.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/windows_undefs.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#ifdef WIN32
+
+#ifdef min
+#undef min
+#endif
+
+#ifdef max
+#undef max
+#endif
+
+#ifdef ERROR
+#undef ERROR
+#endif
+
+#ifdef small
+#undef small
+#endif
+
+#ifdef CreateDirectory
+#undef CreateDirectory
+#endif
+
+#ifdef MoveFile
+#undef MoveFile
+#endif
+
+#ifdef RemoveDirectory
+#undef RemoveDirectory
+#endif
+
+#endif
+
+
+
+namespace duckdb {
+
+class NumericStatistics : public BaseStatistics {
+public:
+	explicit NumericStatistics(LogicalType type);
+	NumericStatistics(LogicalType type, Value min, Value max);
+
+	//! The minimum value of the segment
+	Value min;
+	//! The maximum value of the segment
+	Value max;
+
+public:
+	void Merge(const BaseStatistics &other) override;
+
+	bool IsConstant() override;
+
+	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant);
+
+	unique_ptr<BaseStatistics> Copy() override;
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source, LogicalType type);
+	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) override;
+
+	string ToString() override;
+
+private:
+	template <class T>
+	void TemplatedVerify(Vector &vector, const SelectionVector &sel, idx_t count);
+
+public:
+	template <class T>
+	static inline void UpdateValue(T new_value, T &min, T &max) {
+		if (LessThan::Operation(new_value, min)) {
+			min = new_value;
+		}
+		if (GreaterThan::Operation(new_value, max)) {
+			max = new_value;
+		}
+	}
+
+	template <class T>
+	static inline void Update(SegmentStatistics &stats, T new_value);
+};
+
+template <>
+void NumericStatistics::Update<int8_t>(SegmentStatistics &stats, int8_t new_value);
+template <>
+void NumericStatistics::Update<int16_t>(SegmentStatistics &stats, int16_t new_value);
+template <>
+void NumericStatistics::Update<int32_t>(SegmentStatistics &stats, int32_t new_value);
+template <>
+void NumericStatistics::Update<int64_t>(SegmentStatistics &stats, int64_t new_value);
+template <>
+void NumericStatistics::Update<uint8_t>(SegmentStatistics &stats, uint8_t new_value);
+template <>
+void NumericStatistics::Update<uint16_t>(SegmentStatistics &stats, uint16_t new_value);
+template <>
+void NumericStatistics::Update<uint32_t>(SegmentStatistics &stats, uint32_t new_value);
+template <>
+void NumericStatistics::Update<uint64_t>(SegmentStatistics &stats, uint64_t new_value);
+template <>
+void NumericStatistics::Update<hugeint_t>(SegmentStatistics &stats, hugeint_t new_value);
+template <>
+void NumericStatistics::Update<float>(SegmentStatistics &stats, float new_value);
+template <>
+void NumericStatistics::Update<double>(SegmentStatistics &stats, double new_value);
+template <>
+void NumericStatistics::Update<interval_t>(SegmentStatistics &stats, interval_t new_value);
+template <>
+void NumericStatistics::Update<list_entry_t>(SegmentStatistics &stats, list_entry_t new_value);
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/filter/conjunction_filter.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+class ConjunctionOrFilter : public TableFilter {
+public:
+	ConjunctionOrFilter();
+
+	//! The filters to OR together
+	vector<unique_ptr<TableFilter>> child_filters;
+
+public:
+	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
+	string ToString(const string &column_name) override;
+	bool Equals(const TableFilter &other) const override;
+};
+
+class ConjunctionAndFilter : public TableFilter {
+public:
+	ConjunctionAndFilter();
+
+	//! The filters to OR together
+	vector<unique_ptr<TableFilter>> child_filters;
+
+public:
+	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
+	string ToString(const string &column_name) override;
+	bool Equals(const TableFilter &other) const override;
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/filter/constant_filter.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+class ConstantFilter : public TableFilter {
+public:
+	ConstantFilter(ExpressionType comparison_type, Value constant);
+
+	//! The comparison type (e.g. COMPARE_EQUAL, COMPARE_GREATERTHAN, COMPARE_LESSTHAN, ...)
+	ExpressionType comparison_type;
+	//! The constant value to filter on
+	Value constant;
+
+public:
+	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
+	string ToString(const string &column_name) override;
+	bool Equals(const TableFilter &other) const override;
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/persistent/buffered_csv_reader.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/scalar/strftime.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+enum class StrTimeSpecifier : uint8_t {
+	ABBREVIATED_WEEKDAY_NAME = 0,    // %a - Abbreviated weekday name. (Sun, Mon, ...)
+	FULL_WEEKDAY_NAME = 1,           // %A Full weekday name. (Sunday, Monday, ...)
+	WEEKDAY_DECIMAL = 2,             // %w - Weekday as a decimal number. (0, 1, ..., 6)
+	DAY_OF_MONTH_PADDED = 3,         // %d - Day of the month as a zero-padded decimal. (01, 02, ..., 31)
+	DAY_OF_MONTH = 4,                // %-d - Day of the month as a decimal number. (1, 2, ..., 30)
+	ABBREVIATED_MONTH_NAME = 5,      // %b - Abbreviated month name. (Jan, Feb, ..., Dec)
+	FULL_MONTH_NAME = 6,             // %B - Full month name. (January, February, ...)
+	MONTH_DECIMAL_PADDED = 7,        // %m - Month as a zero-padded decimal number. (01, 02, ..., 12)
+	MONTH_DECIMAL = 8,               // %-m - Month as a decimal number. (1, 2, ..., 12)
+	YEAR_WITHOUT_CENTURY_PADDED = 9, // %y - Year without century as a zero-padded decimal number. (00, 01, ..., 99)
+	YEAR_WITHOUT_CENTURY = 10,       // %-y - Year without century as a decimal number. (0, 1, ..., 99)
+	YEAR_DECIMAL = 11,               // %Y - Year with century as a decimal number. (2013, 2019 etc.)
+	HOUR_24_PADDED = 12,             // %H - Hour (24-hour clock) as a zero-padded decimal number. (00, 01, ..., 23)
+	HOUR_24_DECIMAL = 13,            // %-H - Hour (24-hour clock) as a decimal number. (0, 1, ..., 23)
+	HOUR_12_PADDED = 14,             // %I - Hour (12-hour clock) as a zero-padded decimal number. (01, 02, ..., 12)
+	HOUR_12_DECIMAL = 15,            // %-I - Hour (12-hour clock) as a decimal number. (1, 2, ... 12)
+	AM_PM = 16,                      // %p - Locale’s AM or PM. (AM, PM)
+	MINUTE_PADDED = 17,              // %M - Minute as a zero-padded decimal number. (00, 01, ..., 59)
+	MINUTE_DECIMAL = 18,             // %-M - Minute as a decimal number. (0, 1, ..., 59)
+	SECOND_PADDED = 19,              // %S - Second as a zero-padded decimal number. (00, 01, ..., 59)
+	SECOND_DECIMAL = 20,             // %-S - Second as a decimal number. (0, 1, ..., 59)
+	MICROSECOND_PADDED = 21,         // %f - Microsecond as a decimal number, zero-padded on the left. (000000 - 999999)
+	MILLISECOND_PADDED = 22,         // %g - Millisecond as a decimal number, zero-padded on the left. (000 - 999)
+	UTC_OFFSET = 23,                 // %z - UTC offset in the form +HHMM or -HHMM. ( )
+	TZ_NAME = 24,                    // %Z - Time zone name. ( )
+	DAY_OF_YEAR_PADDED = 25,         // %j - Day of the year as a zero-padded decimal number. (001, 002, ..., 366)
+	DAY_OF_YEAR_DECIMAL = 26,        // %-j - Day of the year as a decimal number. (1, 2, ..., 366)
+	WEEK_NUMBER_PADDED_SUN_FIRST =
+	    27, // %U - Week number of the year (Sunday as the first day of the week). All days in a new year preceding the
+	        // first Sunday are considered to be in week 0. (00, 01, ..., 53)
+	WEEK_NUMBER_PADDED_MON_FIRST =
+	    28, // %W - Week number of the year (Monday as the first day of the week). All days in a new year preceding the
+	        // first Monday are considered to be in week 0. (00, 01, ..., 53)
+	LOCALE_APPROPRIATE_DATE_AND_TIME =
+	    29, // %c - Locale’s appropriate date and time representation. (Mon Sep 30 07:06:05 2013)
+	LOCALE_APPROPRIATE_DATE = 30, // %x - Locale’s appropriate date representation. (09/30/13)
+	LOCALE_APPROPRIATE_TIME = 31  // %X - Locale’s appropriate time representation. (07:06:05)
+};
+
+struct StrTimeFormat {
+public:
+	virtual ~StrTimeFormat() {
+	}
+
+	static string ParseFormatSpecifier(const string &format_string, StrTimeFormat &format);
+
+protected:
+	//! The format specifiers
+	vector<StrTimeSpecifier> specifiers;
+	//! The literals that appear in between the format specifiers
+	//! The following must hold: literals.size() = specifiers.size() + 1
+	//! Format is literals[0], specifiers[0], literals[1], ..., specifiers[n - 1], literals[n]
+	vector<string> literals;
+	//! The constant size that appears in the format string
+	idx_t constant_size;
+	//! The max numeric width of the specifier (if it is parsed as a number), or -1 if it is not a number
+	vector<int> numeric_width;
+
+protected:
+	void AddLiteral(string literal);
+	virtual void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier);
+};
+
+struct StrfTimeFormat : public StrTimeFormat {
+	idx_t GetLength(date_t date, dtime_t time);
+
+	void FormatString(date_t date, int32_t data[7], char *target);
+	void FormatString(date_t date, dtime_t time, char *target);
+
+	static string Format(timestamp_t timestamp, const string &format);
+
+protected:
+	//! The variable-length specifiers. To determine total string size, these need to be checked.
+	vector<StrTimeSpecifier> var_length_specifiers;
+	//! Whether or not the current specifier is a special "date" specifier (i.e. one that requires a date_t object to
+	//! generate)
+	vector<bool> is_date_specifier;
+
+protected:
+	void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) override;
+	static idx_t GetSpecifierLength(StrTimeSpecifier specifier, date_t date, dtime_t time);
+	char *WriteString(char *target, const string_t &str);
+	char *Write2(char *target, uint8_t value);
+	char *WritePadded2(char *target, int32_t value);
+	char *WritePadded3(char *target, uint32_t value);
+	char *WritePadded(char *target, int32_t value, int32_t padding);
+	bool IsDateSpecifier(StrTimeSpecifier specifier);
+	char *WriteDateSpecifier(StrTimeSpecifier specifier, date_t date, char *target);
+	char *WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], char *target);
+};
+
+struct StrpTimeFormat : public StrTimeFormat {
+public:
+	//! Type-safe parsing argument
+	struct ParseResult {
+		int32_t data[7];
+		string error_message;
+		idx_t error_position = DConstants::INVALID_INDEX;
+
+		date_t ToDate();
+		timestamp_t ToTimestamp();
+		string FormatError(string_t input, const string &format_specifier);
+	};
+	//! The full format specifier, for error messages
+	string format_specifier;
+
+	bool Parse(string_t str, ParseResult &result);
+
+	bool TryParseDate(string_t str, date_t &result, string &error_message);
+	bool TryParseTimestamp(string_t str, timestamp_t &result, string &error_message);
+
+	date_t ParseDate(string_t str);
+	timestamp_t ParseTimestamp(string_t str);
+
+protected:
+	static string FormatStrpTimeError(const string &input, idx_t position);
+	void AddFormatSpecifier(string preceding_literal, StrTimeSpecifier specifier) override;
+	int NumericSpecifierWidth(StrTimeSpecifier specifier);
+	int32_t TryParseCollection(const char *data, idx_t &pos, idx_t size, const string_t collection[],
+	                           idx_t collection_count);
+};
+
+} // namespace duckdb
+
+
+
+
+
+#include <sstream>
+#include <queue>
+
+namespace duckdb {
+struct CopyInfo;
+struct FileHandle;
+struct StrpTimeFormat;
+
+class FileOpener;
+class FileSystem;
+
+//! The shifts array allows for linear searching of multi-byte values. For each position, it determines the next
+//! position given that we encounter a byte with the given value.
+/*! For example, if we have a string "ABAC", the shifts array will have the following values:
+ *  [0] --> ['A'] = 1, all others = 0
+ *  [1] --> ['B'] = 2, ['A'] = 1, all others = 0
+ *  [2] --> ['A'] = 3, all others = 0
+ *  [3] --> ['C'] = 4 (match), 'B' = 2, 'A' = 1, all others = 0
+ * Suppose we then search in the following string "ABABAC", our progression will be as follows:
+ * 'A' -> [1], 'B' -> [2], 'A' -> [3], 'B' -> [2], 'A' -> [3], 'C' -> [4] (match!)
+ */
+struct TextSearchShiftArray {
+	TextSearchShiftArray();
+	explicit TextSearchShiftArray(string search_term);
+
+	inline bool Match(uint8_t &position, uint8_t byte_value) {
+		if (position >= length) {
+			return false;
+		}
+		position = shifts[position * 255 + byte_value];
+		return position == length;
+	}
+
+	idx_t length;
+	unique_ptr<uint8_t[]> shifts;
+};
+
+struct BufferedCSVReaderOptions {
+	//! The file path of the CSV file to read
+	string file_path;
+	//! Whether file is compressed or not, and if so which compression type
+	//! AUTO_DETECT (default; infer from file extension)
+	FileCompressionType compression = FileCompressionType::AUTO_DETECT;
+	//! Whether or not to automatically detect dialect and datatypes
+	bool auto_detect = false;
+	//! Whether or not a delimiter was defined by the user
+	bool has_delimiter = false;
+	//! Delimiter to separate columns within each line
+	string delimiter = ",";
+	//! Whether or not a quote sign was defined by the user
+	bool has_quote = false;
+	//! Quote used for columns that contain reserved characters, e.g., delimiter
+	string quote = "\"";
+	//! Whether or not an escape character was defined by the user
+	bool has_escape = false;
+	//! Escape character to escape quote character
+	string escape;
+	//! Whether or not a header information was given by the user
+	bool has_header = false;
+	//! Whether or not the file has a header line
+	bool header = false;
+	//! Whether or not header names shall be normalized
+	bool normalize_names = false;
+	//! How many leading rows to skip
+	idx_t skip_rows = 0;
+	//! Expected number of columns
+	idx_t num_cols = 0;
+	//! Specifies the string that represents a null value
+	string null_str;
+	//! True, if column with that index must skip null check
+	vector<bool> force_not_null;
+	//! Size of sample chunk used for dialect and type detection
+	idx_t sample_chunk_size = STANDARD_VECTOR_SIZE;
+	//! Number of sample chunks used for type detection
+	idx_t sample_chunks = 10;
+	//! Number of samples to buffer
+	idx_t buffer_size = STANDARD_VECTOR_SIZE * 100;
+	//! Consider all columns to be of type varchar
+	bool all_varchar = false;
+	//! The date format to use (if any is specified)
+	std::map<LogicalTypeId, StrpTimeFormat> date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
+	//! Whether or not a type format is specified
+	std::map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
+
+	void SetDelimiter(const string &delimiter);
+
+	std::string ToString() const;
+};
+
+enum class ParserMode : uint8_t { PARSING = 0, SNIFFING_DIALECT = 1, SNIFFING_DATATYPES = 2, PARSING_HEADER = 3 };
+
+//! Buffered CSV reader is a class that reads values from a stream and parses them as a CSV file
+class BufferedCSVReader {
+	//! Initial buffer read size; can be extended for long lines
+	static constexpr idx_t INITIAL_BUFFER_SIZE = 16384;
+	//! Maximum CSV line size: specified because if we reach this amount, we likely have the wrong delimiters
+	static constexpr idx_t MAXIMUM_CSV_LINE_SIZE = 1048576;
+	ParserMode mode;
+
+public:
+	BufferedCSVReader(ClientContext &context, BufferedCSVReaderOptions options,
+	                  const vector<LogicalType> &requested_types = vector<LogicalType>());
+
+	BufferedCSVReader(FileSystem &fs, FileOpener *opener, BufferedCSVReaderOptions options,
+	                  const vector<LogicalType> &requested_types = vector<LogicalType>());
+
+	FileSystem &fs;
+	FileOpener *opener;
+	BufferedCSVReaderOptions options;
+	vector<LogicalType> sql_types;
+	vector<string> col_names;
+	unique_ptr<FileHandle> file_handle;
+	bool plain_file_source = false;
+	idx_t file_size = 0;
+
+	unique_ptr<char[]> buffer;
+	idx_t buffer_size;
+	idx_t position;
+	idx_t start = 0;
+
+	idx_t linenr = 0;
+	bool linenr_estimated = false;
+
+	vector<idx_t> sniffed_column_counts;
+	bool row_empty = false;
+	idx_t sample_chunk_idx = 0;
+	bool jumping_samples = false;
+	bool end_of_file_reached = false;
+	bool bom_checked = false;
+
+	idx_t bytes_in_chunk = 0;
+	double bytes_per_line_avg = 0;
+
+	vector<unique_ptr<char[]>> cached_buffers;
+
+	TextSearchShiftArray delimiter_search, escape_search, quote_search;
+
+	DataChunk parse_chunk;
+
+	std::queue<unique_ptr<DataChunk>> cached_chunks;
+
+public:
+	//! Extract a single DataChunk from the CSV file and stores it in insert_chunk
+	void ParseCSV(DataChunk &insert_chunk);
+
+private:
+	//! Initialize Parser
+	void Initialize(const vector<LogicalType> &requested_types);
+	//! Initializes the parse_chunk with varchar columns and aligns info with new number of cols
+	void InitParseChunk(idx_t num_cols);
+	//! Initializes the TextSearchShiftArrays for complex parser
+	void PrepareComplexParser();
+	//! Try to parse a single datachunk from the file. Throws an exception if anything goes wrong.
+	void ParseCSV(ParserMode mode);
+	//! Try to parse a single datachunk from the file. Returns whether or not the parsing is successful
+	bool TryParseCSV(ParserMode mode);
+	//! Extract a single DataChunk from the CSV file and stores it in insert_chunk
+	bool TryParseCSV(ParserMode mode, DataChunk &insert_chunk, string &error_message);
+	//! Sniffs CSV dialect and determines skip rows, header row, column types and column names
+	vector<LogicalType> SniffCSV(const vector<LogicalType> &requested_types);
+	//! Change the date format for the type to the string
+	void SetDateFormat(const string &format_specifier, const LogicalTypeId &sql_type);
+	//! Try to cast a string value to the specified sql type
+	bool TryCastValue(const Value &value, const LogicalType &sql_type);
+	//! Try to cast a vector of values to the specified sql type
+	bool TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type);
+	//! Skips skip_rows, reads header row from input stream
+	void SkipRowsAndReadHeader(idx_t skip_rows, bool skip_header);
+	//! Jumps back to the beginning of input stream and resets necessary internal states
+	void JumpToBeginning(idx_t skip_rows, bool skip_header);
+	//! Jumps back to the beginning of input stream and resets necessary internal states
+	bool JumpToNextSample();
+	//! Resets the buffer
+	void ResetBuffer();
+	//! Resets the steam
+	void ResetStream();
+
+	//! Parses a CSV file with a one-byte delimiter, escape and quote character
+	bool TryParseSimpleCSV(DataChunk &insert_chunk, string &error_message);
+	//! Parses more complex CSV files with multi-byte delimiters, escapes or quotes
+	bool TryParseComplexCSV(DataChunk &insert_chunk, string &error_message);
+
+	//! Adds a value to the current row
+	void AddValue(char *str_val, idx_t length, idx_t &column, vector<idx_t> &escape_positions);
+	//! Adds a row to the insert_chunk, returns true if the chunk is filled as a result of this row being added
+	bool AddRow(DataChunk &insert_chunk, idx_t &column);
+	//! Finalizes a chunk, parsing all values that have been added so far and adding them to the insert_chunk
+	void Flush(DataChunk &insert_chunk);
+	//! Reads a new buffer from the CSV file if the current one has been exhausted
+	bool ReadBuffer(idx_t &start);
+
+	unique_ptr<FileHandle> OpenCSV(const BufferedCSVReaderOptions &options);
+
+	//! First phase of auto detection: detect CSV dialect (i.e. delimiter, quote rules, etc)
+	void DetectDialect(const vector<LogicalType> &requested_types, BufferedCSVReaderOptions &original_options,
+	                   vector<BufferedCSVReaderOptions> &info_candidates, idx_t &best_num_cols);
+	//! Second phase of auto detection: detect candidate types for each column
+	void DetectCandidateTypes(const vector<LogicalType> &type_candidates,
+	                          const map<LogicalTypeId, vector<const char *>> &format_template_candidates,
+	                          const vector<BufferedCSVReaderOptions> &info_candidates,
+	                          BufferedCSVReaderOptions &original_options, idx_t best_num_cols,
+	                          vector<vector<LogicalType>> &best_sql_types_candidates,
+	                          std::map<LogicalTypeId, vector<string>> &best_format_candidates,
+	                          DataChunk &best_header_row);
+	//! Third phase of auto detection: detect header of CSV file
+	void DetectHeader(const vector<vector<LogicalType>> &best_sql_types_candidates, const DataChunk &best_header_row);
+	//! Fourth phase of auto detection: refine the types of each column and select which types to use for each column
+	vector<LogicalType> RefineTypeDetection(const vector<LogicalType> &type_candidates,
+	                                        const vector<LogicalType> &requested_types,
+	                                        vector<vector<LogicalType>> &best_sql_types_candidates,
+	                                        map<LogicalTypeId, vector<string>> &best_format_candidates);
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/vector_cache.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+class Vector;
+
+//! The VectorCache holds cached data that allows for re-use of the same memory by vectors
+class VectorCache {
+public:
+	//! Instantiate a vector cache with the given type
+	explicit VectorCache(const LogicalType &type);
+
+	buffer_ptr<VectorBuffer> buffer;
+
+public:
+	void ResetFromCache(Vector &result) const;
+
+	const LogicalType &GetType() const;
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/filter/null_filter.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+class IsNullFilter : public TableFilter {
+public:
+	IsNullFilter();
+
+public:
+	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
+	string ToString(const string &column_name) override;
+};
+
+class IsNotNullFilter : public TableFilter {
+public:
+	IsNotNullFilter();
+
+public:
+	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
+	string ToString(const string &column_name) override;
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/arrow_wrapper.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//! Here we have the internal duckdb classes that interact with Arrow's Internal Header (i.e., duckdb/commons/arrow.hpp)
+namespace duckdb {
+class ArrowSchemaWrapper {
+public:
+	ArrowSchema arrow_schema;
+
+	ArrowSchemaWrapper() {
+		arrow_schema.release = nullptr;
+	}
+
+	~ArrowSchemaWrapper();
+};
+class ArrowArrayWrapper {
+public:
+	ArrowArray arrow_array;
+	ArrowArrayWrapper() {
+		arrow_array.length = 0;
+		arrow_array.release = nullptr;
+	}
+	~ArrowArrayWrapper();
+};
+
+class ArrowArrayStreamWrapper {
+public:
+	ArrowArrayStream arrow_array_stream;
+	int64_t number_of_rows;
+	void GetSchema(ArrowSchemaWrapper &schema);
+
+	unique_ptr<ArrowArrayWrapper> GetNextChunk();
+
+	const char *GetError();
+
+	~ArrowArrayStreamWrapper();
+	ArrowArrayStreamWrapper() {
+		arrow_array_stream.release = nullptr;
+	}
+};
+
+class ResultArrowArrayStreamWrapper {
+public:
+	explicit ResultArrowArrayStreamWrapper(unique_ptr<QueryResult> result, idx_t approx_batch_size);
+	ArrowArrayStream stream;
+	unique_ptr<QueryResult> result;
+	std::string last_error;
+	idx_t vectors_per_chunk;
+
+private:
+	static int MyStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out);
+	static int MyStreamGetNext(struct ArrowArrayStream *stream, struct ArrowArray *out);
+	static void MyStreamRelease(struct ArrowArrayStream *stream);
+	static const char *MyStreamGetLastError(struct ArrowArrayStream *stream);
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/compressed_file_system.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+class CompressedFile;
+
+struct StreamData {
+	// various buffers & pointers
+	bool write = false;
+	unique_ptr<data_t[]> in_buff;
+	unique_ptr<data_t[]> out_buff;
+	data_ptr_t out_buff_start = nullptr;
+	data_ptr_t out_buff_end = nullptr;
+	data_ptr_t in_buff_start = nullptr;
+	data_ptr_t in_buff_end = nullptr;
+
+	idx_t in_buf_size = 0;
+	idx_t out_buf_size = 0;
+};
+
+struct StreamWrapper {
+	DUCKDB_API virtual ~StreamWrapper();
+
+	DUCKDB_API virtual void Initialize(CompressedFile &file, bool write) = 0;
+	DUCKDB_API virtual bool Read(StreamData &stream_data) = 0;
+	DUCKDB_API virtual void Write(CompressedFile &file, StreamData &stream_data, data_ptr_t buffer,
+	                              int64_t nr_bytes) = 0;
+	DUCKDB_API virtual void Close() = 0;
+};
+
+class CompressedFileSystem : public FileSystem {
+public:
+	DUCKDB_API int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
+	DUCKDB_API int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
+
+	DUCKDB_API void Reset(FileHandle &handle) override;
+
+	DUCKDB_API int64_t GetFileSize(FileHandle &handle) override;
+
+	DUCKDB_API bool OnDiskFile(FileHandle &handle) override;
+	DUCKDB_API bool CanSeek() override;
+
+	DUCKDB_API virtual unique_ptr<StreamWrapper> CreateStream() = 0;
+	DUCKDB_API virtual idx_t InBufferSize() = 0;
+	DUCKDB_API virtual idx_t OutBufferSize() = 0;
+};
+
+class CompressedFile : public FileHandle {
+public:
+	DUCKDB_API CompressedFile(CompressedFileSystem &fs, unique_ptr<FileHandle> child_handle_p, const string &path);
+	DUCKDB_API virtual ~CompressedFile() override;
+
+	CompressedFileSystem &compressed_fs;
+	unique_ptr<FileHandle> child_handle;
+	//! Whether the file is opened for reading or for writing
+	bool write = false;
+	StreamData stream_data;
+
+public:
+	DUCKDB_API void Initialize(bool write);
+	DUCKDB_API int64_t ReadData(void *buffer, int64_t nr_bytes);
+	DUCKDB_API int64_t WriteData(data_ptr_t buffer, int64_t nr_bytes);
+	DUCKDB_API void Close() override;
+
+private:
+	unique_ptr<StreamWrapper> stream_wrapper;
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/between_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+class BetweenExpression : public ParsedExpression {
+public:
+	BetweenExpression(unique_ptr<ParsedExpression> input, unique_ptr<ParsedExpression> lower,
+	                  unique_ptr<ParsedExpression> upper);
+
+	unique_ptr<ParsedExpression> input;
+	unique_ptr<ParsedExpression> lower;
+	unique_ptr<ParsedExpression> upper;
+
+public:
+	string ToString() const override;
+
+	static bool Equals(const BetweenExpression *a, const BetweenExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/positional_reference_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+class PositionalReferenceExpression : public ParsedExpression {
+public:
+	PositionalReferenceExpression(idx_t index);
+
+	idx_t index;
+
+public:
+	bool IsScalar() const override {
+		return false;
+	}
+
+	string ToString() const override;
+
+	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
+	unique_ptr<ParsedExpression> Copy() const override;
+	hash_t Hash() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/subquery_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+//! Represents a subquery
+class SubqueryExpression : public ParsedExpression {
+public:
+	SubqueryExpression();
+
+	//! The actual subquery
+	unique_ptr<SelectStatement> subquery;
+	//! The subquery type
+	SubqueryType subquery_type;
+	//! the child expression to compare with (in case of IN, ANY, ALL operators, empty for EXISTS queries and scalar
+	//! subquery)
+	unique_ptr<ParsedExpression> child;
+	//! The comparison type of the child expression with the subquery (in case of ANY, ALL operators), empty otherwise
+	ExpressionType comparison_type;
+
+public:
+	bool HasSubquery() const override {
+		return true;
+	}
+	bool IsScalar() const override {
+		return false;
+	}
+
+	string ToString() const override;
+
+	static bool Equals(const SubqueryExpression *a, const SubqueryExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/parameter_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+class ParameterExpression : public ParsedExpression {
+public:
+	ParameterExpression();
+
+	idx_t parameter_nr;
+
+public:
+	bool IsScalar() const override {
+		return true;
+	}
+	bool HasParameter() const override {
+		return true;
+	}
+
+	string ToString() const override;
+
+	unique_ptr<ParsedExpression> Copy() const override;
+	hash_t Hash() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/constant_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+//! ConstantExpression represents a constant value in the query
+class ConstantExpression : public ParsedExpression {
+public:
+	explicit ConstantExpression(Value val);
+
+	//! The constant value referenced
+	Value value;
+
+public:
+	string ToString() const override;
+
+	static bool Equals(const ConstantExpression *a, const ConstantExpression *b);
+	hash_t Hash() const override;
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/default_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+//! Represents the default value of a column
+class DefaultExpression : public ParsedExpression {
+public:
+	DefaultExpression();
+
+public:
+	bool IsScalar() const override {
+		return false;
+	}
+
+	string ToString() const override;
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/case_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct CaseCheck {
+	unique_ptr<ParsedExpression> when_expr;
+	unique_ptr<ParsedExpression> then_expr;
+};
+
+//! The CaseExpression represents a CASE expression in the query
+class CaseExpression : public ParsedExpression {
+public:
+	CaseExpression();
+
+	vector<CaseCheck> case_checks;
+	unique_ptr<ParsedExpression> else_expr;
+
+public:
+	string ToString() const override;
+
+	static bool Equals(const CaseExpression *a, const CaseExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/function_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+//! Represents a function call
+class FunctionExpression : public ParsedExpression {
+public:
+	FunctionExpression(string schema_name, const string &function_name, vector<unique_ptr<ParsedExpression>> children,
+	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
+	                   bool distinct = false, bool is_operator = false);
+	FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children,
+	                   unique_ptr<ParsedExpression> filter = nullptr, unique_ptr<OrderModifier> order_bys = nullptr,
+	                   bool distinct = false, bool is_operator = false);
+
+	//! Schema of the function
+	string schema;
+	//! Function name
+	string function_name;
+	//! Whether or not the function is an operator, only used for rendering
+	bool is_operator;
+	//! List of arguments to the function
+	vector<unique_ptr<ParsedExpression>> children;
+	//! Whether or not the aggregate function is distinct, only used for aggregates
+	bool distinct;
+	//! Expression representing a filter, only used for aggregates
+	unique_ptr<ParsedExpression> filter;
+	//! Modifier representing an ORDER BY, only used for aggregates
+	unique_ptr<OrderModifier> order_bys;
+
+public:
+	string ToString() const override;
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
+	hash_t Hash() const override;
+
+	//! Serializes a FunctionExpression to a stand-alone binary blob
+	void Serialize(Serializer &serializer) override;
+	//! Deserializes a blob back into an FunctionExpression
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/lambda_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+//! LambdaExpression represents a lambda operator that can be used for e.g. mapping an expression to a list
+//! Lambda expressions are written in the form of "capture -> expr", e.g. "x -> x + 1"
+class LambdaExpression : public ParsedExpression {
+public:
+	LambdaExpression(vector<string> parameters, unique_ptr<ParsedExpression> expression);
+
+	vector<string> parameters;
+	unique_ptr<ParsedExpression> expression;
+
+public:
+	string ToString() const override;
+
+	static bool Equals(const LambdaExpression *a, const LambdaExpression *b);
+	hash_t Hash() const override;
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/comparison_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+//! ComparisonExpression represents a boolean comparison (e.g. =, >=, <>). Always returns a boolean
+//! and has two children.
+class ComparisonExpression : public ParsedExpression {
+public:
+	ComparisonExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
+
+	unique_ptr<ParsedExpression> left;
+	unique_ptr<ParsedExpression> right;
+
+public:
+	string ToString() const override;
+
+	static bool Equals(const ComparisonExpression *a, const ComparisonExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/cast_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+//! CastExpression represents a type cast from one SQL type to another SQL type
+class CastExpression : public ParsedExpression {
+public:
+	CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
+
+	//! The child of the cast expression
+	unique_ptr<ParsedExpression> child;
+	//! The type to cast to
+	LogicalType cast_type;
+	//! Whether or not this is a try_cast expression
+	bool try_cast;
+
+public:
+	string ToString() const override;
+
+	static bool Equals(const CastExpression *a, const CastExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/collate_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+//! CollateExpression represents a COLLATE statement
+class CollateExpression : public ParsedExpression {
+public:
+	CollateExpression(string collation, unique_ptr<ParsedExpression> child);
+
+	//! The child of the cast expression
+	unique_ptr<ParsedExpression> child;
+	//! The collation clause
+	string collation;
+
+public:
+	string ToString() const override;
+
+	static bool Equals(const CollateExpression *a, const CollateExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/conjunction_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+//! Represents a conjunction (AND/OR)
+class ConjunctionExpression : public ParsedExpression {
+public:
+	explicit ConjunctionExpression(ExpressionType type);
+	ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+	ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left, unique_ptr<ParsedExpression> right);
+
+	vector<unique_ptr<ParsedExpression>> children;
+
+public:
+	void AddExpression(unique_ptr<ParsedExpression> expr);
+
+	string ToString() const override;
+
+	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/operator_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+//! Represents a built-in operator expression
+class OperatorExpression : public ParsedExpression {
+public:
+	explicit OperatorExpression(ExpressionType type, unique_ptr<ParsedExpression> left = nullptr,
+	                            unique_ptr<ParsedExpression> right = nullptr);
+	OperatorExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+
+	vector<unique_ptr<ParsedExpression>> children;
+
+public:
+	string ToString() const override;
+
+	static bool Equals(const OperatorExpression *a, const OperatorExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/star_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+//! Represents a * expression in the SELECT clause
+class StarExpression : public ParsedExpression {
+public:
+	StarExpression(string relation_name = string());
+
+	//! The relation name in case of tbl.*, or empty if this is a normal *
+	string relation_name;
+	//! List of columns to exclude from the STAR expression
+	case_insensitive_set_t exclude_list;
+	//! List of columns to replace with another expression
+	case_insensitive_map_t<unique_ptr<ParsedExpression>> replace_list;
+
+public:
+	string ToString() const override;
+
+	static bool Equals(const StarExpression *a, const StarExpression *b);
+
+	unique_ptr<ParsedExpression> Copy() const override;
+
+	void Serialize(Serializer &serializer) override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, Deserializer &source);
+};
+} // namespace duckdb
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_index_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/basetableref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+//! Represents a TableReference to a base table in the schema
+class BaseTableRef : public TableRef {
+public:
+	BaseTableRef() : TableRef(TableReferenceType::BASE_TABLE), schema_name(INVALID_SCHEMA) {
+	}
+
+	//! Schema name
+	string schema_name;
+	//! Table name
+	string table_name;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
+
+public:
+	string ToString() const override;
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a BaseTableRef
+	void Serialize(Serializer &serializer) override;
+	//! Deserializes a blob back into a BaseTableRef
+	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+};
+} // namespace duckdb
+
+
+
+namespace duckdb {
+
+struct CreateIndexInfo : public CreateInfo {
+	CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY) {
+	}
+
+	//! Index Type (e.g., B+-tree, Skip-List, ...)
+	IndexType index_type;
+	//! Name of the Index
+	string index_name;
+	//! If it is an unique index
+	bool unique = false;
+	//! The table to create the index on
+	unique_ptr<BaseTableRef> table;
+	//! Set of expressions to index by
+	vector<unique_ptr<ParsedExpression>> expressions;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateIndexInfo>();
+		CopyProperties(*result);
+		result->index_type = index_type;
+		result->index_name = index_name;
+		result->unique = unique;
+		result->table = unique_ptr_cast<TableRef, BaseTableRef>(table->Copy());
+		for (auto &expr : expressions) {
+			result->expressions.push_back(expr->Copy());
+		}
+		return move(result);
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_view_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct CreateViewInfo : public CreateInfo {
+	CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
+	}
+	CreateViewInfo(string schema, string view_name)
+	    : CreateInfo(CatalogType::VIEW_ENTRY, schema), view_name(view_name) {
+	}
+
+	//! Table name to insert to
+	string view_name;
+	//! Aliases of the view
+	vector<string> aliases;
+	//! Return types
+	vector<LogicalType> types;
+	//! The SelectStatement of the view
+	unique_ptr<SelectStatement> query;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateViewInfo>(schema, view_name);
+		CopyProperties(*result);
+		result->aliases = aliases;
+		result->types = types;
+		result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
+		return move(result);
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_pragma_function_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct CreatePragmaFunctionInfo : public CreateFunctionInfo {
+	explicit CreatePragmaFunctionInfo(PragmaFunction function)
+	    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY) {
+		functions.push_back(move(function));
+		this->name = function.name;
+	}
+	CreatePragmaFunctionInfo(string name, vector<PragmaFunction> functions_)
+	    : CreateFunctionInfo(CatalogType::PRAGMA_FUNCTION_ENTRY), functions(move(functions_)) {
+		this->name = name;
+		for (auto &function : functions) {
+			function.name = name;
+		}
+	}
+
+	vector<PragmaFunction> functions;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreatePragmaFunctionInfo>(functions[0].name, functions);
+		CopyProperties(*result);
+		return move(result);
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/drop_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct DropInfo : public ParseInfo {
+	DropInfo() : schema(INVALID_SCHEMA), if_exists(false), cascade(false) {
+	}
+
+	//! The catalog type to drop
+	CatalogType type;
+	//! Schema name to drop from, if any
+	string schema;
+	//! Element name to drop
+	string name;
+	//! Ignore if the entry does not exist instead of failing
+	bool if_exists = false;
+	//! Cascade drop (drop all dependents instead of throwing an error if there
+	//! are any)
+	bool cascade = false;
+
+public:
+	unique_ptr<DropInfo> Copy() const {
+		auto result = make_unique<DropInfo>();
+		result->type = type;
+		result->schema = schema;
+		result->name = name;
+		result->if_exists = if_exists;
+		result->cascade = cascade;
+		return result;
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/transaction_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
+
+struct TransactionInfo : public ParseInfo {
+	explicit TransactionInfo(TransactionType type) : type(type) {
+	}
+
+	//! The type of transaction statement
+	TransactionType type;
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_type_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+
+struct CreateTypeInfo : public CreateInfo {
+
+	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
+	}
+
+	//! Name of the Type
+	string name;
+	//! Shared Pointer of Logical Type
+	unique_ptr<LogicalType> type;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateTypeInfo>();
+		CopyProperties(*result);
+		result->name = name;
+		result->type = make_unique<LogicalType>(*type);
+		return move(result);
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/vacuum_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class LoadType { LOAD, INSTALL, FORCE_INSTALL };
+
+struct LoadInfo : public ParseInfo {
+	std::string filename;
+	LoadType load_type;
+
+public:
+	unique_ptr<LoadInfo> Copy() const {
+		auto result = make_unique<LoadInfo>();
+		result->filename = filename;
+		result->load_type = load_type;
+		return result;
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_collation_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct CreateCollationInfo : public CreateInfo {
+	CreateCollationInfo(string name_p, ScalarFunction function_p, bool combinable_p, bool not_required_for_equality_p)
+	    : CreateInfo(CatalogType::COLLATION_ENTRY), function(move(function_p)), combinable(combinable_p),
+	      not_required_for_equality(not_required_for_equality_p) {
+		this->name = move(name_p);
+	}
+
+	//! The name of the collation
+	string name;
+	//! The collation function to push in case collation is required
+	ScalarFunction function;
+	//! Whether or not the collation can be combined with other collations.
+	bool combinable;
+	//! Whether or not the collation is required for equality comparisons or not. For many collations a binary
+	//! comparison for equality comparisons is correct, allowing us to skip the collation in these cases which greatly
+	//! speeds up processing.
+	bool not_required_for_equality;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
+		CopyProperties(*result);
+		return move(result);
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_schema_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+struct CreateSchemaInfo : public CreateInfo {
+	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
+	}
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateSchemaInfo>();
+		CopyProperties(*result);
+		return move(result);
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/vacuum_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+struct VacuumInfo : public ParseInfo {
+	// nothing for now
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_macro_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/macro_function.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+
+class MacroCatalogEntry;
+
+class MacroFunction {
+public:
+	explicit MacroFunction(unique_ptr<ParsedExpression> expression);
+
+	//! Check whether the supplied arguments are valid
+	static string ValidateArguments(MacroCatalogEntry &macro_func, FunctionExpression &function_expr,
+	                                vector<unique_ptr<ParsedExpression>> &positionals,
+	                                unordered_map<string, unique_ptr<ParsedExpression>> &defaults);
+	//! The macro expression
+	unique_ptr<ParsedExpression> expression;
+	//! The positional parameters
+	vector<unique_ptr<ParsedExpression>> parameters;
+	//! The default parameters and their associated values
+	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
+
+public:
+	unique_ptr<MacroFunction> Copy();
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+struct CreateMacroInfo : public CreateFunctionInfo {
+	CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
+	}
+
+	unique_ptr<MacroFunction> function;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateMacroInfo>();
+		result->function = function->Copy();
+		result->name = name;
+		CopyProperties(*result);
+		return move(result);
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
+	explicit CreateAggregateFunctionInfo(AggregateFunction function)
+	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
+		this->name = function.name;
+		functions.AddFunction(move(function));
+	}
+
+	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set)
+	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
+		this->name = functions.name;
+		for (auto &func : functions.functions) {
+			func.name = functions.name;
+		}
+	}
+
+	AggregateFunctionSet functions;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
+		CopyProperties(*result);
+		return move(result);
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/export_table_data.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct ExportedTableData {
+	//! Name of the exported table
+	string table_name;
+
+	//! Name of the schema
+	string schema_name;
+
+	//! Path to be exported
+	string file_path;
+};
+
+struct BoundExportData : public ParseInfo {
+	unordered_map<TableCatalogEntry *, ExportedTableData> data;
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/show_select_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct ShowSelectInfo : public ParseInfo {
+	//! Types of projected columns
+	vector<LogicalType> types;
+	//! The QueryNode of select query
+	unique_ptr<QueryNode> query;
+	//! Aliases of projected columns
+	vector<string> aliases;
+	//! Whether or not we are requesting a summary or a describe
+	bool is_summary;
+
+	unique_ptr<ShowSelectInfo> Copy() {
+		auto result = make_unique<ShowSelectInfo>();
+		result->types = types;
+		result->query = query->Copy();
+		result->aliases = aliases;
+		result->is_summary = is_summary;
+		return result;
+	}
+};
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/subqueryref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+//! Represents a subquery
+class SubqueryRef : public TableRef {
+public:
+	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
+
+	//! The subquery
+	unique_ptr<SelectStatement> subquery;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
+
+public:
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a SubqueryRef
+	void Serialize(Serializer &serializer) override;
+	//! Deserializes a blob back into a SubqueryRef
+	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/table_function_ref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+//! Represents a Table producing function
+class TableFunctionRef : public TableRef {
+public:
+	TableFunctionRef() : TableRef(TableReferenceType::TABLE_FUNCTION) {
+	}
+
+	unique_ptr<ParsedExpression> function;
+	vector<string> column_name_alias;
+
+	// if the function takes a subquery as argument its in here
+	unique_ptr<SelectStatement> subquery;
+
+public:
+	string ToString() const override;
+
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a BaseTableRef
+	void Serialize(Serializer &serializer) override;
+	//! Deserializes a blob back into a BaseTableRef
+	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/crossproductref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+//! Represents a cross product
+class CrossProductRef : public TableRef {
+public:
+	CrossProductRef() : TableRef(TableReferenceType::CROSS_PRODUCT) {
+	}
+
+	//! The left hand side of the cross product
+	unique_ptr<TableRef> left;
+	//! The right hand side of the cross product
+	unique_ptr<TableRef> right;
+
+public:
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a CrossProductRef
+	void Serialize(Serializer &serializer) override;
+	//! Deserializes a blob back into a CrossProductRef
+	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+};
+} // namespace duckdb
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/emptytableref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+//! Represents a cross product
+class EmptyTableRef : public TableRef {
+public:
+	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
+	}
+
+public:
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a DummyTableRef
+	void Serialize(Serializer &serializer) override;
+	//! Deserializes a blob back into a DummyTableRef
+	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+};
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/expressionlistref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+//! Represents an expression list as generated by a VALUES statement
+class ExpressionListRef : public TableRef {
+public:
+	ExpressionListRef() : TableRef(TableReferenceType::EXPRESSION_LIST) {
+	}
+
+	//! Value list, only used for VALUES statement
+	vector<vector<unique_ptr<ParsedExpression>>> values;
+	//! Expected SQL types
+	vector<LogicalType> expected_types;
+	//! The set of expected names
+	vector<string> expected_names;
+
+public:
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a ExpressionListRef
+	void Serialize(Serializer &serializer) override;
+	//! Deserializes a blob back into a ExpressionListRef
+	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+};
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/joinref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+
+namespace duckdb {
+//! Represents a JOIN between two expressions
+class JoinRef : public TableRef {
+public:
+	JoinRef() : TableRef(TableReferenceType::JOIN), is_natural(false) {
+	}
+
+	//! The left hand side of the join
+	unique_ptr<TableRef> left;
+	//! The right hand side of the join
+	unique_ptr<TableRef> right;
+	//! The join condition
+	unique_ptr<ParsedExpression> condition;
+	//! The join type
+	JoinType type;
+	//! Natural join
+	bool is_natural;
+	//! The set of USING columns (if any)
+	vector<string> using_columns;
+
+public:
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a JoinRef
+	void Serialize(Serializer &serializer) override;
+	//! Deserializes a blob back into a JoinRef
+	static unique_ptr<TableRef> Deserialize(Deserializer &source);
+};
+} // namespace duckdb
+
+
+