duckdb 0.7.2-dev1457.0 → 0.7.2-dev1533.0

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

@@ -287,6 +287,19 @@ private:
 	                                                 const unordered_set<SchemaCatalogEntry *> &schemas);
 
 	virtual void DropSchema(ClientContext &context, DropInfo *info) = 0;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
 };
 
 } // namespace duckdb

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

@@ -22,8 +22,8 @@ public:
 	shared_ptr<DataTableInfo> info;
 
 public:
-	string GetSchemaName() override;
-	string GetTableName() override;
+	string GetSchemaName() const override;
+	string GetTableName() const override;
 };
 
 } // namespace duckdb

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

@@ -31,7 +31,7 @@ public:
 	//! Get statistics of a column (physical or virtual) within the table
 	unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id) override;
 
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) override;
+	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
 
 	void SetAsRoot() override;
 

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

@@ -33,12 +33,12 @@ public:
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
 
 public:
-	string ToSQL() override;
-	void Serialize(Serializer &serializer);
+	string ToSQL() const override;
+	void Serialize(Serializer &serializer) const;
 	static unique_ptr<CreateIndexInfo> Deserialize(Deserializer &source, ClientContext &context);
 
-	virtual string GetSchemaName() = 0;
-	virtual string GetTableName() = 0;
+	virtual string GetSchemaName() const = 0;
+	virtual string GetTableName() const = 0;
 };
 
 } // namespace duckdb

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

@@ -19,14 +19,15 @@ namespace duckdb {
 class MacroCatalogEntry : public StandardEntry {
 public:
 	MacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info);
+
 	//! The macro function
 	unique_ptr<MacroFunction> function;
 
 public:
 	//! Serialize the meta information
-	virtual void Serialize(Serializer &serializer) = 0;
+	virtual void Serialize(Serializer &serializer) const = 0;
 
-	string ToSQL() override {
+	string ToSQL() const override {
 		return function->ToSQL(schema->name, name);
 	}
 };

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

@@ -26,7 +26,7 @@ public:
 
 public:
 	//! Serialize the meta information of the ScalarMacroCatalogEntry
-	void Serialize(Serializer &serializer) override;
+	void Serialize(Serializer &serializer) const override;
 	//! Deserializes to a CreateMacroInfo
 	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &source, ClientContext &context);
 };

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

@@ -56,11 +56,11 @@ public:
 	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);
+	virtual void Serialize(Serializer &serializer) const;
 	//! Deserializes to a CreateSchemaInfo
 	static unique_ptr<CreateSchemaInfo> Deserialize(Deserializer &source);
 
-	string ToSQL() override;
+	string ToSQL() const override;
 
 	//! Creates an index with the given name in the schema
 	virtual CatalogEntry *CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table) = 0;

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

@@ -58,11 +58,11 @@ public:
 
 public:
 	//! Serialize the meta information of the SequenceCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer);
+	virtual void Serialize(Serializer &serializer) const;
 	//! Deserializes to a CreateTableInfo
 	static unique_ptr<CreateSequenceInfo> Deserialize(Deserializer &source);
 
-	string ToSQL() override;
+	string ToSQL() const override;
 
 	CatalogEntry *AlterOwnership(ClientContext &context, AlterInfo *info);
 };

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

@@ -75,13 +75,13 @@ public:
 
 	//! Returns a list of the constraints of the table
 	DUCKDB_API const vector<unique_ptr<Constraint>> &GetConstraints();
-	DUCKDB_API string ToSQL() override;
+	DUCKDB_API string ToSQL() const override;
 
 	//! Get statistics of a column (physical or virtual) within the table
 	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);
+	virtual void Serialize(Serializer &serializer) const;
 	//! Deserializes to a CreateTableInfo
 	static unique_ptr<CreateTableInfo> Deserialize(Deserializer &source, ClientContext &context);
 

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

@@ -25,7 +25,7 @@ public:
 
 public:
 	//! Serialize the meta information of the ScalarMacroCatalogEntry
-	void Serialize(Serializer &serializer) override;
+	void Serialize(Serializer &serializer) const override;
 	//! Deserializes to a CreateMacroInfo
 	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &source, ClientContext &context);
 };

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

@@ -30,10 +30,10 @@ public:
 
 public:
 	//! Serialize the meta information of the TypeCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer);
+	virtual void Serialize(Serializer &serializer) const;
 	//! Deserializes to a TypeCatalogEntry
 	static unique_ptr<CreateTypeInfo> Deserialize(Deserializer &source);
 
-	string ToSQL() override;
+	string ToSQL() const override;
 };
 } // namespace duckdb

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

@@ -41,13 +41,13 @@ public:
 	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
 
 	//! Serialize the meta information of the ViewCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer);
+	virtual void Serialize(Serializer &serializer) const;
 	//! Deserializes to a CreateTableInfo
 	static unique_ptr<CreateViewInfo> Deserialize(Deserializer &source, ClientContext &context);
 
-	unique_ptr<CatalogEntry> Copy(ClientContext &context) override;
+	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
 
-	string ToSQL() override;
+	string ToSQL() const override;
 
 private:
 	void Initialize(CreateViewInfo *info);

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

@@ -12,7 +12,6 @@
 #include "duckdb/common/enums/catalog_type.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/atomic.hpp"
-
 #include <memory>
 
 namespace duckdb {
@@ -54,15 +53,27 @@ public:
 	virtual unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info);
 	virtual void UndoAlter(ClientContext &context, AlterInfo *info);
 
-	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context);
+	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context) const;
 
 	//! Sets the CatalogEntry as the new root entry (i.e. the newest entry)
 	// this is called on a rollback to an AlterEntry
 	virtual void SetAsRoot();
 
 	//! Convert the catalog entry to a SQL string that can be used to re-construct the catalog entry
-	virtual string ToSQL();
+	virtual string ToSQL() const;
 
 	virtual void Verify(Catalog &catalog);
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
 };
 } // namespace duckdb

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

@@ -102,7 +102,7 @@ public:
 
 	//! Rollback <entry> to be the currently valid entry for a certain catalog
 	//! entry
-	void Undo(CatalogEntry *entry);
+	void Undo(CatalogEntry &entry);
 
 	//! Scan the catalog set, invoking the callback method for every committed entry
 	DUCKDB_API void Scan(const std::function<void(CatalogEntry *)> &callback);
@@ -120,17 +120,17 @@ public:
 	DUCKDB_API bool HasConflict(CatalogTransaction transaction, transaction_t timestamp);
 	DUCKDB_API bool UseTimestamp(CatalogTransaction transaction, transaction_t timestamp);
 
-	void UpdateTimestamp(CatalogEntry *entry, transaction_t timestamp);
+	void UpdateTimestamp(CatalogEntry &entry, transaction_t timestamp);
 
 	void Verify(Catalog &catalog);
 
 private:
 	//! Adjusts table dependencies on the event of an UNDO
-	void AdjustTableDependencies(CatalogEntry *entry);
+	void AdjustTableDependencies(CatalogEntry &entry);
 	//! Adjust one dependency
-	void AdjustDependency(CatalogEntry *entry, TableCatalogEntry *table, ColumnDefinition &column, bool remove);
+	void AdjustDependency(CatalogEntry &entry, TableCatalogEntry &table, ColumnDefinition &column, bool remove);
 	//! Adjust User dependency
-	void AdjustUserDependency(CatalogEntry *entry, ColumnDefinition &column, bool remove);
+	void AdjustUserDependency(CatalogEntry &entry, ColumnDefinition &column, bool remove);
 	//! Given a root entry, gets the entry valid for this transaction
 	CatalogEntry *GetEntryForTransaction(CatalogTransaction transaction, CatalogEntry *current);
 	CatalogEntry *GetCommittedEntry(CatalogEntry *current);

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

@@ -17,14 +17,13 @@ namespace duckdb {
 
 struct CaseInsensitiveStringHashFunction {
 	uint64_t operator()(const string &str) const {
-		std::hash<string> hasher;
-		return hasher(StringUtil::Lower(str));
+		return StringUtil::CIHash(str);
 	}
 };
 
 struct CaseInsensitiveStringEquality {
 	bool operator()(const string &a, const string &b) const {
-		return StringUtil::Lower(a) == StringUtil::Lower(b);
+		return StringUtil::CIEquals(a, b);
 	}
 };
 

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

@@ -29,6 +29,7 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_DISTINCT = 11,
 	LOGICAL_SAMPLE = 12,
 	LOGICAL_LIMIT_PERCENT = 13,
+	LOGICAL_PIVOT = 14,
 
 	// -----------------------------
 	// Data sources

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

@@ -33,6 +33,8 @@ enum class PhysicalOperatorType : uint8_t {
 	RESERVOIR_SAMPLE,
 	STREAMING_SAMPLE,
 	STREAMING_WINDOW,
+	PIVOT,
+
 	// -----------------------------
 	// Scans
 	// -----------------------------

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

@@ -22,7 +22,7 @@ struct MultiFileReaderOptions {
 
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	DUCKDB_API static MultiFileReaderOptions Deserialize(Deserializer &source);
-	DUCKDB_API void AddBatchInfo(BindInfo &bind_info);
+	DUCKDB_API void AddBatchInfo(BindInfo &bind_info) const;
 };
 
 } // namespace duckdb

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

@@ -138,6 +138,9 @@ public:
 	//! Convert a string to lowercase
 	DUCKDB_API static string Lower(const string &str);
 
+	//! Case insensitive hash
+	DUCKDB_API static uint64_t CIHash(const string &str);
+
 	//! Case insensitive equals
 	DUCKDB_API static bool CIEquals(const string &l1, const string &l2);
 

package/src/duckdb/src/include/duckdb/execution/index/art/art.hpp

@@ -84,7 +84,7 @@ public:
 
 	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
 	//! index must also be locked during the merge
-	bool MergeIndexes(IndexLock &state, Index *other_index) override;
+	bool MergeIndexes(IndexLock &state, Index &other_index) override;
 
 	//! Generate ART keys for an input chunk
 	static void GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector<Key> &keys);

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp

@@ -57,6 +57,9 @@ public:
 //! PhysicalHashAggregate is a group-by and aggregate implementation that uses a hash table to perform the grouping
 //! This only contains read-only variables, anything that is stateful instead gets stored in the Global/Local states
 class PhysicalHashAggregate : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::HASH_GROUP_BY;
+
 public:
 	PhysicalHashAggregate(ClientContext &context, vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
 	                      idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_perfecthash_aggregate.hpp

@@ -17,6 +17,9 @@ class PerfectAggregateHashTable;
 
 //! PhysicalPerfectHashAggregate performs a group-by and aggregation using a perfect hash table
 class PhysicalPerfectHashAggregate : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PERFECT_HASH_GROUP_BY;
+
 public:
 	PhysicalPerfectHashAggregate(ClientContext &context, vector<LogicalType> types,
 	                             vector<unique_ptr<Expression>> aggregates, vector<unique_ptr<Expression>> groups,

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_streaming_window.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalStreamingWindow implements streaming window functions (i.e. with an empty OVER clause)
 class PhysicalStreamingWindow : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::STREAMING_WINDOW;
+
 public:
 	PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
 	                        idx_t estimated_cardinality,

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_ungrouped_aggregate.hpp

@@ -21,6 +21,9 @@ namespace duckdb {
 //! PhysicalUngroupedAggregate is an aggregate operator that can only perform aggregates (1) without any groups, (2)
 //! without any DISTINCT aggregates, and (3) when all aggregates are combineable
 class PhysicalUngroupedAggregate : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::UNGROUPED_AGGREGATE;
+
 public:
 	PhysicalUngroupedAggregate(vector<LogicalType> types, vector<unique_ptr<Expression>> expressions,
 	                           idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_window.hpp

@@ -17,6 +17,9 @@ namespace duckdb {
 //! PhysicalWindow implements window functions
 //! It assumes that all functions have a common partitioning and ordering
 class PhysicalWindow : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::WINDOW;
+
 public:
 	PhysicalWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality,
 	               PhysicalOperatorType type = PhysicalOperatorType::WINDOW);

package/src/duckdb/src/include/duckdb/execution/operator/filter/physical_filter.hpp

@@ -17,6 +17,9 @@ namespace duckdb {
 //! from the result. Note that it does not physically change the data, it only
 //! adds a selection vector to the chunk.
 class PhysicalFilter : public CachingPhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::FILTER;
+
 public:
 	PhysicalFilter(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality);
 

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_execute.hpp

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class PhysicalExecute : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EXECUTE;
+
 public:
 	explicit PhysicalExecute(PhysicalOperator *plan);
 

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_explain_analyze.hpp

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class PhysicalExplainAnalyze : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::EXPLAIN_ANALYZE;
+
 public:
 	PhysicalExplainAnalyze(vector<LogicalType> types)
 	    : PhysicalOperator(PhysicalOperatorType::EXPLAIN_ANALYZE, std::move(types), 1) {

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_limit.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhyisicalLimit represents the LIMIT operator
 class PhysicalLimit : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::LIMIT;
+
 public:
 	PhysicalLimit(vector<LogicalType> types, idx_t limit, idx_t offset, unique_ptr<Expression> limit_expression,
 	              unique_ptr<Expression> offset_expression, idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_limit_percent.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhyisicalLimitPercent represents the LIMIT PERCENT operator
 class PhysicalLimitPercent : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::LIMIT_PERCENT;
+
 public:
 	PhysicalLimitPercent(vector<LogicalType> types, double limit_percent, idx_t offset,
 	                     unique_ptr<Expression> limit_expression, unique_ptr<Expression> offset_expression,

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_load.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalLoad represents an extension LOAD operation
 class PhysicalLoad : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::LOAD;
+
 public:
 	explicit PhysicalLoad(unique_ptr<LoadInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::LOAD, {LogicalType::BOOLEAN}, estimated_cardinality),

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_pragma.hpp

@@ -16,6 +16,9 @@ namespace duckdb {
 
 //! PhysicalPragma represents the PRAGMA operator
 class PhysicalPragma : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PRAGMA;
+
 public:
 	PhysicalPragma(PragmaFunction function_p, PragmaInfo info_p, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::PRAGMA, {LogicalType::BOOLEAN}, estimated_cardinality),

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_prepare.hpp

@@ -15,6 +15,9 @@
 namespace duckdb {
 
 class PhysicalPrepare : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PREPARE;
+
 public:
 	PhysicalPrepare(string name, shared_ptr<PreparedStatementData> prepared, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::PREPARE, {LogicalType::BOOLEAN}, estimated_cardinality), name(name),

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_reset.hpp

@@ -19,6 +19,9 @@ struct ExtensionOption;
 
 //! PhysicalReset represents a RESET operation (e.g. RESET a = 42)
 class PhysicalReset : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::RESET;
+
 public:
 	PhysicalReset(const std::string &name_p, SetScope scope_p, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::RESET, {LogicalType::BOOLEAN}, estimated_cardinality), name(name_p),

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set.hpp

@@ -19,6 +19,9 @@ struct ExtensionOption;
 
 //! PhysicalSet represents a SET operation (e.g. SET a = 42)
 class PhysicalSet : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::SET;
+
 public:
 	PhysicalSet(const std::string &name_p, Value value_p, SetScope scope_p, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::SET, {LogicalType::BOOLEAN}, estimated_cardinality), name(name_p),

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_streaming_limit.hpp

@@ -14,6 +14,9 @@
 namespace duckdb {
 
 class PhysicalStreamingLimit : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::STREAMING_LIMIT;
+
 public:
 	PhysicalStreamingLimit(vector<LogicalType> types, idx_t limit, idx_t offset,
 	                       unique_ptr<Expression> limit_expression, unique_ptr<Expression> offset_expression,

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_streaming_sample.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalStreamingSample represents a streaming sample using either system or bernoulli sampling
 class PhysicalStreamingSample : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::STREAMING_SAMPLE;
+
 public:
 	PhysicalStreamingSample(vector<LogicalType> types, SampleMethod method, double percentage, int64_t seed,
 	                        idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_transaction.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalTransaction represents a transaction operator (e.g. BEGIN or COMMIT)
 class PhysicalTransaction : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::TRANSACTION;
+
 public:
 	explicit PhysicalTransaction(unique_ptr<TransactionInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::TRANSACTION, {LogicalType::BOOLEAN}, estimated_cardinality),

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_vacuum.hpp

@@ -16,6 +16,9 @@ namespace duckdb {
 
 //! PhysicalVacuum represents a VACUUM operation (i.e. VACUUM or ANALYZE)
 class PhysicalVacuum : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::VACUUM;
+
 public:
 	PhysicalVacuum(unique_ptr<VacuumInfo> info, idx_t estimated_cardinality);
 

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_blockwise_nl_join.hpp

@@ -17,6 +17,9 @@ namespace duckdb {
 //! from the PhysicalNestedLoopJoin in that it does not require expressions to be comparisons between the LHS and the
 //! RHS.
 class PhysicalBlockwiseNLJoin : public PhysicalJoin {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::BLOCKWISE_NL_JOIN;
+
 public:
 	PhysicalBlockwiseNLJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
 	                        unique_ptr<Expression> condition, JoinType join_type, idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_cross_product.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalCrossProduct represents a cross product between two tables
 class PhysicalCrossProduct : public CachingPhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CROSS_PRODUCT;
+
 public:
 	PhysicalCrossProduct(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
 	                     unique_ptr<PhysicalOperator> right, idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_delim_join.hpp

@@ -17,6 +17,9 @@ class PhysicalHashAggregate;
 //! PhysicalDelimJoin represents a join where the LHS will be duplicate eliminated and pushed into a
 //! PhysicalColumnDataScan in the RHS.
 class PhysicalDelimJoin : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::DELIM_JOIN;
+
 public:
 	PhysicalDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
 	                  vector<PhysicalOperator *> delim_scans, idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_hash_join.hpp

@@ -20,6 +20,9 @@ namespace duckdb {
 
 //! PhysicalHashJoin represents a hash loop join between two tables
 class PhysicalHashJoin : public PhysicalComparisonJoin {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::HASH_JOIN;
+
 public:
 	PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
 	                 vector<JoinCondition> cond, JoinType join_type, const vector<idx_t> &left_projection_map,

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_iejoin.hpp

@@ -16,6 +16,9 @@ namespace duckdb {
 //! PhysicalIEJoin represents a two inequality range join between
 //! two tables
 class PhysicalIEJoin : public PhysicalRangeJoin {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::IE_JOIN;
+
 public:
 	PhysicalIEJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
 	               vector<JoinCondition> cond, JoinType join_type, idx_t estimated_cardinality);

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_index_join.hpp

@@ -18,6 +18,9 @@ namespace duckdb {
 
 //! PhysicalIndexJoin represents an index join between two tables
 class PhysicalIndexJoin : public CachingPhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::INDEX_JOIN;
+
 public:
 	PhysicalIndexJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
 	                  vector<JoinCondition> cond, JoinType join_type, const vector<idx_t> &left_projection_map,

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_join.hpp

@@ -15,6 +15,9 @@ namespace duckdb {
 
 //! PhysicalJoin represents the base class of the join operators
 class PhysicalJoin : public CachingPhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::INVALID;
+
 public:
 	PhysicalJoin(LogicalOperator &op, PhysicalOperatorType type, JoinType join_type, idx_t estimated_cardinality);
 

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_nested_loop_join.hpp

@@ -12,13 +12,12 @@
 #include "duckdb/execution/operator/join/physical_comparison_join.hpp"
 
 namespace duckdb {
-idx_t nested_loop_join(ExpressionType op, Vector &left, Vector &right, idx_t &lpos, idx_t &rpos, sel_t lvector[],
-                       sel_t rvector[]);
-idx_t nested_loop_comparison(ExpressionType op, Vector &left, Vector &right, sel_t lvector[], sel_t rvector[],
-                             idx_t count);
 
 //! PhysicalNestedLoopJoin represents a nested loop join between two tables
 class PhysicalNestedLoopJoin : public PhysicalComparisonJoin {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::NESTED_LOOP_JOIN;
+
 public:
 	PhysicalNestedLoopJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
 	                       vector<JoinCondition> cond, JoinType join_type, idx_t estimated_cardinality);