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

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev3250.0",
+  "version": "0.8.2-dev3300.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/parquet/column_reader.cpp

@@ -507,13 +507,13 @@ idx_t ColumnReader::Read(uint64_t num_values, parquet_filter_t &filter, data_ptr
 			// TODO keep this in the state
 			auto read_buf = make_shared<ResizeableBuffer>();
 
-			switch (type.InternalType()) {
-			case PhysicalType::INT32:
+			switch (schema.type) {
+			case duckdb_parquet::format::Type::INT32:
 				read_buf->resize(reader.allocator, sizeof(int32_t) * (read_now - null_count));
 				dbp_decoder->GetBatch<int32_t>(read_buf->ptr, read_now - null_count);
 
 				break;
-			case PhysicalType::INT64:
+			case duckdb_parquet::format::Type::INT64:
 				read_buf->resize(reader.allocator, sizeof(int64_t) * (read_now - null_count));
 				dbp_decoder->GetBatch<int64_t>(read_buf->ptr, read_now - null_count);
 				break;
@@ -1389,7 +1389,6 @@ unique_ptr<ColumnReader> ColumnReader::CreateReader(ParquetReader &reader, const
 		return make_uniq<CallbackColumnReader<int32_t, date_t, ParquetIntToDate>>(reader, type_p, schema_p, file_idx_p,
 		                                                                          max_define, max_repeat);
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		if (schema_p.__isset.logicalType && schema_p.logicalType.__isset.TIME) {
 			if (schema_p.logicalType.TIME.unit.__isset.MILLIS) {
 				return make_uniq<CallbackColumnReader<int32_t, dtime_t, ParquetIntToTimeMs>>(
@@ -1413,6 +1412,21 @@ unique_ptr<ColumnReader> ColumnReader::CreateReader(ParquetReader &reader, const
 				break;
 			}
 		}
+	case LogicalTypeId::TIME_TZ:
+		if (schema_p.__isset.logicalType && schema_p.logicalType.__isset.TIME) {
+			if (schema_p.logicalType.TIME.unit.__isset.MICROS) {
+				return make_uniq<CallbackColumnReader<int64_t, dtime_tz_t, ParquetIntToTimeTZ>>(
+				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+			}
+		} else if (schema_p.__isset.converted_type) {
+			switch (schema_p.converted_type) {
+			case ConvertedType::TIME_MICROS:
+				return make_uniq<CallbackColumnReader<int64_t, dtime_tz_t, ParquetIntToTimeTZ>>(
+				    reader, type_p, schema_p, file_idx_p, max_define, max_repeat);
+			default:
+				break;
+			}
+		}
 	case LogicalTypeId::BLOB:
 	case LogicalTypeId::VARCHAR:
 		return make_uniq<StringColumnReader>(reader, type_p, schema_p, file_idx_p, max_define, max_repeat);

package/src/duckdb/extension/parquet/include/parquet_timestamp.hpp

@@ -25,5 +25,6 @@ date_t ParquetIntToDate(const int32_t &raw_date);
 dtime_t ParquetIntToTimeMs(const int32_t &raw_time);
 dtime_t ParquetIntToTime(const int64_t &raw_time);
 dtime_t ParquetIntToTimeNs(const int64_t &raw_time);
+dtime_tz_t ParquetIntToTimeTZ(const int64_t &raw_time);
 
 } // namespace duckdb

package/src/duckdb/extension/parquet/include/parquet_writer.hpp

@@ -75,7 +75,11 @@ public:
 		return *writer;
 	}
 
+	static bool TypeIsSupported(const LogicalType &type);
+
 private:
+	static bool DuckDBTypeToParquetTypeInternal(const LogicalType &duckdb_type,
+	                                            duckdb_parquet::format::Type::type &type);
 	string file_name;
 	vector<LogicalType> sql_types;
 	vector<string> column_names;

package/src/duckdb/extension/parquet/parquet_extension.cpp

@@ -37,6 +37,7 @@
 #include "duckdb/storage/table/row_group.hpp"
 #include "duckdb/common/serializer/format_serializer.hpp"
 #include "duckdb/common/serializer/format_deserializer.hpp"
+
 #endif
 
 namespace duckdb {
@@ -826,6 +827,7 @@ unique_ptr<FunctionData> ParquetWriteBind(ClientContext &context, CopyInfo &info
 	if (!row_group_size_bytes_set) {
 		bind_data->row_group_size_bytes = bind_data->row_group_size * ParquetWriteBindData::BYTES_PER_ROW;
 	}
+
 	bind_data->sql_types = sql_types;
 	bind_data->column_names = names;
 	return std::move(bind_data);
@@ -1003,6 +1005,7 @@ void ParquetExtension::Load(DuckDB &db) {
 	function.desired_batch_size = ParquetWriteDesiredBatchSize;
 	function.serialize = ParquetCopySerialize;
 	function.deserialize = ParquetCopyDeserialize;
+	function.supports_type = ParquetWriter::TypeIsSupported;
 
 	function.extension = "parquet";
 	ExtensionUtil::RegisterFunction(db_instance, function);

package/src/duckdb/extension/parquet/parquet_statistics.cpp

@@ -154,8 +154,7 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 			throw InternalException("Incorrect stats size for type DATE");
 		}
 		return Value::DATE(date_t(Load<int32_t>(stats_data)));
-	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ: {
+	case LogicalTypeId::TIME: {
 		int64_t val;
 		if (stats.size() == sizeof(int32_t)) {
 			val = Load<int32_t>(stats_data);
@@ -182,6 +181,23 @@ Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
 			return Value::TIME(dtime_t(val));
 		}
 	}
+	case LogicalTypeId::TIME_TZ: {
+		int64_t val;
+		if (stats.size() == sizeof(int64_t)) {
+			val = Load<int64_t>(stats_data);
+		} else {
+			throw InternalException("Incorrect stats size for type TIMETZ");
+		}
+		if (schema_ele.__isset.logicalType && schema_ele.logicalType.__isset.TIME) {
+			// logical type
+			if (schema_ele.logicalType.TIME.unit.__isset.MICROS) {
+				return Value::TIMETZ(ParquetIntToTimeTZ(val));
+			} else {
+				throw InternalException("Time With Time Zone logicalType is set but unit is not defined");
+			}
+		}
+		return Value::TIMETZ(ParquetIntToTimeTZ(val));
+	}
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ: {
 		if (schema_ele.type == Type::INT96) {

package/src/duckdb/extension/parquet/parquet_timestamp.cpp

@@ -66,4 +66,10 @@ dtime_t ParquetIntToTimeNs(const int64_t &raw_time) {
 	return Time::FromTimeNs(raw_time);
 }
 
+dtime_tz_t ParquetIntToTimeTZ(const int64_t &raw_time) {
+	dtime_tz_t result;
+	result.bits = raw_time;
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/extension/parquet/parquet_writer.cpp

@@ -76,27 +76,32 @@ private:
 	Serializer &serializer;
 };
 
-Type::type ParquetWriter::DuckDBTypeToParquetType(const LogicalType &duckdb_type) {
+bool ParquetWriter::DuckDBTypeToParquetTypeInternal(const LogicalType &duckdb_type, Type::type &parquet_type) {
 	switch (duckdb_type.id()) {
 	case LogicalTypeId::BOOLEAN:
-		return Type::BOOLEAN;
+		parquet_type = Type::BOOLEAN;
+		break;
 	case LogicalTypeId::TINYINT:
 	case LogicalTypeId::SMALLINT:
 	case LogicalTypeId::INTEGER:
 	case LogicalTypeId::DATE:
-		return Type::INT32;
+		parquet_type = Type::INT32;
+		break;
 	case LogicalTypeId::BIGINT:
-		return Type::INT64;
+		parquet_type = Type::INT64;
+		break;
 	case LogicalTypeId::FLOAT:
-		return Type::FLOAT;
+		parquet_type = Type::FLOAT;
+		break;
 	case LogicalTypeId::DOUBLE:
 	case LogicalTypeId::HUGEINT:
-		return Type::DOUBLE;
+		parquet_type = Type::DOUBLE;
+		break;
 	case LogicalTypeId::ENUM:
 	case LogicalTypeId::BLOB:
 	case LogicalTypeId::VARCHAR:
-	case LogicalTypeId::BIT:
-		return Type::BYTE_ARRAY;
+		parquet_type = Type::BYTE_ARRAY;
+		break;
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIME_TZ:
 	case LogicalTypeId::TIMESTAMP:
@@ -104,31 +109,80 @@ Type::type ParquetWriter::DuckDBTypeToParquetType(const LogicalType &duckdb_type
 	case LogicalTypeId::TIMESTAMP_MS:
 	case LogicalTypeId::TIMESTAMP_NS:
 	case LogicalTypeId::TIMESTAMP_SEC:
-		return Type::INT64;
+		parquet_type = Type::INT64;
+		break;
 	case LogicalTypeId::UTINYINT:
 	case LogicalTypeId::USMALLINT:
 	case LogicalTypeId::UINTEGER:
-		return Type::INT32;
+		parquet_type = Type::INT32;
+		break;
 	case LogicalTypeId::UBIGINT:
-		return Type::INT64;
+		parquet_type = Type::INT64;
+		break;
 	case LogicalTypeId::INTERVAL:
 	case LogicalTypeId::UUID:
-		return Type::FIXED_LEN_BYTE_ARRAY;
+		parquet_type = Type::FIXED_LEN_BYTE_ARRAY;
+		break;
 	case LogicalTypeId::DECIMAL:
 		switch (duckdb_type.InternalType()) {
 		case PhysicalType::INT16:
 		case PhysicalType::INT32:
-			return Type::INT32;
+			parquet_type = Type::INT32;
+			break;
 		case PhysicalType::INT64:
-			return Type::INT64;
+			parquet_type = Type::INT64;
+			break;
 		case PhysicalType::INT128:
-			return Type::FIXED_LEN_BYTE_ARRAY;
+			parquet_type = Type::FIXED_LEN_BYTE_ARRAY;
+			break;
 		default:
 			throw InternalException("Unsupported internal decimal type");
 		}
+		break;
 	default:
+		// Anything that is not supported returns false
+		return false;
+	}
+	return true;
+}
+
+Type::type ParquetWriter::DuckDBTypeToParquetType(const LogicalType &duckdb_type) {
+	Type::type result;
+	if (!DuckDBTypeToParquetTypeInternal(duckdb_type, result)) {
 		throw NotImplementedException("Unimplemented type for Parquet \"%s\"", duckdb_type.ToString());
 	}
+	return result;
+}
+
+bool ParquetWriter::TypeIsSupported(const LogicalType &type) {
+	Type::type unused;
+	auto id = type.id();
+	if (id == LogicalTypeId::LIST) {
+		auto &child_type = ListType::GetChildType(type);
+		return TypeIsSupported(child_type);
+	}
+	if (id == LogicalTypeId::STRUCT) {
+		auto &children = StructType::GetChildTypes(type);
+		for (auto &child : children) {
+			auto &child_type = child.second;
+			if (!TypeIsSupported(child_type)) {
+				return false;
+			}
+		}
+		return true;
+	}
+	if (id == LogicalTypeId::MAP) {
+		auto &key_type = MapType::KeyType(type);
+		auto &value_type = MapType::ValueType(type);
+		if (!TypeIsSupported(key_type)) {
+			return false;
+		}
+		if (!TypeIsSupported(value_type)) {
+			return false;
+		}
+		return true;
+	}
+	return DuckDBTypeToParquetTypeInternal(type, unused);
 }
 
 void ParquetWriter::SetSchemaProperties(const LogicalType &duckdb_type,

package/src/duckdb/src/common/enum_util.cpp

@@ -2345,6 +2345,8 @@ const char* EnumUtil::ToChars<IndexType>(IndexType value) {
 		return "INVALID";
 	case IndexType::ART:
 		return "ART";
+	case IndexType::EXTENSION:
+		return "EXTENSION";
 	default:
 		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
 	}
@@ -2358,6 +2360,9 @@ IndexType EnumUtil::FromString<IndexType>(const char *value) {
 	if (StringUtil::Equals(value, "ART")) {
 		return IndexType::ART;
 	}
+	if (StringUtil::Equals(value, "EXTENSION")) {
+		return IndexType::EXTENSION;
+	}
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 

package/src/duckdb/src/common/operator/cast_operators.cpp

@@ -1272,6 +1272,27 @@ bool TryCast::Operation(dtime_t input, dtime_t &result, bool strict) {
 	return true;
 }
 
+template <>
+bool TryCast::Operation(dtime_t input, dtime_tz_t &result, bool strict) {
+	result = dtime_tz_t(input, 0);
+	return true;
+}
+
+//===--------------------------------------------------------------------===//
+// Cast From Time With Time Zone (Offset)
+//===--------------------------------------------------------------------===//
+template <>
+bool TryCast::Operation(dtime_tz_t input, dtime_tz_t &result, bool strict) {
+	result = input;
+	return true;
+}
+
+template <>
+bool TryCast::Operation(dtime_tz_t input, dtime_t &result, bool strict) {
+	result = input.time();
+	return true;
+}
+
 //===--------------------------------------------------------------------===//
 // Cast From Timestamps
 //===--------------------------------------------------------------------===//
@@ -1296,6 +1317,15 @@ bool TryCast::Operation(timestamp_t input, timestamp_t &result, bool strict) {
 	return true;
 }
 
+template <>
+bool TryCast::Operation(timestamp_t input, dtime_tz_t &result, bool strict) {
+	if (!Timestamp::IsFinite(input)) {
+		return false;
+	}
+	result = dtime_tz_t(Timestamp::GetTime(input), 0);
+	return true;
+}
+
 //===--------------------------------------------------------------------===//
 // Cast from Interval
 //===--------------------------------------------------------------------===//
@@ -1583,6 +1613,33 @@ dtime_t Cast::Operation(string_t input) {
 	return Time::FromCString(input.GetData(), input.GetSize());
 }
 
+//===--------------------------------------------------------------------===//
+// Cast To TimeTZ
+//===--------------------------------------------------------------------===//
+template <>
+bool TryCastErrorMessage::Operation(string_t input, dtime_tz_t &result, string *error_message, bool strict) {
+	if (!TryCast::Operation<string_t, dtime_tz_t>(input, result, strict)) {
+		HandleCastError::AssignError(Time::ConversionError(input), error_message);
+		return false;
+	}
+	return true;
+}
+
+template <>
+bool TryCast::Operation(string_t input, dtime_tz_t &result, bool strict) {
+	idx_t pos;
+	return Time::TryConvertTimeTZ(input.GetData(), input.GetSize(), pos, result, strict);
+}
+
+template <>
+dtime_tz_t Cast::Operation(string_t input) {
+	dtime_tz_t result;
+	if (!TryCast::Operation(input, result, false)) {
+		throw ConversionException(Time::ConversionError(input));
+	}
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // Cast To Timestamp
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/common/operator/string_cast.cpp

@@ -161,24 +161,61 @@ duckdb::string_t StringCast::Operation(duckdb::string_t input, Vector &result) {
 }
 
 template <>
-string_t StringCastTZ::Operation(dtime_t input, Vector &vector) {
+string_t StringCastTZ::Operation(dtime_tz_t input, Vector &vector) {
 	int32_t time[4];
-	Time::Convert(input, time[0], time[1], time[2], time[3]);
+	Time::Convert(input.time(), time[0], time[1], time[2], time[3]);
 
-	// format for timetz is TIME+00
 	char micro_buffer[10];
 	const auto time_length = TimeToStringCast::Length(time, micro_buffer);
-	const idx_t length = time_length + 3;
+	idx_t length = time_length;
+
+	const auto offset = input.offset();
+	const bool negative = (offset < 0);
+	++length;
+
+	auto ss = std::abs(offset);
+	const auto hh = ss / Interval::SECS_PER_HOUR;
+
+	const auto hh_length = (hh < 100) ? 2 : NumericHelper::UnsignedLength(uint32_t(hh));
+	length += hh_length;
+
+	ss %= Interval::SECS_PER_HOUR;
+	const auto mm = ss / Interval::SECS_PER_MINUTE;
+	if (mm) {
+		length += 3;
+	}
+
+	ss %= Interval::SECS_PER_MINUTE;
+	if (ss) {
+		length += 3;
+	}
 
 	string_t result = StringVector::EmptyString(vector, length);
 	auto data = result.GetDataWriteable();
 
 	idx_t pos = 0;
-	TimeToStringCast::Format(data + pos, length, time, micro_buffer);
+	TimeToStringCast::Format(data + pos, time_length, time, micro_buffer);
 	pos += time_length;
-	data[pos++] = '+';
-	data[pos++] = '0';
-	data[pos++] = '0';
+
+	data[pos++] = negative ? '-' : '+';
+	if (hh < 100) {
+		TimeToStringCast::FormatTwoDigits(data + pos, hh);
+	} else {
+		NumericHelper::FormatUnsigned(hh, data + pos + hh_length);
+	}
+	pos += hh_length;
+
+	if (mm) {
+		data[pos++] = ':';
+		TimeToStringCast::FormatTwoDigits(data + pos, mm);
+		pos += 2;
+	}
+
+	if (ss) {
+		data[pos++] = ':';
+		TimeToStringCast::FormatTwoDigits(data + pos, ss);
+		pos += 2;
+	}
 
 	result.Finalize();
 	return result;

package/src/duckdb/src/common/types/time.cpp

@@ -129,6 +129,111 @@ bool Time::TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &resul
 	return true;
 }
 
+bool Time::TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int32_t &offset) {
+	offset = 0;
+	if (pos == len || StringUtil::CharacterIsSpace(str[pos])) {
+		return true;
+	}
+
+	idx_t curpos = pos;
+	// Minimum of 3 characters
+	if (curpos + 3 > len) {
+		// no characters left to parse
+		return false;
+	}
+
+	const auto sign_char = str[curpos];
+	if (sign_char != '+' && sign_char != '-') {
+		// expected either + or -
+		return false;
+	}
+	curpos++;
+
+	int32_t hh = 0;
+	idx_t start = curpos;
+	for (; curpos < len; ++curpos) {
+		const auto c = str[curpos];
+		if (!StringUtil::CharacterIsDigit(c)) {
+			break;
+		}
+		hh = hh * 10 + (c - '0');
+	}
+	//	HH is in [-1559,+1559] and must be at least two digits
+	if (curpos - start < 2 || hh > 1559) {
+		return false;
+	}
+
+	// optional minute specifier: expected ":MM"
+	int32_t mm = 0;
+	if (curpos + 3 <= len && str[curpos] == ':') {
+		++curpos;
+		if (!Date::ParseDoubleDigit(str, len, curpos, mm) || mm >= Interval::MINS_PER_HOUR) {
+			return false;
+		}
+	}
+
+	// optional seconds specifier: expected ":SS"
+	int32_t ss = 0;
+	if (curpos + 3 <= len && str[curpos] == ':') {
+		++curpos;
+		if (!Date::ParseDoubleDigit(str, len, curpos, ss) || ss >= Interval::SECS_PER_MINUTE) {
+			return false;
+		}
+	}
+
+	//	Assemble the offset now that we know nothing went wrong
+	offset += hh * Interval::SECS_PER_HOUR;
+	offset += mm * Interval::SECS_PER_MINUTE;
+	offset += ss;
+	if (sign_char == '-') {
+		offset = -offset;
+	}
+
+	pos = curpos;
+
+	return true;
+}
+
+bool Time::TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &result, bool strict) {
+	dtime_t time_part;
+	if (!Time::TryConvertInternal(buf, len, pos, time_part, false)) {
+		if (!strict) {
+			// last chance, check if we can parse as timestamp
+			timestamp_t timestamp;
+			if (Timestamp::TryConvertTimestamp(buf, len, timestamp) == TimestampCastResult::SUCCESS) {
+				if (!Timestamp::IsFinite(timestamp)) {
+					return false;
+				}
+				result = dtime_tz_t(Timestamp::GetTime(timestamp), 0);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	//	We can't use Timestamp::TryParseUTCOffset because the colon is optional there but required here.
+	int32_t offset = 0;
+	if (!TryParseUTCOffset(buf, pos, len, offset)) {
+		return false;
+	}
+
+	// in strict mode, check remaining string for non-space characters
+	if (strict) {
+		// skip trailing spaces
+		while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) {
+			pos++;
+		}
+		// check position. if end was not reached, non-space chars remaining
+		if (pos < len) {
+			return false;
+		}
+	}
+
+	result = dtime_tz_t(time_part, offset);
+
+	return true;
+}
+
 string Time::ConversionError(const string &str) {
 	return StringUtil::Format("time field value out of range: \"%s\", "
 	                          "expected format is ([YYYY-MM-DD ]HH:MM:SS[.MS])",

package/src/duckdb/src/common/types/value.cpp

@@ -231,7 +231,7 @@ Value Value::MinimumValue(const LogicalType &type) {
 	case LogicalTypeId::TIMESTAMP_NS:
 		return Value::TIMESTAMPNS(timestamp_t(NumericLimits<int64_t>::Minimum()));
 	case LogicalTypeId::TIME_TZ:
-		return Value::TIMETZ(dtime_t(0));
+		return Value::TIMETZ(dtime_tz_t(dtime_t(0), dtime_tz_t::MIN_OFFSET));
 	case LogicalTypeId::TIMESTAMP_TZ:
 		return Value::TIMESTAMPTZ(Timestamp::FromDatetime(
 		    Date::FromDate(Timestamp::MIN_YEAR, Timestamp::MIN_MONTH, Timestamp::MIN_DAY), dtime_t(0)));
@@ -300,7 +300,8 @@ Value Value::MaximumValue(const LogicalType &type) {
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return MaximumValue(LogicalType::TIMESTAMP).DefaultCastAs(LogicalType::TIMESTAMP_S);
 	case LogicalTypeId::TIME_TZ:
-		return Value::TIMETZ(dtime_t(Interval::SECS_PER_DAY * Interval::MICROS_PER_SEC - 1));
+		return Value::TIMETZ(
+		    dtime_tz_t(dtime_t(Interval::SECS_PER_DAY * Interval::MICROS_PER_SEC - 1), dtime_tz_t::MAX_OFFSET));
 	case LogicalTypeId::TIMESTAMP_TZ:
 		return MaximumValue(LogicalType::TIMESTAMP);
 	case LogicalTypeId::FLOAT:
@@ -587,9 +588,9 @@ Value Value::TIME(dtime_t value) {
 	return result;
 }
 
-Value Value::TIMETZ(dtime_t value) {
+Value Value::TIMETZ(dtime_tz_t value) {
 	Value result(LogicalType::TIME_TZ);
-	result.value_.time = value;
+	result.value_.timetz = value;
 	result.is_null = false;
 	return result;
 }
@@ -955,8 +956,9 @@ T Value::GetValueInternal() const {
 	case LogicalTypeId::DATE:
 		return Cast::Operation<date_t, T>(value_.date);
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		return Cast::Operation<dtime_t, T>(value_.time);
+	case LogicalTypeId::TIME_TZ:
+		return Cast::Operation<dtime_tz_t, T>(value_.timetz);
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ:
 		return Cast::Operation<timestamp_t, T>(value_.timestamp);
@@ -1028,7 +1030,6 @@ int64_t Value::GetValue() const {
 	case LogicalTypeId::TIMESTAMP_NS:
 	case LogicalTypeId::TIMESTAMP_MS:
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 	case LogicalTypeId::TIMESTAMP_TZ:
 		return value_.bigint;
 	default:
@@ -1146,8 +1147,6 @@ Value Value::Numeric(const LogicalType &type, int64_t value) {
 		return Value::TIMESTAMPMS(timestamp_t(value));
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return Value::TIMESTAMPSEC(timestamp_t(value));
-	case LogicalTypeId::TIME_TZ:
-		return Value::TIMETZ(dtime_t(value));
 	case LogicalTypeId::TIMESTAMP_TZ:
 		return Value::TIMESTAMPTZ(timestamp_t(value));
 	case LogicalTypeId::ENUM:

package/src/duckdb/src/common/types/vector.cpp

@@ -477,7 +477,7 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) {
 	case LogicalTypeId::TIME:
 		return Value::TIME(reinterpret_cast<dtime_t *>(data)[index]);
 	case LogicalTypeId::TIME_TZ:
-		return Value::TIMETZ(reinterpret_cast<dtime_t *>(data)[index]);
+		return Value::TIMETZ(reinterpret_cast<dtime_tz_t *>(data)[index]);
 	case LogicalTypeId::BIGINT:
 		return Value::BIGINT(reinterpret_cast<int64_t *>(data)[index]);
 	case LogicalTypeId::UTINYINT:

package/src/duckdb/src/execution/column_binding_resolver.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/planner/operator/logical_any_join.hpp"
 #include "duckdb/planner/operator/logical_create_index.hpp"
 #include "duckdb/planner/operator/logical_insert.hpp"
+#include "duckdb/planner/operator/logical_extension_operator.hpp"
 
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
@@ -91,6 +92,12 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 			bindings = op.GetColumnBindings();
 			return;
 		}
+		break;
+	}
+	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR: {
+		auto &ext_op = op.Cast<LogicalExtensionOperator>();
+		ext_op.ResolveColumnBindings(*this, bindings);
+		return;
 	}
 	default:
 		break;