duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/schema_catalog_entry.hpp

@@ -41,8 +41,6 @@ struct DropInfo;
 
 //! A schema in the catalog
 class SchemaCatalogEntry : public CatalogEntry {
-	friend class Catalog;
-
 public:
 	static constexpr const CatalogType Type = CatalogType::SCHEMA_ENTRY;
 	static constexpr const char *Name = "schema";
@@ -50,31 +48,12 @@ public:
 public:
 	SchemaCatalogEntry(Catalog *catalog, string name, bool is_internal);
 
-private:
-	//! The catalog set holding the tables
-	CatalogSet tables;
-	//! The catalog set holding the indexes
-	CatalogSet indexes;
-	//! The catalog set holding the table functions
-	CatalogSet table_functions;
-	//! The catalog set holding the copy functions
-	CatalogSet copy_functions;
-	//! The catalog set holding the pragma functions
-	CatalogSet pragma_functions;
-	//! The catalog set holding the scalar and aggregate functions
-	CatalogSet functions;
-	//! The catalog set holding the sequences
-	CatalogSet sequences;
-	//! The catalog set holding the collations
-	CatalogSet collations;
-	//! The catalog set holding the types
-	CatalogSet types;
-
 public:
 	//! Scan the specified catalog set, invoking the callback method for every entry
-	void Scan(ClientContext &context, CatalogType type, const std::function<void(CatalogEntry *)> &callback);
+	virtual void Scan(ClientContext &context, CatalogType type,
+	                  const std::function<void(CatalogEntry *)> &callback) = 0;
 	//! Scan the specified catalog set, invoking the callback method for every committed entry
-	void Scan(CatalogType type, const std::function<void(CatalogEntry *)> &callback);
+	virtual void Scan(CatalogType type, const std::function<void(CatalogEntry *)> &callback) = 0;
 
 	//! Serialize the meta information of the SchemaCatalogEntry a serializer
 	virtual void Serialize(Serializer &serializer);
@@ -84,45 +63,35 @@ public:
 	string ToSQL() override;
 
 	//! Creates an index with the given name in the schema
-	CatalogEntry *CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table);
-
-	void Verify(Catalog &catalog) override;
-
-private:
+	virtual CatalogEntry *CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table) = 0;
 	//! Create a scalar or aggregate function within the given schema
-	CatalogEntry *CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info);
+	virtual CatalogEntry *CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info) = 0;
 	//! Creates a table with the given name in the schema
-	CatalogEntry *CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info);
+	virtual CatalogEntry *CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info) = 0;
 	//! Creates a view with the given name in the schema
-	CatalogEntry *CreateView(CatalogTransaction transaction, CreateViewInfo *info);
+	virtual CatalogEntry *CreateView(CatalogTransaction transaction, CreateViewInfo *info) = 0;
 	//! Creates a sequence with the given name in the schema
-	CatalogEntry *CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info);
+	virtual CatalogEntry *CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info) = 0;
 	//! Create a table function within the given schema
-	CatalogEntry *CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info);
+	virtual CatalogEntry *CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info) = 0;
 	//! Create a copy function within the given schema
-	CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info);
+	virtual CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info) = 0;
 	//! Create a pragma function within the given schema
-	CatalogEntry *CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info);
+	virtual CatalogEntry *CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info) = 0;
 	//! Create a collation within the given schema
-	CatalogEntry *CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info);
+	virtual CatalogEntry *CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info) = 0;
 	//! Create a enum within the given schema
-	CatalogEntry *CreateType(CatalogTransaction transaction, CreateTypeInfo *info);
+	virtual CatalogEntry *CreateType(CatalogTransaction transaction, CreateTypeInfo *info) = 0;
+
+	DUCKDB_API virtual CatalogEntry *GetEntry(CatalogTransaction transaction, CatalogType type, const string &name) = 0;
+	DUCKDB_API virtual SimilarCatalogEntry GetSimilarEntry(CatalogTransaction transaction, CatalogType type,
+	                                                       const string &name);
 
 	//! Drops an entry from the schema
-	void DropEntry(ClientContext &context, DropInfo *info);
+	virtual void DropEntry(ClientContext &context, DropInfo *info) = 0;
 
 	//! Alters a catalog entry
-	void Alter(ClientContext &context, AlterInfo *info);
-
-	//! Add a catalog entry to this schema
-	CatalogEntry *AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
-	                       OnCreateConflict on_conflict);
-	//! Add a catalog entry to this schema
-	CatalogEntry *AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
-	                       OnCreateConflict on_conflict, DependencyList dependencies);
-
-	//! Get the catalog set for the specified type
-	CatalogSet &GetCatalogSet(CatalogType type);
+	virtual void Alter(ClientContext &context, AlterInfo *info) = 0;
 
 	CatalogTransaction GetCatalogTransaction(ClientContext &context);
 };

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp

@@ -33,6 +33,13 @@ struct AlterForeignKeyInfo;
 struct SetNotNullInfo;
 struct DropNotNullInfo;
 
+class TableFunction;
+struct FunctionData;
+
+class TableColumnInfo;
+class TableIndexInfo;
+class TableStorageInfo;
+
 //! A table catalog entry
 class TableCatalogEntry : public StandardEntry {
 public:
@@ -40,64 +47,66 @@ public:
 	static constexpr const char *Name = "table";
 
 public:
-	//! Create a real TableCatalogEntry and initialize storage for it
-	TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, BoundCreateTableInfo *info,
-	                  std::shared_ptr<DataTable> inherited_storage = nullptr);
-
-	//! A reference to the underlying storage unit used for this table
-	std::shared_ptr<DataTable> storage;
-	//! A list of columns that are part of this table
-	ColumnList columns;
-	//! A list of constraints that are part of this table
-	vector<unique_ptr<Constraint>> constraints;
-	//! A list of constraints that are part of this table
-	vector<unique_ptr<BoundConstraint>> bound_constraints;
-	ColumnDependencyManager column_dependency_manager;
+	//! Create a TableCatalogEntry and initialize storage for it
+	DUCKDB_API TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTableInfo &info);
 
 public:
-	bool HasGeneratedColumns() const;
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
-	void UndoAlter(ClientContext &context, AlterInfo *info) override;
+	DUCKDB_API bool HasGeneratedColumns() const;
 
 	//! Returns whether or not a column with the given name exists
 	DUCKDB_API bool ColumnExists(const string &name);
 	//! Returns a reference to the column of the specified name. Throws an
 	//! exception if the column does not exist.
-	ColumnDefinition &GetColumn(const string &name);
+	DUCKDB_API const ColumnDefinition &GetColumn(const string &name);
+	//! Returns a reference to the column of the specified logical index. Throws an
+	//! exception if the column does not exist.
+	DUCKDB_API const ColumnDefinition &GetColumn(LogicalIndex idx);
 	//! Returns a list of types of the table, excluding generated columns
-	vector<LogicalType> GetTypes();
-	string ToSQL() override;
+	DUCKDB_API vector<LogicalType> GetTypes();
+	//! Returns a list of the columns of the table
+	DUCKDB_API const ColumnList &GetColumns() const;
+	//! Returns a mutable list of the columns of the table
+	DUCKDB_API ColumnList &GetColumnsMutable();
+	//! Returns the underlying storage of the table
+	virtual DataTable &GetStorage();
+	virtual DataTable *GetStoragePtr();
+	//! Returns a list of the bound constraints of the table
+	virtual const vector<unique_ptr<BoundConstraint>> &GetBoundConstraints();
+
+	//! Returns a list of the constraints of the table
+	DUCKDB_API const vector<unique_ptr<Constraint>> &GetConstraints();
+	DUCKDB_API string ToSQL() override;
 
 	//! Get statistics of a column (physical or virtual) within the table
-	unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id);
+	virtual unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id) = 0;
 
 	//! Serialize the meta information of the TableCatalogEntry a serializer
 	virtual void Serialize(Serializer &serializer);
 	//! Deserializes to a CreateTableInfo
 	static unique_ptr<CreateTableInfo> Deserialize(Deserializer &source, ClientContext &context);
 
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) override;
-
-	void SetAsRoot() override;
-
-	void CommitAlter(AlterInfo &info);
-	void CommitDrop();
-
 	//! Returns the column index of the specified column name.
 	//! If the column does not exist:
 	//! If if_column_exists is true, returns DConstants::INVALID_INDEX
 	//! If if_column_exists is false, throws an exception
-	LogicalIndex GetColumnIndex(string &name, bool if_exists = false);
-
-private:
-	unique_ptr<CatalogEntry> RenameColumn(ClientContext &context, RenameColumnInfo &info);
-	unique_ptr<CatalogEntry> AddColumn(ClientContext &context, AddColumnInfo &info);
-	unique_ptr<CatalogEntry> RemoveColumn(ClientContext &context, RemoveColumnInfo &info);
-	unique_ptr<CatalogEntry> SetDefault(ClientContext &context, SetDefaultInfo &info);
-	unique_ptr<CatalogEntry> ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info);
-	unique_ptr<CatalogEntry> SetNotNull(ClientContext &context, SetNotNullInfo &info);
-	unique_ptr<CatalogEntry> DropNotNull(ClientContext &context, DropNotNullInfo &info);
-	unique_ptr<CatalogEntry> AddForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
-	unique_ptr<CatalogEntry> DropForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info);
+	DUCKDB_API LogicalIndex GetColumnIndex(string &name, bool if_exists = false);
+
+	//! Returns the scan function that can be used to scan the given table
+	virtual TableFunction GetScanFunction(ClientContext &context, unique_ptr<FunctionData> &bind_data) = 0;
+
+	virtual bool IsDuckTable() {
+		return false;
+	}
+
+	DUCKDB_API static string ColumnsToSQL(const ColumnList &columns, const vector<unique_ptr<Constraint>> &constraints);
+
+	//! Returns the storage info of this table
+	virtual TableStorageInfo GetStorageInfo(ClientContext &context) = 0;
+
+protected:
+	//! A list of columns that are part of this table
+	ColumnList columns;
+	//! A list of constraints that are part of this table
+	vector<unique_ptr<Constraint>> constraints;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_set.hpp

@@ -16,10 +16,9 @@
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/parser/column_definition.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
 #include "duckdb/transaction/transaction.hpp"
 #include "duckdb/catalog/catalog_transaction.hpp"
+#include "duckdb/catalog/similar_catalog_entry.hpp"
 #include <functional>
 #include <memory>
 
@@ -31,6 +30,10 @@ class DependencyList;
 struct MappingValue;
 struct EntryIndex;
 
+class DuckCatalog;
+class TableCatalogEntry;
+class SequenceCatalogEntry;
+
 typedef unordered_map<CatalogSet *, unique_lock<mutex>> set_lock_map_t;
 
 struct EntryValue {
@@ -38,7 +41,7 @@ struct EntryValue {
 		throw InternalException("EntryValue called without a catalog entry");
 	}
 
-	explicit EntryValue(unique_ptr<CatalogEntry> entry_p) : entry(move(entry_p)), reference_count(0) {
+	explicit EntryValue(unique_ptr<CatalogEntry> entry_p) : entry(std::move(entry_p)), reference_count(0) {
 	}
 	//! enable move constructors
 	EntryValue(EntryValue &&other) noexcept {
@@ -83,7 +86,7 @@ public:
 	DUCKDB_API bool DropEntry(ClientContext &context, const string &name, bool cascade,
 	                          bool allow_drop_internal = false);
 
-	DUCKDB_API Catalog &GetCatalog();
+	DUCKDB_API DuckCatalog &GetCatalog();
 
 	bool AlterOwnership(CatalogTransaction transaction, ChangeOwnershipInfo *info);
 
@@ -95,7 +98,7 @@ public:
 
 	//! Gets the entry that is most similar to the given name (i.e. smallest levenshtein distance), or empty string if
 	//! none is found. The returned pair consists of the entry name and the distance (smaller means closer).
-	pair<string, idx_t> SimilarEntry(CatalogTransaction transaction, const string &name);
+	SimilarCatalogEntry SimilarEntry(CatalogTransaction transaction, const string &name);
 
 	//! Rollback <entry> to be the currently valid entry for a certain catalog
 	//! entry
@@ -152,7 +155,7 @@ private:
 	void PutEntry(EntryIndex index, unique_ptr<CatalogEntry> entry);
 
 private:
-	Catalog &catalog;
+	DuckCatalog &catalog;
 	//! The catalog lock is used to make changes to the data
 	mutex catalog_lock;
 	//! The set of catalog entries

package/src/duckdb/src/include/duckdb/catalog/dependency_manager.hpp

@@ -16,7 +16,7 @@
 #include <functional>
 
 namespace duckdb {
-class Catalog;
+class DuckCatalog;
 class ClientContext;
 class DependencyList;
 
@@ -25,7 +25,7 @@ class DependencyManager {
 	friend class CatalogSet;
 
 public:
-	explicit DependencyManager(Catalog &catalog);
+	explicit DependencyManager(DuckCatalog &catalog);
 
 	//! Erase the object from the DependencyManager; this should only happen when the object itself is destroyed
 	void EraseObject(CatalogEntry *object);
@@ -36,7 +36,7 @@ public:
 	void AddOwnership(CatalogTransaction transaction, CatalogEntry *owner, CatalogEntry *entry);
 
 private:
-	Catalog &catalog;
+	DuckCatalog &catalog;
 	//! Map of objects that DEPEND on [object], i.e. [object] can only be deleted when all entries in the dependency map
 	//! are deleted.
 	unordered_map<CatalogEntry *, dependency_set_t> dependents_map;

package/src/duckdb/src/include/duckdb/catalog/duck_catalog.hpp

@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/dcatalog.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/catalog/catalog.hpp"
+
+namespace duckdb {
+
+//! The Catalog object represents the catalog of the database.
+class DuckCatalog : public Catalog {
+public:
+	explicit DuckCatalog(AttachedDatabase &db);
+	~DuckCatalog();
+
+public:
+	bool IsDuckCatalog() override;
+	void Initialize(bool load_builtin) override;
+	string GetCatalogType() override {
+		return "duckdb";
+	}
+
+	DependencyManager &GetDependencyManager() {
+		return *dependency_manager;
+	}
+	mutex &GetWriteLock() {
+		return write_lock;
+	}
+
+public:
+	DUCKDB_API CatalogEntry *CreateSchema(CatalogTransaction transaction, CreateSchemaInfo *info) override;
+	DUCKDB_API void ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback) override;
+	DUCKDB_API void ScanSchemas(std::function<void(CatalogEntry *)> callback);
+
+	DUCKDB_API SchemaCatalogEntry *GetSchema(CatalogTransaction transaction, const string &schema_name,
+	                                         bool if_exists = false,
+	                                         QueryErrorContext error_context = QueryErrorContext()) override;
+
+	DUCKDB_API unique_ptr<PhysicalOperator> PlanCreateTableAs(ClientContext &context, LogicalCreateTable &op,
+	                                                          unique_ptr<PhysicalOperator> plan) override;
+	DUCKDB_API unique_ptr<PhysicalOperator> PlanInsert(ClientContext &context, LogicalInsert &op,
+	                                                   unique_ptr<PhysicalOperator> plan) override;
+	DUCKDB_API unique_ptr<PhysicalOperator> PlanDelete(ClientContext &context, LogicalDelete &op,
+	                                                   unique_ptr<PhysicalOperator> plan) override;
+	DUCKDB_API unique_ptr<PhysicalOperator> PlanUpdate(ClientContext &context, LogicalUpdate &op,
+	                                                   unique_ptr<PhysicalOperator> plan) override;
+	DUCKDB_API unique_ptr<LogicalOperator> BindCreateIndex(Binder &binder, CreateStatement &stmt,
+	                                                       TableCatalogEntry &table,
+	                                                       unique_ptr<LogicalOperator> plan) override;
+
+	DatabaseSize GetDatabaseSize(ClientContext &context) override;
+
+	DUCKDB_API bool InMemory() override;
+	DUCKDB_API string GetDBPath() override;
+
+private:
+	DUCKDB_API void DropSchema(ClientContext &context, DropInfo *info) override;
+
+	void Verify() override;
+
+private:
+	//! The DependencyManager manages dependencies between different catalog objects
+	unique_ptr<DependencyManager> dependency_manager;
+	//! Write lock for the catalog
+	mutex write_lock;
+	//! The catalog set holding the schemas
+	unique_ptr<CatalogSet> schemas;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/mapping_value.hpp

@@ -78,7 +78,8 @@ private:
 };
 
 struct MappingValue {
-	explicit MappingValue(EntryIndex index_p) : index(move(index_p)), timestamp(0), deleted(false), parent(nullptr) {
+	explicit MappingValue(EntryIndex index_p)
+	    : index(std::move(index_p)), timestamp(0), deleted(false), parent(nullptr) {
 	}
 
 	EntryIndex index;

package/src/duckdb/src/include/duckdb/catalog/similar_catalog_entry.hpp

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/similar_catalog_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+class SchemaCatalogEntry;
+
+//! Return value of SimilarEntryInSchemas
+struct SimilarCatalogEntry {
+	//! The entry name. Empty if absent
+	string name;
+	//! The distance to the given name.
+	idx_t distance = idx_t(-1);
+	//! The schema of the entry.
+	SchemaCatalogEntry *schema = nullptr;
+
+	DUCKDB_API bool Found() const {
+		return !name.empty();
+	}
+
+	DUCKDB_API string GetQualifiedName(bool qualify_catalog, bool qualify_schema) const;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/allocator.hpp

@@ -120,7 +120,7 @@ void DeleteArray(T *ptr, idx_t size) {
 }
 
 template <typename T, typename... ARGS>
-T *AllocateObject(ARGS &&...args) {
+T *AllocateObject(ARGS &&... args) {
 	auto data = Allocator::DefaultAllocator().AllocateData(sizeof(T));
 	return new (data) T(std::forward<ARGS>(args)...);
 }

package/src/duckdb/src/include/duckdb/common/assert.hpp

@@ -14,6 +14,10 @@
 
 #include <assert.h>
 #define D_ASSERT assert
+namespace duckdb {
+DUCKDB_API void DuckDBAssertInternal(bool condition, const char *condition_name, const char *file, int linenr);
+}
+
 #else
 namespace duckdb {
 DUCKDB_API void DuckDBAssertInternal(bool condition, const char *condition_name, const char *file, int linenr);

package/src/duckdb/src/include/duckdb/common/bind_helpers.hpp

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/bind_helpers.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+#pragma once
+
+#include "duckdb/common/vector.hpp"
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+
+class Value;
+
+Value ConvertVectorToValue(vector<Value> set);
+vector<bool> ParseColumnList(const vector<Value> &set, vector<string> &names, const string &option_name);
+vector<bool> ParseColumnList(const Value &value, vector<string> &names, const string &option_name);
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/box_renderer.hpp

@@ -22,7 +22,11 @@ enum class ValueRenderAlignment { LEFT, MIDDLE, RIGHT };
 struct BoxRendererConfig {
 	// a max_width of 0 means we default to the terminal width
 	idx_t max_width = 0;
+	// the maximum amount of rows to render
 	idx_t max_rows = 20;
+	// the limit that is applied prior to rendering
+	// if we are rendering exactly "limit" rows then a question mark is rendered instead
+	idx_t limit = 0;
 	// the max col width determines the maximum size of a single column
 	// note that the max col width is only used if the result does not fit on the screen
 	idx_t max_col_width = 20;

package/src/duckdb/src/include/duckdb/common/constants.hpp

@@ -35,7 +35,9 @@ namespace duckdb {
 #endif
 
 //! inline std directives that we use frequently
+#ifndef DUCKDB_DEBUG_MOVE
 using std::move;
+#endif
 using std::shared_ptr;
 using std::unique_ptr;
 using std::weak_ptr;

package/src/duckdb/src/include/duckdb/common/enums/access_mode.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/access_mode.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+enum class AccessMode : uint8_t { UNDEFINED = 0, AUTOMATIC = 1, READ_ONLY = 2, READ_WRITE = 3 };
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp

@@ -143,7 +143,8 @@ enum class ExpressionType : uint8_t {
 	BOUND_UNNEST = 229,
 	COLLATE = 230,
 	LAMBDA = 231,
-	POSITIONAL_REFERENCE = 232
+	POSITIONAL_REFERENCE = 232,
+	BOUND_LAMBDA_REF = 233
 };
 
 //===--------------------------------------------------------------------===//
@@ -192,6 +193,7 @@ enum class ExpressionClass : uint8_t {
 	BOUND_BETWEEN = 39,
 	BOUND_UNNEST = 40,
 	BOUND_LAMBDA = 41,
+	BOUND_LAMBDA_REF = 42,
 	//===--------------------------------------------------------------------===//
 	// Miscellaneous
 	//===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/common/enums/joinref_type.hpp

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/joinref_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Join Reference Types
+//===--------------------------------------------------------------------===//
+enum class JoinRefType : uint8_t {
+	REGULAR,   // Explicit conditions
+	NATURAL,   // Implied conditions
+	CROSS,     // No condition
+	POSITIONAL // Positional condition
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/logical_operator_type.hpp

@@ -48,6 +48,7 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_COMPARISON_JOIN = 52,
 	LOGICAL_ANY_JOIN = 53,
 	LOGICAL_CROSS_PRODUCT = 54,
+	LOGICAL_POSITIONAL_JOIN = 55,
 	// -----------------------------
 	// SetOps
 	// -----------------------------

package/src/duckdb/src/include/duckdb/common/enums/optimizer_type.hpp

@@ -21,6 +21,7 @@ enum class OptimizerType : uint32_t {
 	IN_CLAUSE,
 	JOIN_ORDER,
 	DELIMINATOR,
+	UNNEST_REWRITER,
 	UNUSED_COLUMNS,
 	STATISTICS_PROPAGATION,
 	COMMON_SUBEXPRESSIONS,

package/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp

@@ -43,6 +43,7 @@ enum class PhysicalOperatorType : uint8_t {
 	RECURSIVE_CTE_SCAN,
 	DELIM_SCAN,
 	EXPRESSION_SCAN,
+	POSITIONAL_SCAN,
 	// -----------------------------
 	// Joins
 	// -----------------------------
@@ -54,6 +55,7 @@ enum class PhysicalOperatorType : uint8_t {
 	IE_JOIN,
 	DELIM_JOIN,
 	INDEX_JOIN,
+	POSITIONAL_JOIN,
 	// -----------------------------
 	// SetOps
 	// -----------------------------
@@ -100,7 +102,8 @@ enum class PhysicalOperatorType : uint8_t {
 	LOAD,
 	INOUT_FUNCTION,
 	RESULT_COLLECTOR,
-	RESET
+	RESET,
+	EXTENSION
 };
 
 string PhysicalOperatorToString(PhysicalOperatorType type);

package/src/duckdb/src/include/duckdb/common/enums/relation_type.hpp

@@ -35,6 +35,7 @@ enum class RelationType : uint8_t {
 	DELETE_RELATION,
 	UPDATE_RELATION,
 	WRITE_CSV_RELATION,
+	WRITE_PARQUET_RELATION,
 	READ_CSV_RELATION,
 	SUBQUERY_RELATION,
 	TABLE_FUNCTION_RELATION,

package/src/duckdb/src/include/duckdb/common/enums/tableref_type.hpp

@@ -20,7 +20,6 @@ enum class TableReferenceType : uint8_t {
 	BASE_TABLE = 1,      // base table reference
 	SUBQUERY = 2,        // output of a subquery
 	JOIN = 3,            // output of join
-	CROSS_PRODUCT = 4,   // out of cartesian product
 	TABLE_FUNCTION = 5,  // table producing function
 	EXPRESSION_LIST = 6, // expression list
 	CTE = 7,             // Recursive CTE

package/src/duckdb/src/include/duckdb/common/field_writer.hpp

@@ -271,7 +271,7 @@ public:
 	}
 
 	template <class T, typename... ARGS>
-	unique_ptr<T> ReadOptional(unique_ptr<T> default_value, ARGS &&...args) {
+	unique_ptr<T> ReadOptional(unique_ptr<T> default_value, ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, read the default value
 			return default_value;
@@ -293,7 +293,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&...args) {
+	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, read the default value
 			return default_value;
@@ -315,7 +315,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadRequiredSerializable(ARGS &&...args) {
+	RETURN_TYPE ReadRequiredSerializable(ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, throw an exception
 			throw SerializationException("Attempting to read mandatory field, but field is missing");
@@ -326,7 +326,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	vector<RETURN_TYPE> ReadRequiredSerializableList(ARGS &&...args) {
+	vector<RETURN_TYPE> ReadRequiredSerializableList(ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, throw an exception
 			throw SerializationException("Attempting to read mandatory field, but field is missing");