duckdb 0.8.2-dev3250.0 → 0.8.2-dev3300.0

package/src/duckdb/src/execution/operator/schema/{physical_create_index.cpp → physical_create_art_index.cpp}

@@ -1,4 +1,4 @@
-#include "duckdb/execution/operator/schema/physical_create_index.hpp"
+#include "duckdb/execution/operator/schema/physical_create_art_index.hpp"
 
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
@@ -14,10 +14,10 @@
 
 namespace duckdb {
 
-PhysicalCreateIndex::PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry &table_p,
-                                         const vector<column_t> &column_ids, unique_ptr<CreateIndexInfo> info,
-                                         vector<unique_ptr<Expression>> unbound_expressions,
-                                         idx_t estimated_cardinality, const bool sorted)
+PhysicalCreateARTIndex::PhysicalCreateARTIndex(LogicalOperator &op, TableCatalogEntry &table_p,
+                                               const vector<column_t> &column_ids, unique_ptr<CreateIndexInfo> info,
+                                               vector<unique_ptr<Expression>> unbound_expressions,
+                                               idx_t estimated_cardinality, const bool sorted)
     : PhysicalOperator(PhysicalOperatorType::CREATE_INDEX, op.types, estimated_cardinality),
       table(table_p.Cast<DuckTableEntry>()), info(std::move(info)), unbound_expressions(std::move(unbound_expressions)),
       sorted(sorted) {
@@ -31,15 +31,15 @@ PhysicalCreateIndex::PhysicalCreateIndex(LogicalOperator &op, TableCatalogEntry
 // Sink
 //===--------------------------------------------------------------------===//
 
-class CreateIndexGlobalSinkState : public GlobalSinkState {
+class CreateARTIndexGlobalSinkState : public GlobalSinkState {
 public:
 	//! Global index to be added to the table
 	unique_ptr<Index> global_index;
 };
 
-class CreateIndexLocalSinkState : public LocalSinkState {
+class CreateARTIndexLocalSinkState : public LocalSinkState {
 public:
-	explicit CreateIndexLocalSinkState(ClientContext &context) : arena_allocator(Allocator::Get(context)) {};
+	explicit CreateARTIndexLocalSinkState(ClientContext &context) : arena_allocator(Allocator::Get(context)) {};
 
 	unique_ptr<Index> local_index;
 	ArenaAllocator arena_allocator;
@@ -48,37 +48,26 @@ public:
 	vector<column_t> key_column_ids;
 };
 
-unique_ptr<GlobalSinkState> PhysicalCreateIndex::GetGlobalSinkState(ClientContext &context) const {
-	auto state = make_uniq<CreateIndexGlobalSinkState>();
+unique_ptr<GlobalSinkState> PhysicalCreateARTIndex::GetGlobalSinkState(ClientContext &context) const {
+	auto state = make_uniq<CreateARTIndexGlobalSinkState>();
 
 	// create the global index
-	switch (info->index_type) {
-	case IndexType::ART: {
-		auto &storage = table.GetStorage();
-		state->global_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
-		                                     info->constraint_type, storage.db);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented index type");
-	}
+	auto &storage = table.GetStorage();
+	state->global_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
+	                                     info->constraint_type, storage.db);
+
 	return (std::move(state));
 }
 
-unique_ptr<LocalSinkState> PhysicalCreateIndex::GetLocalSinkState(ExecutionContext &context) const {
-	auto state = make_uniq<CreateIndexLocalSinkState>(context.client);
+unique_ptr<LocalSinkState> PhysicalCreateARTIndex::GetLocalSinkState(ExecutionContext &context) const {
+	auto state = make_uniq<CreateARTIndexLocalSinkState>(context.client);
 
 	// create the local index
-	switch (info->index_type) {
-	case IndexType::ART: {
-		auto &storage = table.GetStorage();
-		state->local_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
-		                                    info->constraint_type, storage.db);
-		break;
-	}
-	default:
-		throw InternalException("Unimplemented index type");
-	}
+
+	auto &storage = table.GetStorage();
+	state->local_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
+	                                    info->constraint_type, storage.db);
+
 	state->keys = vector<ARTKey>(STANDARD_VECTOR_SIZE);
 	state->key_chunk.Initialize(Allocator::Get(context.client), state->local_index->logical_types);
 
@@ -88,9 +77,9 @@ unique_ptr<LocalSinkState> PhysicalCreateIndex::GetLocalSinkState(ExecutionConte
 	return std::move(state);
 }
 
-SinkResultType PhysicalCreateIndex::SinkUnsorted(Vector &row_identifiers, OperatorSinkInput &input) const {
+SinkResultType PhysicalCreateARTIndex::SinkUnsorted(Vector &row_identifiers, OperatorSinkInput &input) const {
 
-	auto &l_state = input.local_state.Cast<CreateIndexLocalSinkState>();
+	auto &l_state = input.local_state.Cast<CreateARTIndexLocalSinkState>();
 	auto count = l_state.key_chunk.size();
 
 	// get the corresponding row IDs
@@ -108,9 +97,9 @@ SinkResultType PhysicalCreateIndex::SinkUnsorted(Vector &row_identifiers, Operat
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-SinkResultType PhysicalCreateIndex::SinkSorted(Vector &row_identifiers, OperatorSinkInput &input) const {
+SinkResultType PhysicalCreateARTIndex::SinkSorted(Vector &row_identifiers, OperatorSinkInput &input) const {
 
-	auto &l_state = input.local_state.Cast<CreateIndexLocalSinkState>();
+	auto &l_state = input.local_state.Cast<CreateARTIndexLocalSinkState>();
 	auto &storage = table.GetStorage();
 	auto &l_index = l_state.local_index;
 
@@ -129,12 +118,13 @@ SinkResultType PhysicalCreateIndex::SinkSorted(Vector &row_identifiers, Operator
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
+SinkResultType PhysicalCreateARTIndex::Sink(ExecutionContext &context, DataChunk &chunk,
+                                            OperatorSinkInput &input) const {
 
 	D_ASSERT(chunk.ColumnCount() >= 2);
 
 	// generate the keys for the given input
-	auto &l_state = input.local_state.Cast<CreateIndexLocalSinkState>();
+	auto &l_state = input.local_state.Cast<CreateARTIndexLocalSinkState>();
 	l_state.key_chunk.ReferenceColumns(chunk, l_state.key_column_ids);
 	l_state.arena_allocator.Reset();
 	ART::GenerateKeys(l_state.arena_allocator, l_state.key_chunk, l_state.keys);
@@ -147,10 +137,11 @@ SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, DataChunk &c
 	return SinkUnsorted(row_identifiers, input);
 }
 
-SinkCombineResultType PhysicalCreateIndex::Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const {
+SinkCombineResultType PhysicalCreateARTIndex::Combine(ExecutionContext &context,
+                                                      OperatorSinkCombineInput &input) const {
 
-	auto &gstate = input.global_state.Cast<CreateIndexGlobalSinkState>();
-	auto &lstate = input.local_state.Cast<CreateIndexLocalSinkState>();
+	auto &gstate = input.global_state.Cast<CreateARTIndexGlobalSinkState>();
+	auto &lstate = input.local_state.Cast<CreateARTIndexLocalSinkState>();
 
 	// merge the local index into the global index
 	if (!gstate.global_index->MergeIndexes(*lstate.local_index)) {
@@ -160,11 +151,11 @@ SinkCombineResultType PhysicalCreateIndex::Combine(ExecutionContext &context, Op
 	return SinkCombineResultType::FINISHED;
 }
 
-SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-                                               OperatorSinkFinalizeInput &input) const {
+SinkFinalizeType PhysicalCreateARTIndex::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
+                                                  OperatorSinkFinalizeInput &input) const {
 
 	// here, we set the resulting global index as the newly created index of the table
-	auto &state = input.global_state.Cast<CreateIndexGlobalSinkState>();
+	auto &state = input.global_state.Cast<CreateARTIndexGlobalSinkState>();
 
 	// vacuum excess memory and verify
 	state.global_index->Vacuum();
@@ -199,8 +190,8 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 // Source
 //===--------------------------------------------------------------------===//
 
-SourceResultType PhysicalCreateIndex::GetData(ExecutionContext &context, DataChunk &chunk,
-                                              OperatorSourceInput &input) const {
+SourceResultType PhysicalCreateARTIndex::GetData(ExecutionContext &context, DataChunk &chunk,
+                                                 OperatorSourceInput &input) const {
 	return SourceResultType::FINISHED;
 }
 

package/src/duckdb/src/execution/physical_plan/plan_create_index.cpp

@@ -1,7 +1,8 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/execution/operator/projection/physical_projection.hpp"
 #include "duckdb/execution/operator/filter/physical_filter.hpp"
-#include "duckdb/execution/operator/schema/physical_create_index.hpp"
+#include "duckdb/execution/operator/scan/physical_table_scan.hpp"
+#include "duckdb/execution/operator/schema/physical_create_art_index.hpp"
 #include "duckdb/execution/operator/order/physical_order.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
 #include "duckdb/planner/operator/logical_create_index.hpp"
@@ -19,7 +20,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	auto table_scan = CreatePlan(*op.children[0]);
 
 	// validate that all expressions contain valid scalar functions
-	// e.g. get_current_timestamp(), random(), and sequence values are not allowed as ART keys
+	// e.g. get_current_timestamp(), random(), and sequence values are not allowed as index keys
 	// because they make deletions and lookups unfeasible
 	for (idx_t i = 0; i < op.unbound_expressions.size(); i++) {
 		auto &expr = op.unbound_expressions[i];
@@ -29,6 +30,13 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 		}
 	}
 
+	// If we get here without the plan and the index type is not ART, we throw an exception
+	// because we don't support any other index type yet. However an operator extension could have
+	// replaced this part of the plan with a different index creation operator.
+	if (op.info->index_type != IndexType::ART) {
+		throw BinderException("Index type not supported");
+	}
+
 	// table scan operator for index key columns and row IDs
 	dependencies.AddDependency(op.table);
 
@@ -80,8 +88,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	// actual physical create index operator
 
 	auto physical_create_index =
-	    make_uniq<PhysicalCreateIndex>(op, op.table, op.info->column_ids, std::move(op.info),
-	                                   std::move(op.unbound_expressions), op.estimated_cardinality, perform_sorting);
+	    make_uniq<PhysicalCreateARTIndex>(op, op.table, op.info->column_ids, std::move(op.info),
+	                                      std::move(op.unbound_expressions), op.estimated_cardinality, perform_sorting);
 
 	if (perform_sorting) {
 

package/src/duckdb/src/function/cast/string_cast.cpp

@@ -367,8 +367,9 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 	case LogicalTypeId::DATE:
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, date_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, dtime_t, duckdb::TryCastErrorMessage>);
+	case LogicalTypeId::TIME_TZ:
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, dtime_tz_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ:
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, timestamp_t, duckdb::TryCastErrorMessage>);

package/src/duckdb/src/function/cast/time_casts.cpp

@@ -32,7 +32,7 @@ BoundCastInfo DefaultCasts::TimeCastSwitch(BindCastInput &input, const LogicalTy
 		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_t, duckdb::StringCast>);
 	case LogicalTypeId::TIME_TZ:
 		// time to time with time zone
-		return ReinterpretCast;
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<dtime_t, dtime_tz_t, duckdb::Cast>);
 	default:
 		return TryVectorNullCast;
 	}
@@ -44,10 +44,10 @@ BoundCastInfo DefaultCasts::TimeTzCastSwitch(BindCastInput &input, const Logical
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
 		// time with time zone to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_t, duckdb::StringCastTZ>);
+		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_tz_t, duckdb::StringCastTZ>);
 	case LogicalTypeId::TIME:
 		// time with time zone to time
-		return ReinterpretCast;
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<dtime_tz_t, dtime_t, duckdb::Cast>);
 	default:
 		return TryVectorNullCast;
 	}
@@ -64,9 +64,11 @@ BoundCastInfo DefaultCasts::TimestampCastSwitch(BindCastInput &input, const Logi
 		// timestamp to date
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, date_t, duckdb::Cast>);
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		// timestamp to time
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
+	case LogicalTypeId::TIME_TZ:
+		// timestamp to time_tz
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_tz_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP_TZ:
 		// timestamp (us) to timestamp with time zone
 		return ReinterpretCast;
@@ -96,8 +98,7 @@ BoundCastInfo DefaultCasts::TimestampTzCastSwitch(BindCastInput &input, const Lo
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::StringCastTZ>);
 	case LogicalTypeId::TIME_TZ:
 		// timestamp with time zone to time with time zone.
-		// TODO: set the offset to +00
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_tz_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp with time zone to timestamp (us)
 		return ReinterpretCast;

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev3250"
+#define DUCKDB_VERSION "0.8.2-dev3300"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "a7f85b3b2c"
+#define DUCKDB_SOURCE_ID "26931f7ac6"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -31,6 +31,7 @@ public:
 	string sql;
 	vector<unique_ptr<ParsedExpression>> expressions;
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
+	case_insensitive_map_t<Value> options;
 
 public:
 	unique_ptr<CreateInfo> GetInfo() const override;

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

@@ -16,8 +16,9 @@ namespace duckdb {
 // Index Types
 //===--------------------------------------------------------------------===//
 enum class IndexType : uint8_t {
-	INVALID = 0, // invalid index type
-	ART = 1      // Adaptive Radix Tree
+	INVALID = 0,    // invalid index type
+	ART = 1,        // Adaptive Radix Tree
+	EXTENSION = 100 // Extension index
 };
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp

@@ -73,7 +73,7 @@ struct Cast {
 };
 
 struct HandleCastError {
-	static void AssignError(string error_message, string *error_message_ptr) {
+	static void AssignError(const string &error_message, string *error_message_ptr) {
 		if (!error_message_ptr) {
 			throw ConversionException(error_message);
 		}
@@ -470,6 +470,16 @@ DUCKDB_API bool TryCast::Operation(date_t input, timestamp_t &result, bool stric
 //===--------------------------------------------------------------------===//
 template <>
 DUCKDB_API bool TryCast::Operation(dtime_t input, dtime_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(dtime_t input, dtime_tz_t &result, bool strict);
+
+//===--------------------------------------------------------------------===//
+// Time With Time Zone Casts (Offset)
+//===--------------------------------------------------------------------===//
+template <>
+DUCKDB_API bool TryCast::Operation(dtime_tz_t input, dtime_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(dtime_tz_t input, dtime_tz_t &result, bool strict);
 
 //===--------------------------------------------------------------------===//
 // Timestamp Casts
@@ -479,6 +489,8 @@ DUCKDB_API bool TryCast::Operation(timestamp_t input, date_t &result, bool stric
 template <>
 DUCKDB_API bool TryCast::Operation(timestamp_t input, dtime_t &result, bool strict);
 template <>
+DUCKDB_API bool TryCast::Operation(timestamp_t input, dtime_tz_t &result, bool strict);
+template <>
 DUCKDB_API bool TryCast::Operation(timestamp_t input, timestamp_t &result, bool strict);
 
 //===--------------------------------------------------------------------===//
@@ -506,6 +518,15 @@ DUCKDB_API bool TryCast::Operation(string_t input, dtime_t &result, bool strict)
 template <>
 dtime_t Cast::Operation(string_t input);
 //===--------------------------------------------------------------------===//
+// String -> TimeTZ Casts
+//===--------------------------------------------------------------------===//
+template <>
+DUCKDB_API bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, string *error_message, bool strict);
+template <>
+DUCKDB_API bool TryCast::Operation(string_t input, dtime_tz_t &result, bool strict);
+template <>
+dtime_tz_t Cast::Operation(string_t input);
+//===--------------------------------------------------------------------===//
 // String -> Timestamp Casts
 //===--------------------------------------------------------------------===//
 template <>

package/src/duckdb/src/include/duckdb/common/operator/string_cast.hpp

@@ -71,7 +71,7 @@ struct StringCastTZ {
 template <>
 duckdb::string_t StringCastTZ::Operation(date_t input, Vector &result);
 template <>
-duckdb::string_t StringCastTZ::Operation(dtime_t input, Vector &result);
+duckdb::string_t StringCastTZ::Operation(dtime_tz_t input, Vector &result);
 template <>
 duckdb::string_t StringCastTZ::Operation(timestamp_t input, Vector &result);
 

package/src/duckdb/src/include/duckdb/common/types/datetime.hpp

@@ -81,12 +81,54 @@ struct dtime_t { // NOLINT
 	};
 
 	// special values
-	static inline dtime_t allballs() {
+	static inline dtime_t allballs() { // NOLINT
 		return dtime_t(0);
 	} // NOLINT
 };
 
-struct dtime_tz_t : public dtime_t {};
+struct dtime_tz_t { // NOLINT
+	static constexpr const int TIME_BITS = 40;
+	static constexpr const int OFFSET_BITS = 24;
+	static constexpr const uint64_t OFFSET_MASK = ~uint64_t(0) >> TIME_BITS;
+	static constexpr const int32_t MAX_OFFSET = 1559 * 60 * 60;
+	static constexpr const int32_t MIN_OFFSET = -MAX_OFFSET;
+
+	uint64_t bits;
+
+	dtime_tz_t() = default;
+
+	inline dtime_tz_t(dtime_t t, int32_t offset)
+	    : bits((uint64_t(t.micros) << OFFSET_BITS) | uint64_t(offset + MAX_OFFSET)) {
+	}
+
+	inline dtime_t time() const { // NOLINT
+		return dtime_t(bits >> OFFSET_BITS);
+	}
+
+	inline int32_t offset() const { // NOLINT
+		return int32_t(bits & OFFSET_MASK) - MAX_OFFSET;
+	}
+
+	// comparison operators
+	inline bool operator==(const dtime_tz_t &rhs) const {
+		return bits == rhs.bits;
+	};
+	inline bool operator!=(const dtime_tz_t &rhs) const {
+		return bits != rhs.bits;
+	};
+	inline bool operator<=(const dtime_tz_t &rhs) const {
+		return bits <= rhs.bits;
+	};
+	inline bool operator<(const dtime_tz_t &rhs) const {
+		return bits < rhs.bits;
+	};
+	inline bool operator>(const dtime_tz_t &rhs) const {
+		return bits > rhs.bits;
+	};
+	inline bool operator>=(const dtime_tz_t &rhs) const {
+		return bits >= rhs.bits;
+	};
+};
 
 } // namespace duckdb
 
@@ -100,11 +142,12 @@ struct hash<duckdb::dtime_t> {
 		return hash<int64_t>()((int64_t)k);
 	}
 };
+
 template <>
 struct hash<duckdb::dtime_tz_t> {
 	std::size_t operator()(const duckdb::dtime_tz_t &k) const {
 		using std::hash;
-		return hash<int64_t>()((int64_t)k);
+		return hash<int64_t>()(k.bits);
 	}
 };
 } // namespace std

package/src/duckdb/src/include/duckdb/common/types/time.hpp

@@ -15,6 +15,7 @@
 namespace duckdb {
 
 struct dtime_t;
+struct dtime_tz_t;
 
 //! The Time class is a static class that holds helper functions for the Time
 //! type.
@@ -24,6 +25,10 @@ public:
 	DUCKDB_API static dtime_t FromString(const string &str, bool strict = false);
 	DUCKDB_API static dtime_t FromCString(const char *buf, idx_t len, bool strict = false);
 	DUCKDB_API static bool TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict = false);
+	DUCKDB_API static bool TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &result,
+	                                        bool strict = false);
+	//!	Format is ±[HH]HH[:MM[:SS]]
+	DUCKDB_API static bool TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int32_t &offset);
 
 	//! Convert a time object to a string in the format "hh:mm:ss"
 	DUCKDB_API static string ToString(dtime_t time);

package/src/duckdb/src/include/duckdb/common/types/value.hpp

@@ -120,7 +120,7 @@ public:
 	DUCKDB_API static Value DATE(int32_t year, int32_t month, int32_t day);
 	//! Create a time Value from a specified time
 	DUCKDB_API static Value TIME(dtime_t time);
-	DUCKDB_API static Value TIMETZ(dtime_t time);
+	DUCKDB_API static Value TIMETZ(dtime_tz_t time);
 	//! Create a time Value from a specified time
 	DUCKDB_API static Value TIME(int32_t hour, int32_t min, int32_t sec, int32_t micros);
 	//! Create a timestamp Value from a specified date/time combination
@@ -302,6 +302,7 @@ private:
 		uint64_t hash;
 		date_t date;
 		dtime_t time;
+		dtime_tz_t timetz;
 		timestamp_t timestamp;
 		interval_t interval;
 	} value_; // NOLINT

package/src/duckdb/src/include/duckdb/execution/operator/schema/{physical_create_index.hpp → physical_create_art_index.hpp}

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/execution/operator/schema/physical_create_index.hpp
+// duckdb/execution/operator/schema/physical_create_art_index.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -20,14 +20,14 @@ namespace duckdb {
 class DuckTableEntry;
 
 //! Physical CREATE (UNIQUE) INDEX statement
-class PhysicalCreateIndex : public PhysicalOperator {
+class PhysicalCreateARTIndex : public PhysicalOperator {
 public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_INDEX;
 
 public:
-	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, const bool sorted);
+	PhysicalCreateARTIndex(LogicalOperator &op, TableCatalogEntry &table, const vector<column_t> &column_ids,
+	                       unique_ptr<CreateIndexInfo> info, vector<unique_ptr<Expression>> unbound_expressions,
+	                       idx_t estimated_cardinality, const bool sorted);
 
 	//! The table to create the index for
 	DuckTableEntry &table;

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

@@ -99,13 +99,16 @@ typedef void (*copy_flush_batch_t)(ClientContext &context, FunctionData &bind_da
                                    PreparedBatchData &batch);
 typedef idx_t (*copy_desired_batch_size_t)(ClientContext &context, FunctionData &bind_data);
 
+typedef bool (*copy_supports_type_t)(const LogicalType &type);
+
 class CopyFunction : public Function {
 public:
 	explicit CopyFunction(string name)
 	    : 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), execution_mode(nullptr), prepare_batch(nullptr), flush_batch(nullptr),
-	      desired_batch_size(nullptr), serialize(nullptr), deserialize(nullptr), copy_from_bind(nullptr) {
+	      desired_batch_size(nullptr), serialize(nullptr), deserialize(nullptr), supports_type(nullptr),
+	      copy_from_bind(nullptr) {
 	}
 
 	//! Plan rewrite copy function
@@ -126,6 +129,8 @@ public:
 	copy_to_serialize_t serialize;
 	copy_to_deserialize_t deserialize;
 
+	copy_supports_type_t supports_type;
+
 	copy_from_bind_t copy_from_bind;
 	TableFunction copy_from_function;
 

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

@@ -318,8 +318,9 @@ private:
 		case LogicalTypeId::DATE:
 			return std::is_same<T, date_t>();
 		case LogicalTypeId::TIME:
-		case LogicalTypeId::TIME_TZ:
 			return std::is_same<T, dtime_t>();
+		case LogicalTypeId::TIME_TZ:
+			return std::is_same<T, dtime_tz_t>();
 		case LogicalTypeId::TIMESTAMP:
 		case LogicalTypeId::TIMESTAMP_MS:
 		case LogicalTypeId::TIMESTAMP_NS:

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_index_info.hpp

@@ -25,6 +25,8 @@ struct CreateIndexInfo : public CreateInfo {
 	IndexType index_type;
 	//! Name of the Index
 	string index_name;
+	//! Name of the Index type
+	string index_type_name;
 	//! Index Constraint Type
 	IndexConstraintType constraint_type;
 	//! The table to create the index on
@@ -40,6 +42,9 @@ struct CreateIndexInfo : public CreateInfo {
 	//! Column IDs needed for index creation
 	vector<column_t> column_ids;
 
+	//! Options values (WITH ...)
+	case_insensitive_map_t<Value> options;
+
 protected:
 	void SerializeInternal(Serializer &serializer) const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_extension_operator.hpp

@@ -13,6 +13,8 @@
 
 namespace duckdb {
 
+class ColumnBindingResolver;
+
 struct LogicalExtensionOperator : public LogicalOperator {
 public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR;
@@ -31,6 +33,7 @@ public:
 
 	virtual unique_ptr<PhysicalOperator> CreatePlan(ClientContext &context, PhysicalPlanGenerator &generator) = 0;
 
+	virtual void ResolveColumnBindings(ColumnBindingResolver &res, vector<ColumnBinding> &bindings);
 	virtual string GetExtensionName() const;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/data_table.hpp

@@ -125,7 +125,7 @@ public:
 	void UpdateColumn(TableCatalogEntry &table, ClientContext &context, Vector &row_ids,
 	                  const vector<column_t> &column_path, DataChunk &updates);
 
-	//! Add an index to the DataTable. NOTE: for CREATE (UNIQUE) INDEX statements, we use the PhysicalCreateIndex
+	//! Add an index to the DataTable. NOTE: for CREATE (UNIQUE) INDEX statements, we use the PhysicalCreateARTIndex
 	//! operator. This function is only used during the WAL replay, and is a much less performant index creation
 	//! approach.
 	void WALAddIndex(ClientContext &context, unique_ptr<Index> index,

package/src/duckdb/src/main/appender.cpp

@@ -184,9 +184,11 @@ void BaseAppender::AppendValueInternal(T input) {
 		AppendValueInternal<T, timestamp_t>(col, input);
 		break;
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		AppendValueInternal<T, dtime_t>(col, input);
 		break;
+	case LogicalTypeId::TIME_TZ:
+		AppendValueInternal<T, dtime_tz_t>(col, input);
+		break;
 	case LogicalTypeId::INTERVAL:
 		AppendValueInternal<T, interval_t>(col, input);
 		break;

package/src/duckdb/src/main/capi/result-c.cpp

@@ -182,9 +182,11 @@ duckdb_state deprecated_duckdb_translate_column(MaterializedQueryResult &result,
 		WriteData<date_t>(column, collection, column_ids);
 		break;
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		WriteData<dtime_t>(column, collection, column_ids);
 		break;
+	case LogicalTypeId::TIME_TZ:
+		WriteData<dtime_tz_t>(column, collection, column_ids);
+		break;
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ:
 		WriteData<timestamp_t>(column, collection, column_ids);

package/src/duckdb/src/parser/parsed_data/create_index_info.cpp

@@ -22,6 +22,7 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 	result->scan_types = scan_types;
 	result->names = names;
 	result->column_ids = column_ids;
+	result->options = options;
 	return std::move(result);
 }
 
@@ -37,6 +38,12 @@ void CreateIndexInfo::SerializeInternal(Serializer &serializer) const {
 	writer.WriteRegularSerializableList(scan_types);
 	writer.WriteList<string>(names);
 	writer.WriteList<column_t>(column_ids);
+	writer.WriteString(index_type_name);
+	writer.WriteField((idx_t)options.size());
+	for (auto &kv : options) {
+		writer.WriteString(kv.first);
+		writer.WriteSerializable(kv.second);
+	}
 	writer.Finalize();
 }
 
@@ -55,6 +62,13 @@ unique_ptr<CreateIndexInfo> CreateIndexInfo::Deserialize(Deserializer &deseriali
 	result->scan_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 	result->names = reader.ReadRequiredList<string>();
 	result->column_ids = reader.ReadRequiredList<column_t>();
+	result->index_type_name = reader.ReadRequired<string>();
+	auto options_count = reader.ReadRequired<idx_t>();
+	for (idx_t i = 0; i < options_count; i++) {
+		auto key = reader.ReadRequired<string>();
+		auto value = reader.ReadRequiredSerializable<Value, Value>();
+		result->options[key] = value;
+	}
 	reader.Finalize();
 	return result;
 }