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

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp

@@ -12,16 +12,22 @@
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 #include "duckdb/common/index_vector.hpp"
+#include "duckdb/parser/statement/insert_statement.hpp"
 
 namespace duckdb {
 
+class InsertLocalState;
+
 //! Physically insert a set of data into a table
 class PhysicalInsert : public PhysicalOperator {
 public:
 	//! INSERT INTO
 	PhysicalInsert(vector<LogicalType> types, TableCatalogEntry *table, physical_index_vector_t<idx_t> column_index_map,
-	               vector<unique_ptr<Expression>> bound_defaults, idx_t estimated_cardinality, bool return_chunk,
-	               bool parallel);
+	               vector<unique_ptr<Expression>> bound_defaults, vector<unique_ptr<Expression>> set_expressions,
+	               vector<PhysicalIndex> set_columns, vector<LogicalType> set_types, idx_t estimated_cardinality,
+	               bool return_chunk, bool parallel, OnConflictAction action_type,
+	               unique_ptr<Expression> on_conflict_condition, unique_ptr<Expression> do_update_condition,
+	               unordered_set<column_t> on_conflict_filter, vector<column_t> columns_to_fetch);
 	//! CREATE TABLE AS
 	PhysicalInsert(LogicalOperator &op, SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info,
 	               idx_t estimated_cardinality, bool parallel);
@@ -43,6 +49,27 @@ public:
 	//! Whether or not the INSERT can be executed in parallel
 	//! This insert is not order preserving if executed in parallel
 	bool parallel;
+	// Which action to perform on conflict
+	OnConflictAction action_type;
+
+	// The DO UPDATE set expressions, if 'action_type' is UPDATE
+	vector<unique_ptr<Expression>> set_expressions;
+	// Which columns are targeted by the set expressions
+	vector<PhysicalIndex> set_columns;
+	// The types of the columns targeted by a SET expression
+	vector<LogicalType> set_types;
+
+	// Condition for the ON CONFLICT clause
+	unique_ptr<Expression> on_conflict_condition;
+	// Condition for the DO UPDATE clause
+	unique_ptr<Expression> do_update_condition;
+	// The column ids to apply the ON CONFLICT on
+	unordered_set<column_t> conflict_target;
+
+	// Column ids from the original table to fetch
+	vector<column_t> columns_to_fetch;
+	// Matching types to the column ids to fetch
+	vector<LogicalType> types_to_fetch;
 
 public:
 	// Source interface
@@ -74,6 +101,14 @@ public:
 	static void ResolveDefaults(TableCatalogEntry *table, DataChunk &chunk,
 	                            const physical_index_vector_t<idx_t> &column_index_map,
 	                            ExpressionExecutor &defaults_executor, DataChunk &result);
+
+protected:
+	void CombineExistingAndInsertTuples(DataChunk &result, DataChunk &scan_chunk, DataChunk &input_chunk,
+	                                    ClientContext &client) const;
+	void OnConflictHandling(TableCatalogEntry *table, ExecutionContext &context, InsertLocalState &lstate) const;
+	void PerformOnConflictAction(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry *table,
+	                             Vector &row_ids) const;
+	void RegisterUpdatedRows(InsertLocalState &lstate, const Vector &row_ids, idx_t count) const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/projection/physical_unnest.hpp

@@ -14,13 +14,14 @@
 
 namespace duckdb {
 
-//! PhysicalWindow implements window functions
+//! PhysicalUnnest implements the physical UNNEST operation
 class PhysicalUnnest : public PhysicalOperator {
 public:
 	PhysicalUnnest(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality,
 	               PhysicalOperatorType type = PhysicalOperatorType::UNNEST);
 
 	//! The projection list of the UNNEST
+	//! E.g. SELECT 1, UNNEST([1]), UNNEST([2, 3]); has two UNNESTs in its select_list
 	vector<unique_ptr<Expression>> select_list;
 
 public:
@@ -35,6 +36,9 @@ public:
 public:
 	static unique_ptr<OperatorState> GetState(ExecutionContext &context,
 	                                          const vector<unique_ptr<Expression>> &select_list);
+	//! Executes the UNNEST operator internally and emits a chunk of unnested data. If include_input is set, then
+	//! the resulting chunk also contains vectors for all non-UNNEST columns in the projection. If include_input is
+	//! not set, then the UNNEST behaves as a table function and only emits the unnested data.
 	static OperatorResultType ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
 	                                          OperatorState &state, const vector<unique_ptr<Expression>> &select_list,
 	                                          bool include_input = true);

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_column_data_scan.hpp

@@ -17,7 +17,7 @@ namespace duckdb {
 class PhysicalColumnDataScan : public PhysicalOperator {
 public:
 	PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type, idx_t estimated_cardinality)
-	    : PhysicalOperator(op_type, move(types), estimated_cardinality), collection(nullptr) {
+	    : PhysicalOperator(op_type, std::move(types), estimated_cardinality), collection(nullptr) {
 	}
 
 	// the column data collection to scan

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_dummy_scan.hpp

@@ -15,7 +15,7 @@ namespace duckdb {
 class PhysicalDummyScan : public PhysicalOperator {
 public:
 	explicit PhysicalDummyScan(vector<LogicalType> types, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::DUMMY_SCAN, move(types), estimated_cardinality) {
+	    : PhysicalOperator(PhysicalOperatorType::DUMMY_SCAN, std::move(types), estimated_cardinality) {
 	}
 
 public:

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_empty_result.hpp

@@ -15,7 +15,7 @@ namespace duckdb {
 class PhysicalEmptyResult : public PhysicalOperator {
 public:
 	explicit PhysicalEmptyResult(vector<LogicalType> types, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::EMPTY_RESULT, move(types), estimated_cardinality) {
+	    : PhysicalOperator(PhysicalOperatorType::EMPTY_RESULT, std::move(types), estimated_cardinality) {
 	}
 
 public:

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_expression_scan.hpp

@@ -19,8 +19,8 @@ class PhysicalExpressionScan : public PhysicalOperator {
 public:
 	PhysicalExpressionScan(vector<LogicalType> types, vector<vector<unique_ptr<Expression>>> expressions,
 	                       idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::EXPRESSION_SCAN, move(types), estimated_cardinality),
-	      expressions(move(expressions)) {
+	    : PhysicalOperator(PhysicalOperatorType::EXPRESSION_SCAN, std::move(types), estimated_cardinality),
+	      expressions(std::move(expressions)) {
 	}
 
 	//! The set of expressions to scan

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_positional_scan.hpp

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/scan/physical_positional_scan.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/function/table_function.hpp"
+#include "duckdb/planner/table_filter.hpp"
+#include "duckdb/storage/data_table.hpp"
+
+namespace duckdb {
+
+//! Represents a scan of a base table
+class PhysicalPositionalScan : public PhysicalOperator {
+public:
+	//! Regular Table Scan
+	PhysicalPositionalScan(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
+	                       unique_ptr<PhysicalOperator> right);
+
+	//! The child table functions
+	vector<unique_ptr<PhysicalOperator>> child_tables;
+
+public:
+	bool Equals(const PhysicalOperator &other) const override;
+
+public:
+	unique_ptr<LocalSourceState> GetLocalSourceState(ExecutionContext &context,
+	                                                 GlobalSourceState &gstate) const override;
+	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
+	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+	             LocalSourceState &lstate) const override;
+
+	double GetProgress(ClientContext &context, GlobalSourceState &gstate) const override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_alter.hpp

@@ -18,7 +18,7 @@ class PhysicalAlter : public PhysicalOperator {
 public:
 	explicit PhysicalAlter(unique_ptr<AlterInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::ALTER, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(move(info)) {
+	      info(std::move(info)) {
 	}
 
 	unique_ptr<AlterInfo> info;

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_attach.hpp

@@ -18,7 +18,7 @@ class PhysicalAttach : public PhysicalOperator {
 public:
 	explicit PhysicalAttach(unique_ptr<AttachInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::ATTACH, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(move(info)) {
+	      info(std::move(info)) {
 	}
 
 	unique_ptr<AttachInfo> info;

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_function.hpp

@@ -18,7 +18,7 @@ class PhysicalCreateFunction : public PhysicalOperator {
 public:
 	explicit PhysicalCreateFunction(unique_ptr<CreateMacroInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::CREATE_MACRO, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(move(info)) {
+	      info(std::move(info)) {
 	}
 
 	unique_ptr<CreateMacroInfo> info;

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_index.hpp

@@ -17,41 +17,33 @@
 #include <fstream>
 
 namespace duckdb {
+class DuckTableEntry;
 
-//! Physically CREATE INDEX statement
+//! Physical CREATE (UNIQUE) INDEX statement
 class PhysicalCreateIndex : public PhysicalOperator {
 public:
-	PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry &table, vector<column_t> column_ids,
-	                    vector<unique_ptr<Expression>> expressions, unique_ptr<CreateIndexInfo> info,
-	                    vector<unique_ptr<Expression>> unbound_expressions, idx_t estimated_cardinality)
-	    : PhysicalOperator(PhysicalOperatorType::CREATE_INDEX, op.types, estimated_cardinality), table(table),
-	      expressions(move(expressions)), info(std::move(info)), unbound_expressions(move(unbound_expressions)) {
-
-		// convert virtual column ids to storage column ids
-		for (auto &column_id : column_ids) {
-			storage_ids.push_back(table.columns.LogicalToPhysical(LogicalIndex(column_id)).index);
-		}
-	}
+	PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry &table, const vector<column_t> &column_ids,
+	                    unique_ptr<CreateIndexInfo> info, vector<unique_ptr<Expression>> unbound_expressions,
+	                    idx_t estimated_cardinality);
 
 	//! The table to create the index for
-	TableCatalogEntry &table;
+	DuckTableEntry &table;
 	//! The list of column IDs required for the index
 	vector<column_t> storage_ids;
-	//! Set of expressions to index by
-	vector<unique_ptr<Expression>> expressions;
 	//! Info for index creation
 	unique_ptr<CreateIndexInfo> info;
 	//! Unbound expressions to be used in the optimizer
 	vector<unique_ptr<Expression>> unbound_expressions;
 
 public:
-	// Source interface
+	//! Source interface, NOP for this operator
 	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
 	             LocalSourceState &lstate) const override;
 
 public:
-	// Sink interface
+	//! Sink interface, thread-local sink states
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
+	//! Sink interface, global sink state
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 
 	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_schema.hpp

@@ -18,7 +18,7 @@ class PhysicalCreateSchema : public PhysicalOperator {
 public:
 	explicit PhysicalCreateSchema(unique_ptr<CreateSchemaInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::CREATE_SCHEMA, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(move(info)) {
+	      info(std::move(info)) {
 	}
 
 	unique_ptr<CreateSchemaInfo> info;

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_sequence.hpp

@@ -18,7 +18,7 @@ class PhysicalCreateSequence : public PhysicalOperator {
 public:
 	explicit PhysicalCreateSequence(unique_ptr<CreateSequenceInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::CREATE_SEQUENCE, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(move(info)) {
+	      info(std::move(info)) {
 	}
 
 	unique_ptr<CreateSequenceInfo> info;

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_view.hpp

@@ -18,7 +18,7 @@ class PhysicalCreateView : public PhysicalOperator {
 public:
 	explicit PhysicalCreateView(unique_ptr<CreateViewInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::CREATE_VIEW, {LogicalType::BIGINT}, estimated_cardinality),
-	      info(move(info)) {
+	      info(std::move(info)) {
 	}
 
 	unique_ptr<CreateViewInfo> info;

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_drop.hpp

@@ -18,7 +18,7 @@ class PhysicalDrop : public PhysicalOperator {
 public:
 	explicit PhysicalDrop(unique_ptr<DropInfo> info, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::DROP, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(move(info)) {
+	      info(std::move(info)) {
 	}
 
 	unique_ptr<DropInfo> info;

package/src/duckdb/src/include/duckdb/execution/physical_plan_generator.hpp

@@ -68,6 +68,7 @@ protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalLimitPercent &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalOrder &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalTopN &op);
+	unique_ptr<PhysicalOperator> CreatePlan(LogicalPositionalJoin &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalProjection &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalInsert &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCopyToFile &op);

package/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp

@@ -12,7 +12,9 @@
 #include "duckdb/common/types/vector.hpp"
 
 namespace duckdb {
+
 class CastFunctionSet;
+struct FunctionLocalState;
 
 //! Extra data that can be attached to a bind function of a cast, and is available during binding
 struct BindCastInfo {
@@ -29,8 +31,8 @@ struct BoundCastData {
 struct CastParameters {
 	CastParameters() {
 	}
-	CastParameters(BoundCastData *cast_data, bool strict, string *error_message)
-	    : cast_data(cast_data), strict(strict), error_message(error_message) {
+	CastParameters(BoundCastData *cast_data, bool strict, string *error_message, FunctionLocalState *local_state)
+	    : cast_data(cast_data), strict(strict), error_message(error_message), local_state(local_state) {
 	}
 	CastParameters(CastParameters &parent, BoundCastData *cast_data = nullptr)
 	    : cast_data(cast_data), strict(parent.strict), error_message(parent.error_message) {
@@ -42,16 +44,20 @@ struct CastParameters {
 	bool strict = false;
 	// out: error message in case cast has failed
 	string *error_message = nullptr;
+	//! Local state
+	FunctionLocalState *local_state = nullptr;
 };
 
 typedef bool (*cast_function_t)(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+typedef unique_ptr<FunctionLocalState> (*init_cast_local_state_t)(ClientContext &context);
 
 struct BoundCastInfo {
 	DUCKDB_API
-	BoundCastInfo(cast_function_t function,
-	              unique_ptr<BoundCastData> cast_data = nullptr); // NOLINT: allow explicit cast from cast_function_t
-
+	BoundCastInfo(
+	    cast_function_t function, unique_ptr<BoundCastData> cast_data = nullptr,
+	    init_cast_local_state_t init_local_state = nullptr); // NOLINT: allow explicit cast from cast_function_t
 	cast_function_t function;
+	init_cast_local_state_t init_local_state;
 	unique_ptr<BoundCastData> cast_data;
 
 public:
@@ -70,7 +76,7 @@ public:
 };
 
 struct ListBoundCastData : public BoundCastData {
-	explicit ListBoundCastData(BoundCastInfo child_cast) : child_cast_info(move(child_cast)) {
+	explicit ListBoundCastData(BoundCastInfo child_cast) : child_cast_info(std::move(child_cast)) {
 	}
 
 	BoundCastInfo child_cast_info;
@@ -89,7 +95,7 @@ struct ListCast {
 
 struct StructBoundCastData : public BoundCastData {
 	StructBoundCastData(vector<BoundCastInfo> child_casts, LogicalType target_p)
-	    : child_cast_info(move(child_casts)), target(move(target_p)) {
+	    : child_cast_info(std::move(child_casts)), target(std::move(target_p)) {
 	}
 
 	vector<BoundCastInfo> child_cast_info;
@@ -104,20 +110,38 @@ public:
 		for (auto &info : child_cast_info) {
 			copy_info.push_back(info.Copy());
 		}
-		return make_unique<StructBoundCastData>(move(copy_info), target);
+		return make_unique<StructBoundCastData>(std::move(copy_info), target);
+	}
+};
+
+struct MapBoundCastData : public BoundCastData {
+	MapBoundCastData(BoundCastInfo key_cast, BoundCastInfo value_cast)
+	    : key_cast(std::move(key_cast)), value_cast(std::move(value_cast)) {
+	}
+
+	BoundCastInfo key_cast;
+	BoundCastInfo value_cast;
+
+	static unique_ptr<BoundCastData> BindMapToMapCast(BindCastInput &input, const LogicalType &source,
+	                                                  const LogicalType &target);
+
+public:
+	unique_ptr<BoundCastData> Copy() const override {
+		return make_unique<MapBoundCastData>(key_cast.Copy(), value_cast.Copy());
 	}
 };
 
 struct DefaultCasts {
-	static BoundCastInfo GetDefaultCastFunction(BindCastInput &input, const LogicalType &source,
-	                                            const LogicalType &target);
+	DUCKDB_API static BoundCastInfo GetDefaultCastFunction(BindCastInput &input, const LogicalType &source,
+	                                                       const LogicalType &target);
 
-	static bool NopCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
-	static bool TryVectorNullCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
-	static bool ReinterpretCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+	DUCKDB_API static bool NopCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+	DUCKDB_API static bool TryVectorNullCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+	DUCKDB_API static bool ReinterpretCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
 
 private:
 	static BoundCastInfo BlobCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+	static BoundCastInfo BitCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo DateCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo DecimalCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);
 	static BoundCastInfo EnumCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target);

package/src/duckdb/src/include/duckdb/function/cast/vector_cast_helpers.hpp

@@ -199,8 +199,8 @@ struct VectorCastHelpers {
 };
 
 struct VectorStringToList {
-	static idx_t CountParts(const string_t &input);
-	static bool SplitStringifiedList(const string_t &input, string_t *child_data, idx_t &child_start, Vector &child);
+	static idx_t CountPartsList(const string_t &input);
+	static bool SplitStringList(const string_t &input, string_t *child_data, idx_t &child_start, Vector &child);
 	static bool StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
 	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
 	                                       const SelectionVector *sel);
@@ -214,4 +214,13 @@ struct VectorStringToStruct {
 	                                       const SelectionVector *sel);
 };
 
+struct VectorStringToMap {
+	static idx_t CountPartsMap(const string_t &input);
+	static bool SplitStringMap(const string_t &input, string_t *child_key_data, string_t *child_val_data,
+	                           idx_t &child_start, Vector &varchar_key, Vector &varchar_val);
+	static bool StringToNestedTypeCastLoop(string_t *source_data, ValidityMask &source_mask, Vector &result,
+	                                       ValidityMask &result_mask, idx_t count, CastParameters &parameters,
+	                                       const SelectionVector *sel);
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/compression_function.hpp

@@ -42,7 +42,7 @@ struct CompressedSegmentState {
 };
 
 struct CompressionAppendState {
-	CompressionAppendState(BufferHandle handle_p) : handle(move(handle_p)) {
+	CompressionAppendState(BufferHandle handle_p) : handle(std::move(handle_p)) {
 	}
 	virtual ~CompressionAppendState() {
 	}

package/src/duckdb/src/include/duckdb/function/copy_function.hpp

@@ -11,8 +11,12 @@
 #include "duckdb/function/function.hpp"
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/parser/parsed_data/copy_info.hpp"
+#include "duckdb/parser/statement/copy_statement.hpp"
 
 namespace duckdb {
+
+class Binder;
+struct BoundStatement;
 class ExecutionContext;
 
 struct LocalFunctionData {
@@ -25,6 +29,7 @@ struct GlobalFunctionData {
 	}
 };
 
+typedef BoundStatement (*copy_to_plan_t)(Binder &binder, CopyStatement &stmt);
 typedef unique_ptr<FunctionData> (*copy_to_bind_t)(ClientContext &context, CopyInfo &info, vector<string> &names,
                                                    vector<LogicalType> &sql_types);
 typedef unique_ptr<LocalFunctionData> (*copy_to_initialize_local_t)(ExecutionContext &context, FunctionData &bind_data);
@@ -49,11 +54,15 @@ typedef bool (*copy_to_is_parallel_t)(ClientContext &context, FunctionData &bind
 class CopyFunction : public Function {
 public:
 	explicit CopyFunction(string name)
-	    : Function(name), copy_to_bind(nullptr), copy_to_initialize_local(nullptr), copy_to_initialize_global(nullptr),
-	      copy_to_sink(nullptr), copy_to_combine(nullptr), copy_to_finalize(nullptr), parallel(nullptr),
-	      serialize(nullptr), deserialize(nullptr), copy_from_bind(nullptr) {
+	    : Function(name), plan(nullptr), copy_to_bind(nullptr), copy_to_initialize_local(nullptr),
+	      copy_to_initialize_global(nullptr), copy_to_sink(nullptr), copy_to_combine(nullptr),
+	      copy_to_finalize(nullptr), parallel(nullptr), serialize(nullptr), deserialize(nullptr),
+	      copy_from_bind(nullptr) {
 	}
 
+	//! Plan rewrite copy function
+	copy_to_plan_t plan;
+
 	copy_to_bind_t copy_to_bind;
 	copy_to_initialize_local_t copy_to_initialize_local;
 	copy_to_initialize_global_t copy_to_initialize_global;

package/src/duckdb/src/include/duckdb/function/create_database_extension.hpp

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/create_database_extension.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+
+class ClientContext;
+class TableFunctionRef;
+
+struct CreateDatabaseExtensionData {
+	virtual ~CreateDatabaseExtensionData() {
+	}
+};
+
+typedef unique_ptr<TableFunctionRef> (*create_database_t)(ClientContext &context, const string &extension_name,
+                                                          const string &database_name, const string &source_path,
+                                                          CreateDatabaseExtensionData *data);
+
+struct CreateDatabaseExtension {
+	explicit CreateDatabaseExtension(create_database_t function,
+	                                 unique_ptr<CreateDatabaseExtensionData> data_p = nullptr)
+	    : function(function), data(std::move(data_p)) {
+	}
+
+	create_database_t function;
+	unique_ptr<CreateDatabaseExtensionData> data;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/function/function_serialization.hpp

@@ -47,7 +47,7 @@ public:
 		// note: original_arguments are optional (can be list of size 0)
 		auto original_arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 
-		auto func_catalog = Catalog::GetEntry(context, type, INVALID_CATALOG, DEFAULT_SCHEMA, name);
+		auto func_catalog = Catalog::GetEntry(context, type, SYSTEM_CATALOG, DEFAULT_SCHEMA, name);
 		if (!func_catalog || func_catalog->type != type) {
 			throw InternalException("Cant find catalog entry for function %s", name);
 		}
@@ -55,8 +55,8 @@ public:
 		auto functions = (CATALOG_ENTRY *)func_catalog;
 		auto function = functions->functions.GetFunctionByArguments(
 		    state.context, original_arguments.empty() ? arguments : original_arguments);
-		function.arguments = move(arguments);
-		function.original_arguments = move(original_arguments);
+		function.arguments = std::move(arguments);
+		function.original_arguments = std::move(original_arguments);
 
 		has_deserialize = reader.ReadRequired<bool>();
 		if (has_deserialize) {

package/src/duckdb/src/include/duckdb/function/function_set.hpp

@@ -28,15 +28,17 @@ public:
 
 public:
 	void AddFunction(T function) {
-		functions.push_back(move(function));
+		functions.push_back(std::move(function));
 	}
 	idx_t Size() {
 		return functions.size();
 	}
 	T GetFunctionByOffset(idx_t offset) {
+		D_ASSERT(offset < functions.size());
 		return functions[offset];
 	}
 	T &GetFunctionReferenceByOffset(idx_t offset) {
+		D_ASSERT(offset < functions.size());
 		return functions[offset];
 	}
 	bool MergeFunctionSet(FunctionSet<T> new_functions) {
@@ -82,7 +84,7 @@ public:
 
 class PragmaFunctionSet : public FunctionSet<PragmaFunction> {
 public:
-	explicit PragmaFunctionSet(string name) : FunctionSet(move(name)) {
+	explicit PragmaFunctionSet(string name) : FunctionSet(std::move(name)) {
 	}
 };
 

package/src/duckdb/src/include/duckdb/function/replacement_scan.hpp

@@ -13,21 +13,21 @@
 namespace duckdb {
 
 class ClientContext;
-class TableFunctionRef;
+class TableRef;
 
 struct ReplacementScanData {
 	virtual ~ReplacementScanData() {
 	}
 };
 
-typedef unique_ptr<TableFunctionRef> (*replacement_scan_t)(ClientContext &context, const string &table_name,
-                                                           ReplacementScanData *data);
+typedef unique_ptr<TableRef> (*replacement_scan_t)(ClientContext &context, const string &table_name,
+                                                   ReplacementScanData *data);
 
 //! Replacement table scans are automatically attempted when a table name cannot be found in the schema
 //! This allows you to do e.g. SELECT * FROM 'filename.csv', and automatically convert this into a CSV scan
 struct ReplacementScan {
 	explicit ReplacementScan(replacement_scan_t function, unique_ptr<ReplacementScanData> data_p = nullptr)
-	    : function(function), data(move(data_p)) {
+	    : function(function), data(std::move(data_p)) {
 	}
 
 	replacement_scan_t function;

package/src/duckdb/src/include/duckdb/function/scalar/bit_functions.hpp

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/scalar/bit_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/function/built_in_functions.hpp"
+
+namespace duckdb {
+
+struct GetBitFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct SetBitFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct BitPositionFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/function/scalar/date_functions.hpp

@@ -62,6 +62,10 @@ struct StrpTimeFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct TimeBucketFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct ToIntervalFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };