duckdb 0.5.2-dev1040.0 → 0.5.2-dev1083.0

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "5733a227c"
-#define DUCKDB_VERSION "v0.5.2-dev1040"
+#define DUCKDB_SOURCE_ID "2c8cbc4c0"
+#define DUCKDB_VERSION "v0.5.2-dev1083"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1512,6 +1512,8 @@ public:
 
 	DUCKDB_API static bool UncaughtException();
 
+	DUCKDB_API static string GetStackTrace(int max_depth = 120);
+
 private:
 	string exception_message_;
 	string raw_message_;
@@ -3818,11 +3820,21 @@ private:
 
 
 
+
 namespace duckdb {
 class Serializer;
 class Deserializer;
 struct FileHandle;
 
+#define STANDARD_ROW_GROUPS_SIZE 122880
+#if STANDARD_ROW_GROUPS_SIZE < STANDARD_VECTOR_SIZE
+#error Row groups should be able to hold at least one vector
+#endif
+
+#if ((STANDARD_ROW_GROUPS_SIZE % STANDARD_VECTOR_SIZE) != 0)
+#error Row group size should be cleanly divisible by vector size
+#endif
+
 //! The version number of the database storage format
 extern const uint64_t VERSION_NUMBER;
 
@@ -20415,13 +20427,13 @@ namespace duckdb {
 
 class SegmentBase {
 public:
-	SegmentBase(idx_t start, idx_t count) : start(start), count(count) {
+	SegmentBase(idx_t start, idx_t count) : start(start), count(count), next(nullptr) {
 	}
 	virtual ~SegmentBase() {
-		// destroy the chain of segments iteratively (rather than recursively)
-		while (next && next->next) {
-			next = move(next->next);
-		}
+	}
+
+	SegmentBase *Next() {
+		return next.load();
 	}
 
 	//! The start row id of this chunk
@@ -20429,7 +20441,46 @@ public:
 	//! The amount of entries in this storage chunk
 	atomic<idx_t> count;
 	//! The next segment after this one
-	unique_ptr<SegmentBase> next;
+	atomic<SegmentBase *> next;
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/segment_lock.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct SegmentLock {
+public:
+	SegmentLock() {
+	}
+	SegmentLock(mutex &lock) : lock(lock) {
+	}
+	// disable copy constructors
+	SegmentLock(const SegmentLock &other) = delete;
+	SegmentLock &operator=(const SegmentLock &) = delete;
+	//! enable move constructors
+	SegmentLock(SegmentLock &&other) noexcept {
+		std::swap(lock, other.lock);
+	}
+	SegmentLock &operator=(SegmentLock &&other) noexcept {
+		std::swap(lock, other.lock);
+		return *this;
+	}
+
+private:
+	unique_lock<mutex> lock;
 };
 
 } // namespace duckdb
@@ -20441,39 +20492,62 @@ namespace duckdb {
 
 struct SegmentNode {
 	idx_t row_start;
-	SegmentBase *node;
+	unique_ptr<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;
+	//! Locks the segment tree. All methods to the segment tree either lock the segment tree, or take an already
+	//! obtained lock.
+	SegmentLock Lock();
+
+	bool IsEmpty(SegmentLock &);
 
-public:
 	//! Gets a pointer to the first segment. Useful for scans.
 	SegmentBase *GetRootSegment();
+	SegmentBase *GetRootSegment(SegmentLock &);
+	//! Obtains ownership of the data of the segment tree
+	vector<SegmentNode> MoveSegments(SegmentLock &);
 	//! Gets a pointer to the nth segment. Negative numbers start from the back.
 	SegmentBase *GetSegmentByIndex(int64_t index);
+	SegmentBase *GetSegmentByIndex(SegmentLock &, int64_t index);
+
 	//! Gets a pointer to the last segment. Useful for appends.
 	SegmentBase *GetLastSegment();
+	SegmentBase *GetLastSegment(SegmentLock &);
 	//! Gets a pointer to a specific column segment for the given row
 	SegmentBase *GetSegment(idx_t row_number);
+	SegmentBase *GetSegment(SegmentLock &, idx_t row_number);
+
 	//! Append a column segment to the tree
 	void AppendSegment(unique_ptr<SegmentBase> segment);
+	void AppendSegment(SegmentLock &, unique_ptr<SegmentBase> segment);
 	//! Debug method, check whether the segment is in the segment tree
 	bool HasSegment(SegmentBase *segment);
+	bool HasSegment(SegmentLock &, SegmentBase *segment);
 
 	//! Replace this tree with another tree, taking over its nodes in-place
 	void Replace(SegmentTree &other);
+	void Replace(SegmentLock &, SegmentTree &other);
+
+	//! Erase all segments after a specific segment
+	void EraseSegments(SegmentLock &, idx_t segment_start);
 
-	//! Get the segment index of the column segment for the given row (does not lock the segment tree!)
+	//! Get the segment index of the column segment for the given row
 	idx_t GetSegmentIndex(idx_t row_number);
+	idx_t GetSegmentIndex(SegmentLock &, idx_t row_number);
+	bool TryGetSegmentIndex(SegmentLock &, idx_t row_number, idx_t &);
+
+	void Verify(SegmentLock &);
+	void Verify();
+
+private:
+	//! The nodes in the tree, can be binary searched
+	vector<SegmentNode> nodes;
+	//! Lock to access or modify the nodes
+	mutex node_lock;
 };
 
 } // namespace duckdb
@@ -23107,6 +23181,7 @@ private:
 } // namespace duckdb
 
 
+
 namespace duckdb {
 class ColumnSegment;
 class LocalTableStorage;
@@ -23261,7 +23336,7 @@ class CreateIndexScanState : public TableScanState {
 public:
 	vector<unique_ptr<StorageLockKey>> locks;
 	unique_lock<mutex> append_lock;
-	unique_lock<mutex> delete_lock;
+	SegmentLock segment_lock;
 };
 
 } // namespace duckdb
@@ -23328,8 +23403,8 @@ public:
 	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;
+	static constexpr const idx_t ROW_GROUP_SIZE = STANDARD_ROW_GROUPS_SIZE;
+	static constexpr const idx_t ROW_GROUP_VECTOR_COUNT = ROW_GROUP_SIZE / STANDARD_VECTOR_SIZE;
 
 public:
 	RowGroup(DatabaseInstance &db, BlockManager &block_manager, DataTableInfo &table_info, idx_t start, idx_t count);
@@ -25060,7 +25135,7 @@ private:
 	//! The block-level lock
 	mutex lock;
 	//! Whether or not the block is loaded/unloaded
-	BlockState state;
+	atomic<BlockState> state;
 	//! Amount of concurrent readers
 	atomic<int32_t> readers;
 	//! The block id of the block
@@ -26048,6 +26123,7 @@ private:
 
 
 
+
 namespace duckdb {
 struct ParallelTableScanState;
 
@@ -26066,11 +26142,11 @@ public:
 	Allocator &GetAllocator() const;
 
 	void Initialize(PersistentTableData &data);
+	void InitializeEmpty();
 
 	bool IsEmpty() const;
 
-	RowGroup *GetSecondToLastRowGroup();
-	void AppendRowGroup(idx_t start_row);
+	void AppendRowGroup(SegmentLock &l, idx_t start_row);
 	//! Get the nth row-group, negative numbers start from the back (so -1 is the last row group, etc)
 	RowGroup *GetRowGroup(int64_t index);
 	void Verify();
@@ -26084,6 +26160,10 @@ public:
 	void InitializeParallelScan(ParallelCollectionScanState &state);
 	bool NextParallelScan(ClientContext &context, ParallelCollectionScanState &state, CollectionScanState &scan_state);
 
+	bool Scan(Transaction &transaction, const vector<column_t> &column_ids,
+	          const std::function<bool(DataChunk &chunk)> &fun);
+	bool Scan(Transaction &transaction, const std::function<bool(DataChunk &chunk)> &fun);
+
 	void Fetch(TransactionData transaction, DataChunk &result, const vector<column_t> &column_ids,
 	           Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state);
 
@@ -26092,7 +26172,7 @@ public:
 	//! Initialize an append with a known number of rows. FinalizeAppend should not be called after appending is done.
 	void InitializeAppend(TransactionData transaction, TableAppendState &state, idx_t append_count);
 	//! Appends to the row group collection. Returns true if a new row group has been created to append to
-	bool Append(DataChunk &chunk, TableAppendState &state, TableStatistics &stats);
+	bool Append(DataChunk &chunk, TableAppendState &state);
 	//! FinalizeAppend flushes an append with a variable number of rows.
 	void FinalizeAppend(TransactionData transaction, TableAppendState &state);
 	void CommitAppend(transaction_t commit_id, idx_t row_start, idx_t count);
@@ -26103,10 +26183,9 @@ public:
 	void RemoveFromIndexes(TableIndexList &indexes, Vector &row_identifiers, idx_t count);
 
 	idx_t Delete(TransactionData transaction, DataTable *table, row_t *ids, idx_t count);
-	void Update(TransactionData transaction, row_t *ids, const vector<column_t> &column_ids, DataChunk &updates,
-	            TableStatistics &stats);
+	void Update(TransactionData transaction, row_t *ids, const vector<column_t> &column_ids, DataChunk &updates);
 	void UpdateColumn(TransactionData transaction, Vector &row_ids, const vector<column_t> &column_path,
-	                  DataChunk &updates, TableStatistics &stats);
+	                  DataChunk &updates);
 
 	void Checkpoint(TableDataWriter &writer, vector<unique_ptr<BaseStatistics>> &global_stats);
 
@@ -26116,14 +26195,18 @@ public:
 	vector<vector<Value>> GetStorageInfo();
 	const vector<LogicalType> &GetTypes() const;
 
-	shared_ptr<RowGroupCollection> AddColumn(ColumnDefinition &new_column, Expression *default_value,
-	                                         ColumnStatistics &stats);
+	shared_ptr<RowGroupCollection> AddColumn(ColumnDefinition &new_column, Expression *default_value);
 	shared_ptr<RowGroupCollection> RemoveColumn(idx_t col_idx);
 	shared_ptr<RowGroupCollection> AlterType(idx_t changed_idx, const LogicalType &target_type,
-	                                         vector<column_t> bound_columns, Expression &cast_expr,
-	                                         ColumnStatistics &stats);
+	                                         vector<column_t> bound_columns, Expression &cast_expr);
 	void VerifyNewConstraint(DataTable &parent, const BoundConstraint &constraint);
 
+	unique_ptr<BaseStatistics> CopyStats(column_t column_id);
+	void SetStatistics(column_t column_id, const std::function<void(BaseStatistics &)> &set_fun);
+
+private:
+	bool IsEmpty(SegmentLock &) const;
+
 private:
 	//! BlockManager
 	BlockManager &block_manager;
@@ -26134,6 +26217,8 @@ private:
 	idx_t row_start;
 	//! The segment trees holding the various row_groups of the table
 	shared_ptr<SegmentTree> row_groups;
+	//! Table statistics
+	TableStatistics stats;
 };
 
 } // namespace duckdb
@@ -26159,6 +26244,31 @@ class DataTable;
 class WriteAheadLog;
 struct TableAppendState;
 
+class OptimisticDataWriter {
+public:
+	OptimisticDataWriter(DataTable *table);
+	OptimisticDataWriter(DataTable *table, OptimisticDataWriter &parent);
+	~OptimisticDataWriter();
+
+	void CheckFlushToDisk(RowGroupCollection &row_groups);
+	//! Flushes a specific row group to disk
+	void FlushToDisk(RowGroup *row_group);
+	//! Flushes the final row group to disk (if any)
+	void FlushToDisk(RowGroupCollection &row_groups);
+	//! Final flush: flush the partial block manager to disk
+	void FinalFlush();
+
+	void Rollback();
+
+private:
+	//! The table
+	DataTable *table;
+	//! The partial block manager (if we created one yet)
+	unique_ptr<PartialBlockManager> partial_manager;
+	//! The set of blocks that have been pre-emptively written to disk
+	unordered_set<block_id_t> written_blocks;
+};
+
 class LocalTableStorage : public std::enable_shared_from_this<LocalTableStorage> {
 public:
 	// Create a new LocalTableStorage
@@ -26180,40 +26290,45 @@ public:
 	shared_ptr<RowGroupCollection> row_groups;
 	//! The set of unique indexes
 	TableIndexList indexes;
-	//! Stats
-	TableStatistics stats;
 	//! The number of deleted rows
 	idx_t deleted_rows;
-	//! The partial block manager (if we created one yet)
-	unique_ptr<PartialBlockManager> partial_manager;
-	//! The set of blocks that have been pre-emptively written to disk
-	unordered_set<block_id_t> written_blocks;
+	//! The optimistic data writer
+	OptimisticDataWriter optimistic_writer;
 
 public:
 	void InitializeScan(CollectionScanState &state, TableFilterSet *table_filters = nullptr);
 	//! Check if we should flush the previously written row-group to disk
 	void CheckFlushToDisk();
-	//! Flushes a specific row group to disk
-	void FlushToDisk(RowGroup *row_group);
 	//! Flushes the final row group to disk (if any)
 	void FlushToDisk();
-	//! Whether or not the local table storag ehas optimistically written blocks
-	bool HasWrittenBlocks();
 	void Rollback();
 	idx_t EstimatedSize();
 
 	void AppendToIndexes(Transaction &transaction, TableAppendState &append_state, idx_t append_count,
 	                     bool append_to_table);
+};
+
+class LocalTableManager {
+public:
+	shared_ptr<LocalTableStorage> MoveEntry(DataTable *table);
+	unordered_map<DataTable *, shared_ptr<LocalTableStorage>> MoveEntries();
+	LocalTableStorage *GetStorage(DataTable *table);
+	LocalTableStorage *GetOrCreateStorage(DataTable *table);
+	idx_t EstimatedSize();
+	bool IsEmpty();
+	void InsertEntry(DataTable *table, shared_ptr<LocalTableStorage> entry);
 
 private:
-	template <class T>
-	bool ScanTableStorage(Transaction &transaction, T &&fun);
-	template <class T>
-	bool ScanTableStorage(Transaction &transaction, const vector<column_t> &column_ids, T &&fun);
+	mutex table_storage_lock;
+	unordered_map<DataTable *, shared_ptr<LocalTableStorage>> table_storage;
 };
 
 //! The LocalStorage class holds appends that have not been committed yet
 class LocalStorage {
+public:
+	// Threshold to merge row groups instead of appending
+	static constexpr const idx_t MERGE_THRESHOLD = RowGroup::ROW_GROUP_SIZE / 2;
+
 public:
 	struct CommitState {
 		unordered_map<DataTable *, unique_ptr<TableAppendState>> append_states;
@@ -26240,6 +26355,9 @@ public:
 	static void Append(LocalAppendState &state, DataChunk &chunk);
 	//! Finish appending to the local storage
 	static void FinalizeAppend(LocalAppendState &state);
+	//! Merge a row group collection into the transaction-local storage
+	void LocalMerge(DataTable *table, RowGroupCollection &collection);
+
 	//! Delete a set of rows from the local storage
 	idx_t Delete(DataTable *table, Vector &row_ids, idx_t count);
 	//! Update a set of rows in the local storage
@@ -26250,14 +26368,10 @@ public:
 	//! Rollback the local storage
 	void Rollback();
 
-	bool ChangesMade() noexcept {
-		return table_storage.size() > 0;
-	}
+	bool ChangesMade() noexcept;
 	idx_t EstimatedSize();
 
-	bool Find(DataTable *table) {
-		return table_storage.find(table) != table_storage.end();
-	}
+	bool Find(DataTable *table);
 
 	idx_t AddedRows(DataTable *table);
 
@@ -26272,12 +26386,9 @@ public:
 
 	void VerifyNewConstraint(DataTable &parent, const BoundConstraint &constraint);
 
-private:
-	LocalTableStorage *GetStorage(DataTable *table);
-
 private:
 	Transaction &transaction;
-	unordered_map<DataTable *, shared_ptr<LocalTableStorage>> table_storage;
+	LocalTableManager table_manager;
 
 	void Flush(DataTable &table, LocalTableStorage &storage);
 };
@@ -26400,6 +26511,8 @@ public:
 	void LocalAppend(TableCatalogEntry &table, ClientContext &context, DataChunk &chunk);
 	//! Append a column data collection to the transaction-local storage of this table
 	void LocalAppend(TableCatalogEntry &table, ClientContext &context, ColumnDataCollection &collection);
+	//! Merge a row group collection into the transaction-local storage
+	void LocalMerge(ClientContext &context, RowGroupCollection &collection);
 
 	//! Delete the entries with the specified row identifier from the table
 	idx_t Delete(TableCatalogEntry &table, ClientContext &context, Vector &row_ids, idx_t count);
@@ -26436,7 +26549,7 @@ public:
 	void ScanTableSegment(idx_t start_row, idx_t count, const std::function<void(DataChunk &chunk)> &function);
 
 	//! Merge a row group collection directly into this table - appending it to the end of the table without copying
-	void MergeStorage(RowGroupCollection &data, TableIndexList &indexes, TableStatistics &stats);
+	void MergeStorage(RowGroupCollection &data, TableIndexList &indexes);
 
 	//! 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
@@ -26494,8 +26607,6 @@ private:
 	mutex append_lock;
 	//! The row groups of the table
 	shared_ptr<RowGroupCollection> row_groups;
-	//! Table statistics
-	TableStatistics stats;
 	//! 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;
@@ -29359,7 +29470,7 @@ private:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/default_expression.hpp
+// duckdb/parser/expression/between_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -29369,28 +29480,38 @@ private:
 
 
 namespace duckdb {
-//! Represents the default value of a column
-class DefaultExpression : public ParsedExpression {
-public:
-	DefaultExpression();
 
+class BetweenExpression : public ParsedExpression {
 public:
-	bool IsScalar() const override {
-		return false;
-	}
+	DUCKDB_API 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(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+
+public:
+	template <class T, class BASE>
+	static string ToString(const T &entry) {
+		return "(" + entry.input->ToString() + " BETWEEN " + entry.lower->ToString() + " AND " +
+		       entry.upper->ToString() + ")";
+	}
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/parameter_expression.hpp
+// duckdb/parser/expression/positional_reference_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -29400,24 +29521,20 @@ public:
 
 
 namespace duckdb {
-class ParameterExpression : public ParsedExpression {
+class PositionalReferenceExpression : public ParsedExpression {
 public:
-	ParameterExpression();
+	DUCKDB_API PositionalReferenceExpression(idx_t index);
 
-	idx_t parameter_nr;
+	idx_t index;
 
 public:
 	bool IsScalar() const override {
-		return true;
-	}
-	bool HasParameter() const override {
-		return true;
+		return false;
 	}
 
 	string ToString() const override;
 
-	static bool Equals(const ParameterExpression *a, const ParameterExpression *b);
-
+	static bool Equals(const PositionalReferenceExpression *a, const PositionalReferenceExpression *b);
 	unique_ptr<ParsedExpression> Copy() const override;
 	hash_t Hash() const override;
 
@@ -29428,7 +29545,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/function_expression.hpp
+// duckdb/parser/expression/case_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -29438,117 +29555,52 @@ public:
 
 
 
-
 namespace duckdb {
-//! Represents a function call
-class FunctionExpression : public ParsedExpression {
+
+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:
-	DUCKDB_API 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, bool export_state = false);
-	DUCKDB_API 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, bool export_state = false);
+	DUCKDB_API CaseExpression();
 
-	//! 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;
-	//! whether this function should export its state or not
-	bool export_state;
+	vector<CaseCheck> case_checks;
+	unique_ptr<ParsedExpression> else_expr;
 
 public:
 	string ToString() const override;
 
-	unique_ptr<ParsedExpression> Copy() const override;
+	static bool Equals(const CaseExpression *a, const CaseExpression *b);
 
-	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
-	hash_t Hash() const override;
+	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 
-	void Verify() const override;
-
 public:
 	template <class T, class BASE>
-	static string ToString(const T &entry, const string &schema, const string &function_name, bool is_operator = false,
-	                       bool distinct = false, BASE *filter = nullptr, OrderModifier *order_bys = nullptr,
-	                       bool export_state = false, bool add_alias = false) {
-		if (is_operator) {
-			// built-in operator
-			D_ASSERT(!distinct);
-			if (entry.children.size() == 1) {
-				if (StringUtil::Contains(function_name, "__postfix")) {
-					return "(" + entry.children[0]->ToString() + ")" +
-					       StringUtil::Replace(function_name, "__postfix", "");
-				} else {
-					return function_name + "(" + entry.children[0]->ToString() + ")";
-				}
-			} else if (entry.children.size() == 2) {
-				return StringUtil::Format("(%s %s %s)", entry.children[0]->ToString(), function_name,
-				                          entry.children[1]->ToString());
-			}
-		}
-		// standard function call
-		string result = schema.empty() ? function_name : schema + "." + function_name;
-		result += "(";
-		if (distinct) {
-			result += "DISTINCT ";
-		}
-		result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
-			return child->alias.empty() || !add_alias
-			           ? child->ToString()
-			           : KeywordHelper::WriteOptionallyQuoted(child->alias) + " := " + child->ToString();
-		});
-		// ordered aggregate
-		if (order_bys && !order_bys->orders.empty()) {
-			if (entry.children.empty()) {
-				result += ") WITHIN GROUP (";
-			}
-			result += " ORDER BY ";
-			for (idx_t i = 0; i < order_bys->orders.size(); i++) {
-				if (i > 0) {
-					result += ", ";
-				}
-				result += order_bys->orders[i].ToString();
-			}
+	static string ToString(const T &entry) {
+		string case_str = "CASE ";
+		for (auto &check : entry.case_checks) {
+			case_str += " WHEN (" + check.when_expr->ToString() + ")";
+			case_str += " THEN (" + check.then_expr->ToString() + ")";
 		}
-		result += ")";
-
-		// filtered aggregate
-		if (filter) {
-			result += " FILTER (WHERE " + filter->ToString() + ")";
-		}
-
-		if (export_state) {
-			result += " EXPORT_STATE";
-		}
-
-		return result;
-	}
-};
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/comparison_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
+		case_str += " ELSE " + entry.else_expr->ToString();
+		case_str += " END";
+		return case_str;
+	}
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/comparison_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
 
 
@@ -29582,6 +29634,42 @@ public:
 		                          entry.right->ToString());
 	}
 };
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression/constant_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+//! ConstantExpression represents a constant value in the query
+class ConstantExpression : public ParsedExpression {
+public:
+	DUCKDB_API 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(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+};
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -29624,6 +29712,37 @@ public:
 //===----------------------------------------------------------------------===//
 //                         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;
+
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+};
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
 // duckdb/parser/expression/operator_expression.hpp
 //
 //
@@ -29731,44 +29850,13 @@ public:
 };
 
 } // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/expression/positional_reference_expression.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
 
 
 
-
-namespace duckdb {
-class PositionalReferenceExpression : public ParsedExpression {
-public:
-	DUCKDB_API 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(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-};
-} // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/conjunction_expression.hpp
+// duckdb/parser/expression/cast_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -29780,22 +29868,22 @@ public:
 
 namespace duckdb {
 
-//! Represents a conjunction (AND/OR)
-class ConjunctionExpression : public ParsedExpression {
+//! CastExpression represents a type cast from one SQL type to another SQL type
+class CastExpression : public ParsedExpression {
 public:
-	DUCKDB_API explicit ConjunctionExpression(ExpressionType type);
-	DUCKDB_API ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
-	DUCKDB_API ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
-	                                 unique_ptr<ParsedExpression> right);
+	DUCKDB_API CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
 
-	vector<unique_ptr<ParsedExpression>> children;
+	//! 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:
-	void AddExpression(unique_ptr<ParsedExpression> expr);
-
 	string ToString() const override;
 
-	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
+	static bool Equals(const CastExpression *a, const CastExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
@@ -29805,18 +29893,16 @@ public:
 public:
 	template <class T, class BASE>
 	static string ToString(const T &entry) {
-		string result = "(" + entry.children[0]->ToString();
-		for (idx_t i = 1; i < entry.children.size(); i++) {
-			result += " " + ExpressionTypeToOperator(entry.type) + " " + entry.children[i]->ToString();
-		}
-		return result + ")";
+		return (entry.try_cast ? "TRY_CAST(" : "CAST(") + entry.child->ToString() + " AS " +
+		       entry.cast_type.ToString() + ")";
 	}
 };
 } // namespace duckdb
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/between_expression.hpp
+// duckdb/parser/expression/collate_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -29827,37 +29913,34 @@ public:
 
 namespace duckdb {
 
-class BetweenExpression : public ParsedExpression {
+//! CollateExpression represents a COLLATE statement
+class CollateExpression : public ParsedExpression {
 public:
-	DUCKDB_API BetweenExpression(unique_ptr<ParsedExpression> input, unique_ptr<ParsedExpression> lower,
-	                             unique_ptr<ParsedExpression> upper);
+	CollateExpression(string collation, unique_ptr<ParsedExpression> child);
 
-	unique_ptr<ParsedExpression> input;
-	unique_ptr<ParsedExpression> lower;
-	unique_ptr<ParsedExpression> upper;
+	//! The child of the cast expression
+	unique_ptr<ParsedExpression> child;
+	//! The collation clause
+	string collation;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const BetweenExpression *a, const BetweenExpression *b);
+	static bool Equals(const CollateExpression *a, const CollateExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
-
-public:
-	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		return "(" + entry.input->ToString() + " BETWEEN " + entry.lower->ToString() + " AND " +
-		       entry.upper->ToString() + ")";
-	}
 };
 } // namespace duckdb
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/cast_expression.hpp
+// duckdb/parser/expression/conjunction_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -29869,22 +29952,22 @@ public:
 
 namespace duckdb {
 
-//! CastExpression represents a type cast from one SQL type to another SQL type
-class CastExpression : public ParsedExpression {
+//! Represents a conjunction (AND/OR)
+class ConjunctionExpression : public ParsedExpression {
 public:
-	DUCKDB_API CastExpression(LogicalType target, unique_ptr<ParsedExpression> child, bool try_cast = false);
+	DUCKDB_API explicit ConjunctionExpression(ExpressionType type);
+	DUCKDB_API ConjunctionExpression(ExpressionType type, vector<unique_ptr<ParsedExpression>> children);
+	DUCKDB_API ConjunctionExpression(ExpressionType type, unique_ptr<ParsedExpression> left,
+	                                 unique_ptr<ParsedExpression> right);
 
-	//! 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;
+	vector<unique_ptr<ParsedExpression>> children;
 
 public:
+	void AddExpression(unique_ptr<ParsedExpression> expr);
+
 	string ToString() const override;
 
-	static bool Equals(const CastExpression *a, const CastExpression *b);
+	static bool Equals(const ConjunctionExpression *a, const ConjunctionExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
 
@@ -29894,17 +29977,21 @@ public:
 public:
 	template <class T, class BASE>
 	static string ToString(const T &entry) {
-		return (entry.try_cast ? "TRY_CAST(" : "CAST(") + entry.child->ToString() + " AS " +
-		       entry.cast_type.ToString() + ")";
+		string result = "(" + entry.children[0]->ToString();
+		for (idx_t i = 1; i < entry.children.size(); i++) {
+			result += " " + ExpressionTypeToOperator(entry.type) + " " + entry.children[i]->ToString();
+		}
+		return result + ")";
 	}
 };
 } // namespace duckdb
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/case_expression.hpp
+// duckdb/parser/expression/function_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -29914,90 +30001,117 @@ public:
 
 
 
-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 {
+namespace duckdb {
+//! Represents a function call
+class FunctionExpression : public ParsedExpression {
 public:
-	DUCKDB_API CaseExpression();
+	DUCKDB_API 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, bool export_state = false);
+	DUCKDB_API 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, bool export_state = false);
 
-	vector<CaseCheck> case_checks;
-	unique_ptr<ParsedExpression> else_expr;
+	//! 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;
+	//! whether this function should export its state or not
+	bool export_state;
 
 public:
 	string ToString() const override;
 
-	static bool Equals(const CaseExpression *a, const CaseExpression *b);
-
 	unique_ptr<ParsedExpression> Copy() const override;
 
+	static bool Equals(const FunctionExpression *a, const FunctionExpression *b);
+	hash_t Hash() const override;
+
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 
+	void Verify() const override;
+
 public:
 	template <class T, class BASE>
-	static string ToString(const T &entry) {
-		string case_str = "CASE ";
-		for (auto &check : entry.case_checks) {
-			case_str += " WHEN (" + check.when_expr->ToString() + ")";
-			case_str += " THEN (" + check.then_expr->ToString() + ")";
+	static string ToString(const T &entry, const string &schema, const string &function_name, bool is_operator = false,
+	                       bool distinct = false, BASE *filter = nullptr, OrderModifier *order_bys = nullptr,
+	                       bool export_state = false, bool add_alias = false) {
+		if (is_operator) {
+			// built-in operator
+			D_ASSERT(!distinct);
+			if (entry.children.size() == 1) {
+				if (StringUtil::Contains(function_name, "__postfix")) {
+					return "(" + entry.children[0]->ToString() + ")" +
+					       StringUtil::Replace(function_name, "__postfix", "");
+				} else {
+					return function_name + "(" + entry.children[0]->ToString() + ")";
+				}
+			} else if (entry.children.size() == 2) {
+				return StringUtil::Format("(%s %s %s)", entry.children[0]->ToString(), function_name,
+				                          entry.children[1]->ToString());
+			}
 		}
-		case_str += " ELSE " + entry.else_expr->ToString();
-		case_str += " END";
-		return case_str;
-	}
-};
-} // 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;
+		// standard function call
+		string result = schema.empty() ? function_name : schema + "." + function_name;
+		result += "(";
+		if (distinct) {
+			result += "DISTINCT ";
+		}
+		result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
+			return child->alias.empty() || !add_alias
+			           ? child->ToString()
+			           : KeywordHelper::WriteOptionallyQuoted(child->alias) + " := " + child->ToString();
+		});
+		// ordered aggregate
+		if (order_bys && !order_bys->orders.empty()) {
+			if (entry.children.empty()) {
+				result += ") WITHIN GROUP (";
+			}
+			result += " ORDER BY ";
+			for (idx_t i = 0; i < order_bys->orders.size(); i++) {
+				if (i > 0) {
+					result += ", ";
+				}
+				result += order_bys->orders[i].ToString();
+			}
+		}
+		result += ")";
 
-	static bool Equals(const CollateExpression *a, const CollateExpression *b);
+		// filtered aggregate
+		if (filter) {
+			result += " FILTER (WHERE " + filter->ToString() + ")";
+		}
 
-	unique_ptr<ParsedExpression> Copy() const override;
+		if (export_state) {
+			result += " EXPORT_STATE";
+		}
 
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
+		return result;
+	}
 };
 } // namespace duckdb
 
 
 
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/expression/constant_expression.hpp
+// duckdb/parser/expression/parameter_expression.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30006,38 +30120,35 @@ public:
 
 
 
-
 namespace duckdb {
-
-//! ConstantExpression represents a constant value in the query
-class ConstantExpression : public ParsedExpression {
+class ParameterExpression : public ParsedExpression {
 public:
-	DUCKDB_API explicit ConstantExpression(Value val);
+	ParameterExpression();
 
-	//! The constant value referenced
-	Value value;
+	idx_t parameter_nr;
 
 public:
+	bool IsScalar() const override {
+		return true;
+	}
+	bool HasParameter() const override {
+		return true;
+	}
+
 	string ToString() const override;
 
-	static bool Equals(const ConstantExpression *a, const ConstantExpression *b);
-	hash_t Hash() const override;
+	static bool Equals(const ParameterExpression *a, const ParameterExpression *b);
 
 	unique_ptr<ParsedExpression> Copy() const override;
+	hash_t Hash() const override;
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ParsedExpression> Deserialize(ExpressionType type, FieldReader &source);
 };
-
 } // namespace duckdb
 
 
 
-
-
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -30092,7 +30203,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/export_table_data.hpp
+// duckdb/parser/parsed_data/create_type_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30102,34 +30213,89 @@ public:
 
 
 
+
+
 namespace duckdb {
-class TableCatalogEntry;
 
-struct ExportedTableData {
-	//! Name of the exported table
-	string table_name;
+struct CreateTypeInfo : public CreateInfo {
+	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
+	}
+	CreateTypeInfo(string name_p, LogicalType type_p)
+	    : CreateInfo(CatalogType::TYPE_ENTRY), name(move(name_p)), type(move(type_p)) {
+	}
 
-	//! Name of the schema
-	string schema_name;
+	//! Name of the Type
+	string name;
+	//! Logical Type
+	LogicalType type;
 
-	//! Path to be exported
-	string file_path;
-};
+public:
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateTypeInfo>();
+		CopyProperties(*result);
+		result->name = name;
+		result->type = type;
+		return move(result);
+	}
 
-struct ExportedTableInfo {
-	TableCatalogEntry *entry;
-	ExportedTableData table_data;
+protected:
+	void SerializeInternal(Serializer &) const override {
+		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(CreateInfo::type));
+	}
 };
 
-struct BoundExportData : public ParseInfo {
-	std::vector<ExportedTableInfo> data;
+} // 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;
+
+protected:
+	void SerializeInternal(Serializer &) const override {
+		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
+	}
+
+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/transaction_info.hpp
+// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30138,23 +30304,39 @@ struct BoundExportData : public ParseInfo {
 
 
 
+
 namespace duckdb {
 
-enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
+struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
+	explicit CreateAggregateFunctionInfo(AggregateFunction function)
+	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
+		name = function.name;
+		functions.AddFunction(move(function));
+	}
 
-struct TransactionInfo : public ParseInfo {
-	explicit TransactionInfo(TransactionType type) : type(type) {
+	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set)
+	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
+		name = functions.name;
+		for (auto &func : functions.functions) {
+			func.name = functions.name;
+		}
 	}
 
-	//! The type of transaction statement
-	TransactionType type;
+	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/create_index_info.hpp
+// duckdb/parser/parsed_data/vacuum_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30163,11 +30345,20 @@ struct TransactionInfo : public ParseInfo {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/tableref/bound_basetableref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/basetableref.hpp
+// duckdb/planner/bound_tableref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30177,75 +30368,158 @@ struct TransactionInfo : public ParseInfo {
 
 
 
+
 namespace duckdb {
+
+class BoundTableRef {
+public:
+	explicit BoundTableRef(TableReferenceType type) : type(type) {
+	}
+	virtual ~BoundTableRef() {
+	}
+
+	//! The type of table reference
+	TableReferenceType type;
+	//! The sample options (if any)
+	unique_ptr<SampleOptions> sample;
+};
+} // namespace duckdb
+
+
+
+namespace duckdb {
+class TableCatalogEntry;
+
 //! Represents a TableReference to a base table in the schema
-class BaseTableRef : public TableRef {
+class BoundBaseTableRef : public BoundTableRef {
 public:
-	BaseTableRef() : TableRef(TableReferenceType::BASE_TABLE), schema_name(INVALID_SCHEMA) {
+	BoundBaseTableRef(TableCatalogEntry *table, unique_ptr<LogicalOperator> get)
+	    : BoundTableRef(TableReferenceType::BASE_TABLE), table(table), get(move(get)) {
 	}
 
-	//! Schema name
-	string schema_name;
-	//! Table name
-	string table_name;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
+	TableCatalogEntry *table;
+	unique_ptr<LogicalOperator> get;
+};
+} // namespace duckdb
+
 
+
+namespace duckdb {
+
+struct VacuumOptions {
+	bool vacuum;
+	bool analyze;
+};
+
+struct VacuumInfo : public ParseInfo {
 public:
-	string ToString() const override;
-	bool Equals(const TableRef *other_p) const override;
+	explicit VacuumInfo(VacuumOptions options) : options(options), has_table(false), table(nullptr) {};
 
-	unique_ptr<TableRef> Copy() override;
+	unique_ptr<VacuumInfo> Copy() {
+		auto result = make_unique<VacuumInfo>(options);
+		result->has_table = has_table;
+		if (has_table) {
+			result->ref = ref->Copy();
+		}
+		return result;
+	}
 
-	//! Serializes a blob into a BaseTableRef
-	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a BaseTableRef
-	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+	const VacuumOptions options;
+
+public:
+	bool has_table;
+	unique_ptr<TableRef> ref;
+	TableCatalogEntry *table;
+	unordered_map<idx_t, idx_t> column_id_map;
+	vector<string> columns;
 };
+
 } // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/drop_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
 
 
 
 
 namespace duckdb {
 
-struct CreateIndexInfo : public CreateInfo {
-	CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY) {
+struct DropInfo : public ParseInfo {
+	DropInfo() : schema(INVALID_SCHEMA), if_exists(false), cascade(false) {
 	}
 
-	//! Index Type (e.g., B+-tree, Skip-List, ...)
-	IndexType index_type;
-	//! Name of the Index
-	string index_name;
-	//! Index Constraint Type
-	IndexConstraintType constraint_type;
-	//! The table to create the index on
-	unique_ptr<BaseTableRef> table;
-	//! Set of expressions to index by
-	vector<unique_ptr<ParsedExpression>> expressions;
-	vector<unique_ptr<ParsedExpression>> parsed_expressions;
+	//! 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;
 
-	//! Types used for the CREATE INDEX scan
-	vector<LogicalType> scan_types;
-	//! The names of the columns, used for the CREATE INDEX scan
-	vector<string> names;
-	//! Column IDs needed for index creation
-	vector<column_t> column_ids;
+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;
+	}
+};
 
-protected:
-	void SerializeInternal(Serializer &serializer) const override;
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/export_table_data.hpp
+//
+//
+//===----------------------------------------------------------------------===//
 
-public:
-	unique_ptr<CreateInfo> Copy() const override;
 
-	static unique_ptr<CreateIndexInfo> Deserialize(Deserializer &deserializer);
+
+
+
+
+namespace duckdb {
+class TableCatalogEntry;
+
+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 ExportedTableInfo {
+	TableCatalogEntry *entry;
+	ExportedTableData table_data;
+};
+
+struct BoundExportData : public ParseInfo {
+	std::vector<ExportedTableInfo> data;
 };
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_aggregate_function_info.hpp
+// duckdb/parser/parsed_data/alter_function_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30255,31 +30529,37 @@ public:
 
 
 
+
 namespace duckdb {
 
-struct CreateAggregateFunctionInfo : public CreateFunctionInfo {
-	explicit CreateAggregateFunctionInfo(AggregateFunction function)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(function.name) {
-		name = function.name;
-		functions.AddFunction(move(function));
-	}
+//===--------------------------------------------------------------------===//
+// Alter Table
+//===--------------------------------------------------------------------===//
+enum class AlterFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOADS = 1 };
 
-	explicit CreateAggregateFunctionInfo(AggregateFunctionSet set)
-	    : CreateFunctionInfo(CatalogType::AGGREGATE_FUNCTION_ENTRY), functions(move(set)) {
-		name = functions.name;
-		for (auto &func : functions.functions) {
-			func.name = functions.name;
-		}
-	}
+struct AlterFunctionInfo : public AlterInfo {
+	AlterFunctionInfo(AlterFunctionType type, string schema, string name, bool if_exists);
+	virtual ~AlterFunctionInfo() override;
 
-	AggregateFunctionSet functions;
+	AlterFunctionType alter_function_type;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateAggregateFunctionInfo>(functions);
-		CopyProperties(*result);
-		return move(result);
-	}
+	CatalogType GetCatalogType() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader);
+};
+
+//===--------------------------------------------------------------------===//
+// AddFunctionOverloadInfo
+//===--------------------------------------------------------------------===//
+struct AddFunctionOverloadInfo : public AlterFunctionInfo {
+	AddFunctionOverloadInfo(string schema, string name, bool if_exists, ScalarFunctionSet new_overloads);
+	~AddFunctionOverloadInfo() override;
+
+	ScalarFunctionSet new_overloads;
+
+public:
+	unique_ptr<AlterInfo> Copy() const override;
 };
 
 } // namespace duckdb
@@ -30383,7 +30663,7 @@ protected:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/show_select_info.hpp
+// duckdb/parser/parsed_data/create_schema_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30392,74 +30672,28 @@ protected:
 
 
 
-
 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;
+struct CreateSchemaInfo : public CreateInfo {
+	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
 	}
-};
-
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/alter_function_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// Alter Table
-//===--------------------------------------------------------------------===//
-enum class AlterFunctionType : uint8_t { INVALID = 0, ADD_FUNCTION_OVERLOADS = 1 };
-
-struct AlterFunctionInfo : public AlterInfo {
-	AlterFunctionInfo(AlterFunctionType type, string schema, string name, bool if_exists);
-	virtual ~AlterFunctionInfo() override;
-
-	AlterFunctionType alter_function_type;
 
 public:
-	CatalogType GetCatalogType() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<AlterInfo> Deserialize(FieldReader &reader);
-};
-
-//===--------------------------------------------------------------------===//
-// AddFunctionOverloadInfo
-//===--------------------------------------------------------------------===//
-struct AddFunctionOverloadInfo : public AlterFunctionInfo {
-	AddFunctionOverloadInfo(string schema, string name, bool if_exists, ScalarFunctionSet new_overloads);
-	~AddFunctionOverloadInfo() override;
+	unique_ptr<CreateInfo> Copy() const override {
+		auto result = make_unique<CreateSchemaInfo>();
+		CopyProperties(*result);
+		return move(result);
+	}
 
-	ScalarFunctionSet new_overloads;
+	static unique_ptr<CreateSchemaInfo> Deserialize(Deserializer &deserializer) {
+		auto result = make_unique<CreateSchemaInfo>();
+		result->DeserializeBase(deserializer);
+		return result;
+	}
 
-public:
-	unique_ptr<AlterInfo> Copy() const override;
+protected:
+	void SerializeInternal(Serializer &) const override {
+	}
 };
 
 } // namespace duckdb
@@ -30546,50 +30780,6 @@ public:
 	}
 };
 
-} // 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
@@ -30632,7 +30822,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/vacuum_info.hpp
+// duckdb/parser/parsed_data/transaction_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30641,20 +30831,23 @@ public:
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/tableref/bound_basetableref.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/planner/bound_tableref.hpp
+// duckdb/parser/parsed_data/create_index_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30664,77 +30857,10 @@ public:
 
 
 
-
-namespace duckdb {
-
-class BoundTableRef {
-public:
-	explicit BoundTableRef(TableReferenceType type) : type(type) {
-	}
-	virtual ~BoundTableRef() {
-	}
-
-	//! The type of table reference
-	TableReferenceType type;
-	//! The sample options (if any)
-	unique_ptr<SampleOptions> sample;
-};
-} // namespace duckdb
-
-
-
-namespace duckdb {
-class TableCatalogEntry;
-
-//! Represents a TableReference to a base table in the schema
-class BoundBaseTableRef : public BoundTableRef {
-public:
-	BoundBaseTableRef(TableCatalogEntry *table, unique_ptr<LogicalOperator> get)
-	    : BoundTableRef(TableReferenceType::BASE_TABLE), table(table), get(move(get)) {
-	}
-
-	TableCatalogEntry *table;
-	unique_ptr<LogicalOperator> get;
-};
-} // namespace duckdb
-
-
-
-namespace duckdb {
-
-struct VacuumOptions {
-	bool vacuum;
-	bool analyze;
-};
-
-struct VacuumInfo : public ParseInfo {
-public:
-	explicit VacuumInfo(VacuumOptions options) : options(options), has_table(false), table(nullptr) {};
-
-	unique_ptr<VacuumInfo> Copy() {
-		auto result = make_unique<VacuumInfo>(options);
-		result->has_table = has_table;
-		if (has_table) {
-			result->ref = ref->Copy();
-		}
-		return result;
-	}
-
-	const VacuumOptions options;
-
-public:
-	bool has_table;
-	unique_ptr<TableRef> ref;
-	TableCatalogEntry *table;
-	unordered_map<idx_t, idx_t> column_id_map;
-	vector<string> columns;
-};
-
-} // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_collation_info.hpp
+// duckdb/parser/tableref/basetableref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30745,80 +30871,74 @@ public:
 
 
 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);
+//! Represents a TableReference to a base table in the schema
+class BaseTableRef : public TableRef {
+public:
+	BaseTableRef() : TableRef(TableReferenceType::BASE_TABLE), schema_name(INVALID_SCHEMA) {
 	}
 
-	//! 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;
-
-protected:
-	void SerializeInternal(Serializer &) const override {
-		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
-	}
+	//! Schema name
+	string schema_name;
+	//! Table name
+	string table_name;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateCollationInfo>(name, function, combinable, not_required_for_equality);
-		CopyProperties(*result);
-		return move(result);
-	}
-};
+	string ToString() const override;
+	bool Equals(const TableRef *other_p) const override;
 
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parser/parsed_data/create_schema_info.hpp
-//
-//
-//===----------------------------------------------------------------------===//
+	unique_ptr<TableRef> Copy() override;
 
+	//! Serializes a blob into a BaseTableRef
+	void Serialize(FieldWriter &serializer) const override;
+	//! Deserializes a blob back into a BaseTableRef
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+};
+} // namespace duckdb
 
 
 
 
 namespace duckdb {
 
-struct CreateSchemaInfo : public CreateInfo {
-	CreateSchemaInfo() : CreateInfo(CatalogType::SCHEMA_ENTRY) {
+struct CreateIndexInfo : public CreateInfo {
+	CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY) {
 	}
 
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateSchemaInfo>();
-		CopyProperties(*result);
-		return move(result);
-	}
+	//! Index Type (e.g., B+-tree, Skip-List, ...)
+	IndexType index_type;
+	//! Name of the Index
+	string index_name;
+	//! Index Constraint Type
+	IndexConstraintType constraint_type;
+	//! The table to create the index on
+	unique_ptr<BaseTableRef> table;
+	//! Set of expressions to index by
+	vector<unique_ptr<ParsedExpression>> expressions;
+	vector<unique_ptr<ParsedExpression>> parsed_expressions;
 
-	static unique_ptr<CreateSchemaInfo> Deserialize(Deserializer &deserializer) {
-		auto result = make_unique<CreateSchemaInfo>();
-		result->DeserializeBase(deserializer);
-		return result;
-	}
+	//! Types used for the CREATE INDEX scan
+	vector<LogicalType> scan_types;
+	//! The names of the columns, used for the CREATE INDEX scan
+	vector<string> names;
+	//! Column IDs needed for index creation
+	vector<column_t> column_ids;
 
 protected:
-	void SerializeInternal(Serializer &) const override {
-	}
+	void SerializeInternal(Serializer &serializer) const override;
+
+public:
+	unique_ptr<CreateInfo> Copy() const override;
+
+	static unique_ptr<CreateIndexInfo> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/create_type_info.hpp
+// duckdb/parser/parsed_data/show_select_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30828,34 +30948,25 @@ protected:
 
 
 
-
-
 namespace duckdb {
 
-struct CreateTypeInfo : public CreateInfo {
-	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
-	}
-	CreateTypeInfo(string name_p, LogicalType type_p)
-	    : CreateInfo(CatalogType::TYPE_ENTRY), name(move(name_p)), type(move(type_p)) {
-	}
-
-	//! Name of the Type
-	string name;
-	//! Logical Type
-	LogicalType type;
-
-public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_unique<CreateTypeInfo>();
-		CopyProperties(*result);
-		result->name = name;
-		result->type = type;
-		return move(result);
-	}
+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;
 
-protected:
-	void SerializeInternal(Serializer &) const override {
-		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(CreateInfo::type));
+	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;
 	}
 };
 
@@ -30863,7 +30974,7 @@ protected:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/subqueryref.hpp
+// duckdb/parser/tableref/expressionlistref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30873,16 +30984,21 @@ protected:
 
 
 
+
+
 namespace duckdb {
-//! Represents a subquery
-class SubqueryRef : public TableRef {
+//! Represents an expression list as generated by a VALUES statement
+class ExpressionListRef : public TableRef {
 public:
-	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
+	ExpressionListRef() : TableRef(TableReferenceType::EXPRESSION_LIST) {
+	}
 
-	//! The subquery
-	unique_ptr<SelectStatement> subquery;
-	//! Aliases for the column names
-	vector<string> column_name_alias;
+	//! 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:
 	string ToString() const override;
@@ -30890,9 +31006,9 @@ public:
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a SubqueryRef
+	//! Serializes a blob into a ExpressionListRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a SubqueryRef
+	//! Deserializes a blob back into a ExpressionListRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
@@ -30947,7 +31063,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/table_function_ref.hpp
+// duckdb/parser/tableref/subqueryref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -30957,41 +31073,33 @@ public:
 
 
 
-
-
-
 namespace duckdb {
-//! Represents a Table producing function
-class TableFunctionRef : public TableRef {
+//! Represents a subquery
+class SubqueryRef : public TableRef {
 public:
-	DUCKDB_API TableFunctionRef();
-
-	unique_ptr<ParsedExpression> function;
-	vector<string> column_name_alias;
+	explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
 
-	// if the function takes a subquery as argument its in here
+	//! The subquery
 	unique_ptr<SelectStatement> subquery;
-
-	// External dependencies of this table funcion
-	unique_ptr<ExternalDependency> external_dependency;
+	//! 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
+	//! Serializes a blob into a SubqueryRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a BaseTableRef
+	//! Deserializes a blob back into a SubqueryRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/crossproductref.hpp
+// duckdb/parser/tableref/emptytableref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31002,32 +31110,27 @@ public:
 
 namespace duckdb {
 //! Represents a cross product
-class CrossProductRef : public TableRef {
+class EmptyTableRef : public TableRef {
 public:
-	CrossProductRef() : TableRef(TableReferenceType::CROSS_PRODUCT) {
+	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
 	}
 
-	//! 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:
 	string ToString() const override;
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a CrossProductRef
+	//! Serializes a blob into a DummyTableRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a CrossProductRef
+	//! Deserializes a blob back into a DummyTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/expressionlistref.hpp
+// duckdb/parser/tableref/crossproductref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31036,22 +31139,17 @@ public:
 
 
 
-
-
-
 namespace duckdb {
-//! Represents an expression list as generated by a VALUES statement
-class ExpressionListRef : public TableRef {
+//! Represents a cross product
+class CrossProductRef : public TableRef {
 public:
-	ExpressionListRef() : TableRef(TableReferenceType::EXPRESSION_LIST) {
+	CrossProductRef() : TableRef(TableReferenceType::CROSS_PRODUCT) {
 	}
 
-	//! 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;
+	//! 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:
 	string ToString() const override;
@@ -31059,16 +31157,16 @@ public:
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a ExpressionListRef
+	//! Serializes a blob into a CrossProductRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a ExpressionListRef
+	//! Deserializes a blob back into a CrossProductRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/tableref/emptytableref.hpp
+// duckdb/parser/tableref/table_function_ref.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -31077,22 +31175,35 @@ public:
 
 
 
+
+
+
+
 namespace duckdb {
-//! Represents a cross product
-class EmptyTableRef : public TableRef {
+//! Represents a Table producing function
+class TableFunctionRef : public TableRef {
 public:
-	EmptyTableRef() : TableRef(TableReferenceType::EMPTY) {
-	}
+	DUCKDB_API TableFunctionRef();
+
+	unique_ptr<ParsedExpression> function;
+	vector<string> column_name_alias;
+
+	// if the function takes a subquery as argument its in here
+	unique_ptr<SelectStatement> subquery;
+
+	// External dependencies of this table funcion
+	unique_ptr<ExternalDependency> external_dependency;
 
 public:
 	string ToString() const override;
+
 	bool Equals(const TableRef *other_p) const override;
 
 	unique_ptr<TableRef> Copy() override;
 
-	//! Serializes a blob into a DummyTableRef
+	//! Serializes a blob into a BaseTableRef
 	void Serialize(FieldWriter &serializer) const override;
-	//! Deserializes a blob back into a DummyTableRef
+	//! Deserializes a blob back into a BaseTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 };
 } // namespace duckdb