duckdb 0.3.2-dev362.0 → 0.3.2-dev396.0

package/src/duckdb.cpp

@@ -4703,6 +4703,15 @@ void Catalog::DropEntry(ClientContext &context, DropInfo *info) {
 	lookup.schema->DropEntry(context, info);
 }
 
+CatalogEntry *Catalog::AddFunction(ClientContext &context, CreateFunctionInfo *info) {
+	auto schema = GetSchema(context, info->schema);
+	return AddFunction(context, schema, info);
+}
+
+CatalogEntry *Catalog::AddFunction(ClientContext &context, SchemaCatalogEntry *schema, CreateFunctionInfo *info) {
+	return schema->AddFunction(context, info);
+}
+
 SchemaCatalogEntry *Catalog::GetSchema(ClientContext &context, const string &schema_name, bool if_exists,
                                        QueryErrorContext error_context) {
 	D_ASSERT(!schema_name.empty());
@@ -6659,6 +6668,37 @@ CatalogEntry *SchemaCatalogEntry::CreateFunction(ClientContext &context, CreateF
 	return AddEntry(context, move(function), info->on_conflict);
 }
 
+CatalogEntry *SchemaCatalogEntry::AddFunction(ClientContext &context, CreateFunctionInfo *info) {
+	auto entry = GetCatalogSet(info->type).GetEntry(context, info->name);
+	if (!entry) {
+		return CreateFunction(context, info);
+	}
+
+	info->on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
+	switch (info->type) {
+	case CatalogType::SCALAR_FUNCTION_ENTRY: {
+		auto scalar_info = (CreateScalarFunctionInfo *)info;
+		auto &scalars = *(ScalarFunctionCatalogEntry *)entry;
+		for (const auto &scalar : scalars.functions) {
+			scalar_info->functions.emplace_back(scalar);
+		}
+		break;
+	}
+	case CatalogType::AGGREGATE_FUNCTION_ENTRY: {
+		auto agg_info = (CreateAggregateFunctionInfo *)info;
+		auto &aggs = *(AggregateFunctionCatalogEntry *)entry;
+		for (const auto &agg : aggs.functions) {
+			agg_info->functions.AddFunction(agg);
+		}
+		break;
+	}
+	default:
+		// Macros can only be replaced because there is only one of each name.
+		throw InternalException("Unsupported function type \"%s\" for adding", CatalogTypeToString(info->type));
+	}
+	return CreateFunction(context, info);
+}
+
 void SchemaCatalogEntry::DropEntry(ClientContext &context, DropInfo *info) {
 	auto &set = GetCatalogSet(info->type);
 
@@ -22880,6 +22920,21 @@ duckdb::string_t StringCast::Operation(dtime_t input, Vector &result);
 template <>
 duckdb::string_t StringCast::Operation(timestamp_t input, Vector &result);
 
+//! Temporary casting for Time Zone types. TODO: turn casting into functions.
+struct StringCastTZ {
+	template <typename SRC>
+	static inline string_t Operation(SRC input, Vector &vector) {
+		return StringCast::Operation(input, vector);
+	}
+};
+
+template <>
+duckdb::string_t StringCastTZ::Operation(date_t input, Vector &result);
+template <>
+duckdb::string_t StringCastTZ::Operation(dtime_t input, Vector &result);
+template <>
+duckdb::string_t StringCastTZ::Operation(timestamp_t input, Vector &result);
+
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -26678,6 +26733,90 @@ duckdb::string_t StringCast::Operation(duckdb::string_t input, Vector &result) {
 	return StringVector::AddStringOrBlob(result, input);
 }
 
+template <>
+string_t StringCastTZ::Operation(date_t input, Vector &vector) {
+	int32_t date[3];
+	Date::Convert(input, date[0], date[1], date[2]);
+
+	// format for datetz is DATE+00
+	idx_t year_length;
+	bool add_bc;
+	const idx_t date_length = DateToStringCast::Length(date, year_length, add_bc);
+	const idx_t length = date_length + 3;
+
+	string_t result = StringVector::EmptyString(vector, length);
+	auto data = result.GetDataWriteable();
+
+	idx_t pos = 0;
+	DateToStringCast::Format(data + pos, date, year_length, add_bc);
+	pos += date_length;
+	data[pos++] = '+';
+	data[pos++] = '0';
+	data[pos++] = '0';
+
+	result.Finalize();
+	return result;
+}
+
+template <>
+string_t StringCastTZ::Operation(dtime_t input, Vector &vector) {
+	int32_t time[4];
+	Time::Convert(input, 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;
+
+	string_t result = StringVector::EmptyString(vector, length);
+	auto data = result.GetDataWriteable();
+
+	idx_t pos = 0;
+	TimeToStringCast::Format(data + pos, length, time, micro_buffer);
+	pos += time_length;
+	data[pos++] = '+';
+	data[pos++] = '0';
+	data[pos++] = '0';
+
+	result.Finalize();
+	return result;
+}
+
+template <>
+string_t StringCastTZ::Operation(timestamp_t input, Vector &vector) {
+	date_t date_entry;
+	dtime_t time_entry;
+	Timestamp::Convert(input, date_entry, time_entry);
+
+	int32_t date[3], time[4];
+	Date::Convert(date_entry, date[0], date[1], date[2]);
+	Time::Convert(time_entry, time[0], time[1], time[2], time[3]);
+
+	// format for timestamptz is DATE TIME+00 (separated by space)
+	idx_t year_length;
+	bool add_bc;
+	char micro_buffer[6];
+	const idx_t date_length = DateToStringCast::Length(date, year_length, add_bc);
+	const idx_t time_length = TimeToStringCast::Length(time, micro_buffer);
+	const idx_t length = date_length + 1 + time_length + 3;
+
+	string_t result = StringVector::EmptyString(vector, length);
+	auto data = result.GetDataWriteable();
+
+	idx_t pos = 0;
+	DateToStringCast::Format(data + pos, date, year_length, add_bc);
+	pos += date_length;
+	data[pos++] = ' ';
+	TimeToStringCast::Format(data + pos, time_length, time, micro_buffer);
+	pos += time_length;
+	data[pos++] = '+';
+	data[pos++] = '0';
+	data[pos++] = '0';
+
+	result.Finalize();
+	return result;
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -36113,6 +36252,9 @@ void SetArrowChild(DuckDBArrowArrayChildHolder &child_holder, const LogicalType
 	case LogicalTypeId::TIMESTAMP_NS:
 	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::DATE_TZ:
+	case LogicalTypeId::TIMESTAMP_TZ:
+	case LogicalTypeId::TIME_TZ:
 		child_holder.vector = make_unique<Vector>(data);
 		child.n_buffers = 2;
 		child.buffers[1] = (void *)FlatVector::GetData(*child_holder.vector);
@@ -37881,8 +38023,8 @@ enum class DatePartSpecifier : uint8_t {
 	YEARWEEK
 };
 
-bool TryGetDatePartSpecifier(const string &specifier, DatePartSpecifier &result);
-DatePartSpecifier GetDatePartSpecifier(const string &specifier);
+DUCKDB_API bool TryGetDatePartSpecifier(const string &specifier, DatePartSpecifier &result);
+DUCKDB_API DatePartSpecifier GetDatePartSpecifier(const string &specifier);
 
 } // namespace duckdb
 
@@ -39108,6 +39250,28 @@ string Time::ToString(dtime_t time) {
 	return string(buffer.get(), length);
 }
 
+string Time::ToUTCOffset(int hour_offset, int minute_offset) {
+	dtime_t time((hour_offset * Interval::MINS_PER_HOUR + minute_offset) * Interval::MICROS_PER_MINUTE);
+
+	char buffer[1 + 2 + 1 + 2];
+	idx_t length = 0;
+	buffer[length++] = (time.micros < 0 ? '-' : '+');
+	time.micros = std::abs(time.micros);
+
+	int32_t time_units[4];
+	Time::Convert(time, time_units[0], time_units[1], time_units[2], time_units[3]);
+
+	TimeToStringCast::FormatTwoDigits(buffer + length, time_units[0]);
+	length += 2;
+	if (time_units[1]) {
+		buffer[length++] = ':';
+		TimeToStringCast::FormatTwoDigits(buffer + length, time_units[1]);
+		length += 2;
+	}
+
+	return string(buffer, length);
+}
+
 dtime_t Time::FromTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds) {
 	int64_t result;
 	result = hour;                                             // hours
@@ -39774,6 +39938,12 @@ Value Value::MinimumValue(const LogicalType &type) {
 		return Value::TimestampMs(timestamp_t(NumericLimits<int64_t>::Minimum()));
 	case LogicalTypeId::TIMESTAMP_NS:
 		return Value::TimestampNs(timestamp_t(NumericLimits<int64_t>::Minimum()));
+	case LogicalTypeId::DATE_TZ:
+		return Value::DATETZ(date_t(NumericLimits<int32_t>::Minimum()));
+	case LogicalTypeId::TIME_TZ:
+		return Value::TIMETZ(dtime_t(0));
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Value::TIMESTAMPTZ(timestamp_t(NumericLimits<int64_t>::Minimum()));
 	case LogicalTypeId::FLOAT:
 		return Value::FLOAT(NumericLimits<float>::Minimum());
 	case LogicalTypeId::DOUBLE:
@@ -39859,6 +40029,12 @@ Value Value::MaximumValue(const LogicalType &type) {
 		return Value::TimestampNs(timestamp_t(NumericLimits<int64_t>::Maximum()));
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return Value::TimestampSec(timestamp_t(NumericLimits<int64_t>::Maximum()));
+	case LogicalTypeId::DATE_TZ:
+		return Value::DATETZ(date_t(NumericLimits<int32_t>::Maximum()));
+	case LogicalTypeId::TIME_TZ:
+		return Value::TIMETZ(dtime_t(Interval::SECS_PER_DAY * Interval::MICROS_PER_SEC));
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Value::TIMESTAMPTZ(timestamp_t(NumericLimits<int64_t>::Maximum()));
 	case LogicalTypeId::FLOAT:
 		return Value::FLOAT(NumericLimits<float>::Maximum());
 	case LogicalTypeId::DOUBLE:
@@ -40091,6 +40267,13 @@ Value Value::DATE(date_t value) {
 	return result;
 }
 
+Value Value::DATETZ(date_t value) {
+	Value result(LogicalType::DATE_TZ);
+	result.value_.date = value;
+	result.is_null = false;
+	return result;
+}
+
 Value Value::DATE(int32_t year, int32_t month, int32_t day) {
 	return Value::DATE(Date::FromDate(year, month, day));
 }
@@ -40102,6 +40285,13 @@ Value Value::TIME(dtime_t value) {
 	return result;
 }
 
+Value Value::TIMETZ(dtime_t value) {
+	Value result(LogicalType::TIME_TZ);
+	result.value_.time = value;
+	result.is_null = false;
+	return result;
+}
+
 Value Value::TIME(int32_t hour, int32_t min, int32_t sec, int32_t micros) {
 	return Value::TIME(Time::FromTime(hour, min, sec, micros));
 }
@@ -40113,6 +40303,13 @@ Value Value::TIMESTAMP(timestamp_t value) {
 	return result;
 }
 
+Value Value::TIMESTAMPTZ(timestamp_t value) {
+	Value result(LogicalType::TIMESTAMP_TZ);
+	result.value_.timestamp = value;
+	result.is_null = false;
+	return result;
+}
+
 Value Value::TimestampNs(timestamp_t timestamp) {
 	Value result(LogicalType::TIMESTAMP_NS);
 	result.value_.timestamp = timestamp;
@@ -40367,10 +40564,13 @@ T Value::GetValueInternal() const {
 	case LogicalTypeId::UUID:
 		return Cast::Operation<hugeint_t, T>(value_.hugeint);
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		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::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return Cast::Operation<timestamp_t, T>(value_.timestamp);
 	case LogicalTypeId::UTINYINT:
 		return Cast::Operation<uint8_t, T>(value_.utinyint);
@@ -40419,12 +40619,18 @@ int32_t Value::GetValue() const {
 }
 template <>
 int64_t Value::GetValue() const {
-	if (type_.id() == LogicalTypeId::TIMESTAMP || type_.id() == LogicalTypeId::TIME ||
-	    type_.id() == LogicalTypeId::TIMESTAMP_SEC || type_.id() == LogicalTypeId::TIMESTAMP_NS ||
-	    type_.id() == LogicalTypeId::TIMESTAMP_MS) {
+	switch (type_.id()) {
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_SEC:
+	case LogicalTypeId::TIMESTAMP_NS:
+	case LogicalTypeId::TIMESTAMP_MS:
+	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return value_.bigint;
+	default:
+		return GetValueInternal<int64_t>();
 	}
-	return GetValueInternal<int64_t>();
 }
 template <>
 hugeint_t Value::GetValue() const {
@@ -40702,6 +40908,12 @@ string Value::ToString() const {
 		return Time::ToString(value_.time);
 	case LogicalTypeId::TIMESTAMP:
 		return Timestamp::ToString(value_.timestamp);
+	case LogicalTypeId::DATE_TZ:
+		return Date::ToString(value_.date) + Time::ToUTCOffset(0, 0);
+	case LogicalTypeId::TIME_TZ:
+		return Time::ToString(value_.time) + Time::ToUTCOffset(0, 0);
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Timestamp::ToString(value_.timestamp) + Time::ToUTCOffset(0, 0);
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return Timestamp::ToString(Timestamp::FromEpochSeconds(value_.timestamp.value));
 	case LogicalTypeId::TIMESTAMP_MS:
@@ -41376,6 +41588,7 @@ void Vector::SetValue(idx_t index, const Value &val) {
 		((int16_t *)data)[index] = val.value_.smallint;
 		break;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 	case LogicalTypeId::INTEGER:
 		((int32_t *)data)[index] = val.value_.integer;
 		break;
@@ -41386,6 +41599,8 @@ void Vector::SetValue(idx_t index, const Value &val) {
 	case LogicalTypeId::HASH:
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::BIGINT:
+	case LogicalTypeId::TIMESTAMP_TZ:
+	case LogicalTypeId::TIME_TZ:
 		((int64_t *)data)[index] = val.value_.bigint;
 		break;
 	case LogicalTypeId::UTINYINT:
@@ -41528,8 +41743,12 @@ Value Vector::GetValue(idx_t index) const {
 		return Value::INTEGER(((int32_t *)data)[index]);
 	case LogicalTypeId::DATE:
 		return Value::DATE(((date_t *)data)[index]);
+	case LogicalTypeId::DATE_TZ:
+		return Value::DATETZ(((date_t *)data)[index]);
 	case LogicalTypeId::TIME:
 		return Value::TIME(((dtime_t *)data)[index]);
+	case LogicalTypeId::TIME_TZ:
+		return Value::TIMETZ(((dtime_t *)data)[index]);
 	case LogicalTypeId::BIGINT:
 		return Value::BIGINT(((int64_t *)data)[index]);
 	case LogicalTypeId::UTINYINT:
@@ -41548,6 +41767,8 @@ Value Vector::GetValue(idx_t index) const {
 		return Value::TimestampMs(((timestamp_t *)data)[index]);
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return Value::TimestampSec(((timestamp_t *)data)[index]);
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Value::TIMESTAMPTZ(((timestamp_t *)data)[index]);
 	case LogicalTypeId::HUGEINT:
 		return Value::HUGEINT(((hugeint_t *)data)[index]);
 	case LogicalTypeId::UUID:
@@ -42121,7 +42342,7 @@ void Vector::Verify(const SelectionVector &sel, idx_t count) {
 
 	if (GetType().InternalType() == PhysicalType::STRUCT) {
 		auto &child_types = StructType::GetChildTypes(GetType());
-		D_ASSERT(child_types.size() > 0);
+		D_ASSERT(!child_types.empty());
 		if (GetVectorType() == VectorType::FLAT_VECTOR || GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			// create a selection vector of the non-null entries of the struct vector
 			auto &children = StructVector::GetEntries(*this);
@@ -42551,13 +42772,16 @@ vector<idx_t> ListVector::Search(Vector &list, Value &key, idx_t row) {
 		                                       entry.length);
 		break;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		::duckdb::TemplatedSearchInMap<date_t>(list, key.value_.date, offsets, key.is_null, entry.offset, entry.length);
 		break;
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		::duckdb::TemplatedSearchInMap<dtime_t>(list, key.value_.time, offsets, key.is_null, entry.offset,
 		                                        entry.length);
 		break;
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		::duckdb::TemplatedSearchInMap<timestamp_t>(list, key.value_.timestamp, offsets, key.is_null, entry.offset,
 		                                            entry.length);
 		break;
@@ -43354,6 +43578,7 @@ PhysicalType LogicalType::GetInternalType() {
 		return PhysicalType::UINT16;
 	case LogicalTypeId::SQLNULL:
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 	case LogicalTypeId::INTEGER:
 		return PhysicalType::INT32;
 	case LogicalTypeId::UINTEGER:
@@ -43364,6 +43589,8 @@ PhysicalType LogicalType::GetInternalType() {
 	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::TIMESTAMP_NS:
 	case LogicalTypeId::TIMESTAMP_MS:
+	case LogicalTypeId::TIME_TZ:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return PhysicalType::INT64;
 	case LogicalTypeId::UBIGINT:
 		return PhysicalType::UINT64;
@@ -43457,6 +43684,11 @@ constexpr const LogicalTypeId LogicalType::TIMESTAMP_NS;
 constexpr const LogicalTypeId LogicalType::TIMESTAMP_S;
 
 constexpr const LogicalTypeId LogicalType::TIME;
+
+constexpr const LogicalTypeId LogicalType::DATE_TZ;
+constexpr const LogicalTypeId LogicalType::TIME_TZ;
+constexpr const LogicalTypeId LogicalType::TIMESTAMP_TZ;
+
 constexpr const LogicalTypeId LogicalType::HASH;
 constexpr const LogicalTypeId LogicalType::POINTER;
 
@@ -43485,7 +43717,8 @@ const vector<LogicalType> LogicalType::ALL_TYPES = {
     LogicalType::FLOAT,    LogicalType::VARCHAR,   LogicalType::BLOB,      LogicalType::INTERVAL,
     LogicalType::HUGEINT,  LogicalTypeId::DECIMAL, LogicalType::UTINYINT,  LogicalType::USMALLINT,
     LogicalType::UINTEGER, LogicalType::UBIGINT,   LogicalType::TIME,      LogicalTypeId::LIST,
-    LogicalTypeId::STRUCT, LogicalTypeId::MAP,     LogicalType::UUID};
+    LogicalTypeId::STRUCT, LogicalType::DATE_TZ,   LogicalType::TIME_TZ,   LogicalType::TIMESTAMP_TZ,
+    LogicalTypeId::MAP,    LogicalType::UUID};
 
 const LogicalType LOGICAL_ROW_TYPE = LogicalType::BIGINT;
 const PhysicalType ROW_TYPE = PhysicalType::INT64;
@@ -43667,6 +43900,12 @@ string LogicalTypeIdToString(LogicalTypeId id) {
 		return "TIMESTAMP (NS)";
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return "TIMESTAMP (SEC)";
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return "TIMESTAMP WITH TIME ZONE";
+	case LogicalTypeId::TIME_TZ:
+		return "TIME WITH TIME ZONE";
+	case LogicalTypeId::DATE_TZ:
+		return "DATE WITH TIME ZONE";
 	case LogicalTypeId::FLOAT:
 		return "FLOAT";
 	case LogicalTypeId::DOUBLE:
@@ -43824,6 +44063,12 @@ LogicalTypeId TransformStringToLogicalType(const string &str) {
 		return LogicalTypeId::UINTEGER;
 	} else if (lower_str == "ubigint" || lower_str == "uint64") {
 		return LogicalTypeId::UBIGINT;
+	} else if (lower_str == "timestamptz") {
+		return LogicalTypeId::TIMESTAMP_TZ;
+	} else if (lower_str == "timetz") {
+		return LogicalTypeId::TIME_TZ;
+	} else if (lower_str == "datetz") {
+		return LogicalTypeId::DATE_TZ;
 	} else {
 		// This is a User Type, at this point we don't know if its one of the User Defined Types or an error
 		// It is checked in the binder
@@ -47281,12 +47526,15 @@ static bool StringCastSwitch(Vector &source, Vector &result, idx_t count, bool s
 	// now switch on the result type
 	switch (result.GetType().id()) {
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		return VectorTryCastErrorLoop<string_t, date_t, duckdb::TryCastErrorMessage>(source, result, count, strict,
 		                                                                             error_message);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return VectorTryCastErrorLoop<string_t, dtime_t, duckdb::TryCastErrorMessage>(source, result, count, strict,
 		                                                                              error_message);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return VectorTryCastErrorLoop<string_t, timestamp_t, duckdb::TryCastErrorMessage>(source, result, count, strict,
 		                                                                                  error_message);
 	case LogicalTypeId::TIMESTAMP_NS:
@@ -47319,8 +47567,34 @@ static bool DateCastSwitch(Vector &source, Vector &result, idx_t count, string *
 		VectorStringCast<date_t, duckdb::StringCast>(source, result, count);
 		return true;
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		// date to timestamp
 		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCast>(source, result, count, error_message);
+	case LogicalTypeId::DATE_TZ:
+		// date to date with time zone
+		UnaryExecutor::Execute<date_t, date_t, duckdb::Cast>(source, result, count);
+		return true;
+	default:
+		return TryVectorNullCast(source, result, count, error_message);
+	}
+}
+
+static bool DateTzCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
+	// now switch on the result type
+	switch (result.GetType().id()) {
+	case LogicalTypeId::VARCHAR:
+		// date with time zone to varchar
+		VectorStringCast<date_t, duckdb::StringCastTZ>(source, result, count);
+		return true;
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
+		// date with time zone to timestamp
+		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCast>(source, result, count, error_message);
+	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
+		// date with time zone to date
+		UnaryExecutor::Execute<date_t, date_t, duckdb::Cast>(source, result, count);
+		return true;
 	default:
 		return TryVectorNullCast(source, result, count, error_message);
 	}
@@ -47333,6 +47607,26 @@ static bool TimeCastSwitch(Vector &source, Vector &result, idx_t count, string *
 		// time to varchar
 		VectorStringCast<dtime_t, duckdb::StringCast>(source, result, count);
 		return true;
+	case LogicalTypeId::TIME_TZ:
+		// time to time with time zone
+		UnaryExecutor::Execute<dtime_t, dtime_t, duckdb::Cast>(source, result, count);
+		return true;
+	default:
+		return TryVectorNullCast(source, result, count, error_message);
+	}
+}
+
+static bool TimeTzCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
+	// now switch on the result type
+	switch (result.GetType().id()) {
+	case LogicalTypeId::VARCHAR:
+		// time with time zone to varchar
+		VectorStringCast<dtime_t, duckdb::StringCastTZ>(source, result, count);
+		return true;
+	case LogicalTypeId::TIME:
+		// time with time zone to time
+		UnaryExecutor::Execute<dtime_t, dtime_t, duckdb::Cast>(source, result, count);
+		return true;
 	default:
 		return TryVectorNullCast(source, result, count, error_message);
 	}
@@ -47346,13 +47640,19 @@ static bool TimestampCastSwitch(Vector &source, Vector &result, idx_t count, str
 		VectorStringCast<timestamp_t, duckdb::StringCast>(source, result, count);
 		break;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		// timestamp to date
 		UnaryExecutor::Execute<timestamp_t, date_t, duckdb::Cast>(source, result, count);
 		break;
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		// timestamp to time
 		UnaryExecutor::Execute<timestamp_t, dtime_t, duckdb::Cast>(source, result, count);
 		break;
+	case LogicalTypeId::TIMESTAMP_TZ:
+		// timestamp (us) to timestamp with time zone
+		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::Cast>(source, result, count);
+		break;
 	case LogicalTypeId::TIMESTAMP_NS:
 		// timestamp (us) to timestamp (ns)
 		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::CastTimestampUsToNs>(source, result, count);
@@ -47371,6 +47671,33 @@ static bool TimestampCastSwitch(Vector &source, Vector &result, idx_t count, str
 	return true;
 }
 
+static bool TimestampTzCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
+	// now switch on the result type
+	switch (result.GetType().id()) {
+	case LogicalTypeId::VARCHAR:
+		// timestamp with time zone to varchar
+		VectorStringCast<timestamp_t, duckdb::StringCastTZ>(source, result, count);
+		break;
+	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
+		// timestamp with time zone to date
+		UnaryExecutor::Execute<timestamp_t, date_t, duckdb::Cast>(source, result, count);
+		break;
+	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
+		// timestamp with time zone to time
+		UnaryExecutor::Execute<timestamp_t, dtime_t, duckdb::Cast>(source, result, count);
+		break;
+	case LogicalTypeId::TIMESTAMP:
+		// timestamp with time zone to timestamp (us)
+		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::Cast>(source, result, count);
+		break;
+	default:
+		return TryVectorNullCast(source, result, count, error_message);
+	}
+	return true;
+}
+
 static bool TimestampNsCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
 	// now switch on the result type
 	switch (result.GetType().id()) {
@@ -47719,10 +48046,16 @@ bool VectorOperations::TryCast(Vector &source, Vector &result, idx_t count, stri
 		return NumericCastSwitch<double>(source, result, count, error_message);
 	case LogicalTypeId::DATE:
 		return DateCastSwitch(source, result, count, error_message);
+	case LogicalTypeId::DATE_TZ:
+		return DateTzCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::TIME:
 		return TimeCastSwitch(source, result, count, error_message);
+	case LogicalTypeId::TIME_TZ:
+		return TimeTzCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::TIMESTAMP:
 		return TimestampCastSwitch(source, result, count, error_message);
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return TimestampTzCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::TIMESTAMP_NS:
 		return TimestampNsCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::TIMESTAMP_MS:
@@ -73414,6 +73747,12 @@ struct ApproxCountDistinctFunctionString : ApproxCountDistinctFunctionBase {
 	}
 };
 
+template <typename INPUT_TYPE, typename RESULT_TYPE>
+AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type, const LogicalType &result_type) {
+	return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, INPUT_TYPE, RESULT_TYPE,
+	                                                   ApproxCountDistinctFunction>(input_type, result_type);
+}
+
 AggregateFunction GetApproxCountDistinctFunction(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::UINT16:
@@ -73469,9 +73808,10 @@ void ApproxCountDistinctFun::RegisterFunction(BuiltinFunctions &set) {
 	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::INT64));
 	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::DOUBLE));
 	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::VARCHAR));
-	approx_count.AddFunction(AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, int64_t, int64_t,
-	                                                                     ApproxCountDistinctFunction>(
-	    LogicalType::TIMESTAMP, LogicalType::BIGINT));
+	approx_count.AddFunction(
+	    GetApproxCountDistinctFunction<int64_t, int64_t>(LogicalType::TIMESTAMP, LogicalType::BIGINT));
+	approx_count.AddFunction(
+	    GetApproxCountDistinctFunction<int64_t, int64_t>(LogicalType::TIMESTAMP_TZ, LogicalType::BIGINT));
 	set.AddFunction(approx_count);
 }
 
@@ -73602,6 +73942,12 @@ AggregateFunction GetArgMinMaxFunctionArg2(LogicalTypeId arg_2, const LogicalTyp
 	case LogicalTypeId::TIMESTAMP:
 		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, timestamp_t>, T, timestamp_t, T, OP>(
 		    arg, LogicalType::TIMESTAMP, arg);
+	case LogicalTypeId::DATE_TZ:
+		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, date_t>, T, date_t, T, OP>(
+		    arg, LogicalType::DATE_TZ, arg);
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, timestamp_t>, T, timestamp_t, T, OP>(
+		    arg, LogicalType::TIMESTAMP_TZ, arg);
 	case LogicalTypeId::BLOB:
 		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, string_t>, T, string_t, T, OP>(
 		    arg, LogicalType::BLOB, arg);
@@ -73620,6 +73966,8 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::VARCHAR, LogicalType::INTEGER));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::DATE, LogicalType::INTEGER));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::TIMESTAMP, LogicalType::INTEGER));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::DATE_TZ, LogicalType::INTEGER));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::INTEGER));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::BLOB, LogicalType::INTEGER));
 		break;
 	case LogicalTypeId::BIGINT:
@@ -73629,6 +73977,8 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::VARCHAR, LogicalType::BIGINT));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::DATE, LogicalType::BIGINT));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::TIMESTAMP, LogicalType::BIGINT));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::DATE_TZ, LogicalType::BIGINT));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::BIGINT));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::BLOB, LogicalType::BIGINT));
 		break;
 	case LogicalTypeId::DOUBLE:
@@ -73638,6 +73988,8 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::VARCHAR, LogicalType::DOUBLE));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::DATE, LogicalType::DOUBLE));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::TIMESTAMP, LogicalType::DOUBLE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::DATE_TZ, LogicalType::DOUBLE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::DOUBLE));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::BLOB, LogicalType::DOUBLE));
 		break;
 	case LogicalTypeId::VARCHAR:
@@ -73647,6 +73999,8 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::VARCHAR, LogicalType::VARCHAR));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DATE, LogicalType::VARCHAR));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP, LogicalType::VARCHAR));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DATE_TZ, LogicalType::VARCHAR));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::VARCHAR));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::BLOB, LogicalType::VARCHAR));
 		break;
 	case LogicalTypeId::DATE:
@@ -73656,6 +74010,19 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::VARCHAR, LogicalType::DATE));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DATE, LogicalType::DATE));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::TIMESTAMP, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DATE_TZ, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::BLOB, LogicalType::DATE));
+		break;
+	case LogicalTypeId::DATE_TZ:
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::INTEGER, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::BIGINT, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DOUBLE, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::VARCHAR, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DATE, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::TIMESTAMP, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DATE_TZ, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::DATE_TZ));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::BLOB, LogicalType::DATE));
 		break;
 	case LogicalTypeId::TIMESTAMP:
@@ -73665,8 +74032,22 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::VARCHAR, LogicalType::TIMESTAMP));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DATE, LogicalType::TIMESTAMP));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP, LogicalType::TIMESTAMP));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DATE_TZ, LogicalType::TIMESTAMP));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::TIMESTAMP));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BLOB, LogicalType::TIMESTAMP));
 		break;
+	case LogicalTypeId::TIMESTAMP_TZ:
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::INTEGER, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BIGINT, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DOUBLE, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::VARCHAR, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DATE, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DATE_TZ, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(
+		    GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BLOB, LogicalType::TIMESTAMP_TZ));
+		break;
 	case LogicalTypeId::BLOB:
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::INTEGER, LogicalType::BLOB));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::BIGINT, LogicalType::BLOB));
@@ -73674,6 +74055,8 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::VARCHAR, LogicalType::BLOB));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DATE, LogicalType::BLOB));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP, LogicalType::BLOB));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DATE_TZ, LogicalType::BLOB));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::BLOB));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::BLOB, LogicalType::BLOB));
 		break;
 	default:
@@ -73688,6 +74071,8 @@ void ArgMinFun::RegisterFunction(BuiltinFunctions &set) {
 	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::VARCHAR, fun);
 	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::DATE, fun);
 	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::TIMESTAMP, fun);
+	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::DATE_TZ, fun);
+	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::TIMESTAMP_TZ, fun);
 	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::BLOB, fun);
 	set.AddFunction(fun);
 
@@ -73708,6 +74093,8 @@ void ArgMaxFun::RegisterFunction(BuiltinFunctions &set) {
 	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::VARCHAR, fun);
 	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::DATE, fun);
 	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::TIMESTAMP, fun);
+	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::DATE_TZ, fun);
+	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::TIMESTAMP_TZ, fun);
 	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::BLOB, fun);
 	set.AddFunction(fun);
 
@@ -74274,6 +74661,12 @@ struct EntropyFunctionString : EntropyFunctionBase {
 	}
 };
 
+template <typename INPUT_TYPE, typename RESULT_TYPE>
+AggregateFunction GetEntropyFunction(const LogicalType &input_type, const LogicalType &result_type) {
+	return AggregateFunction::UnaryAggregateDestructor<EntropyState<INPUT_TYPE>, INPUT_TYPE, RESULT_TYPE,
+	                                                   EntropyFunction>(input_type, result_type);
+}
+
 AggregateFunction GetEntropyFunction(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::UINT16:
@@ -74321,9 +74714,8 @@ void EntropyFun::RegisterFunction(BuiltinFunctions &set) {
 	entropy.AddFunction(GetEntropyFunction(PhysicalType::INT64));
 	entropy.AddFunction(GetEntropyFunction(PhysicalType::DOUBLE));
 	entropy.AddFunction(GetEntropyFunction(PhysicalType::VARCHAR));
-	entropy.AddFunction(
-	    AggregateFunction::UnaryAggregateDestructor<EntropyState<int64_t>, int64_t, double, EntropyFunction>(
-	        LogicalType::TIMESTAMP, LogicalType::DOUBLE));
+	entropy.AddFunction(GetEntropyFunction<int64_t, double>(LogicalType::TIMESTAMP, LogicalType::DOUBLE));
+	entropy.AddFunction(GetEntropyFunction<int64_t, double>(LogicalType::TIMESTAMP_TZ, LogicalType::DOUBLE));
 	set.AddFunction(entropy);
 }
 
@@ -74562,10 +74954,13 @@ static AggregateFunction GetFirstFunction(const LogicalType &type) {
 		return GetFirstAggregateTemplated<int16_t, LAST>(type);
 	case LogicalTypeId::INTEGER:
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		return GetFirstAggregateTemplated<int32_t, LAST>(type);
 	case LogicalTypeId::BIGINT:
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIME_TZ:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetFirstAggregateTemplated<int64_t, LAST>(type);
 	case LogicalTypeId::UTINYINT:
 		return GetFirstAggregateTemplated<uint8_t, LAST>(type);
@@ -74767,10 +75162,13 @@ static AggregateFunction GetUnaryAggregate(LogicalType type) {
 	case LogicalTypeId::SMALLINT:
 		return AggregateFunction::UnaryAggregate<MinMaxState<int16_t>, int16_t, int16_t, OP>(type, type);
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 	case LogicalTypeId::INTEGER:
 		return AggregateFunction::UnaryAggregate<MinMaxState<int32_t>, int32_t, int32_t, OP>(type, type);
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIMESTAMP_TZ:
+	case LogicalTypeId::TIME_TZ:
 	case LogicalTypeId::BIGINT:
 		return AggregateFunction::UnaryAggregate<MinMaxState<int64_t>, int64_t, int64_t, OP>(type, type);
 	case LogicalTypeId::UTINYINT:
@@ -76979,7 +77377,8 @@ unique_ptr<FunctionData> BindModeDecimal(ClientContext &context, AggregateFuncti
 }
 
 void ModeFun::RegisterFunction(BuiltinFunctions &set) {
-	const vector<LogicalType> TEMPORAL = {LogicalType::DATE, LogicalType::TIMESTAMP, LogicalType::TIME,
+	const vector<LogicalType> TEMPORAL = {LogicalType::DATE,    LogicalType::TIMESTAMP,    LogicalType::TIME,
+	                                      LogicalType::DATE_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ,
 	                                      LogicalType::INTERVAL};
 
 	AggregateFunctionSet mode("mode");
@@ -77600,10 +77999,13 @@ AggregateFunction GetDiscreteQuantileAggregateFunction(const LogicalType &type)
 		break;
 
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		return GetTypedDiscreteQuantileAggregateFunction<int32_t, int32_t>(type);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
 	case LogicalTypeId::INTERVAL:
 		return GetTypedDiscreteQuantileAggregateFunction<interval_t, interval_t>(type);
@@ -77789,10 +78191,13 @@ AggregateFunction GetDiscreteQuantileListAggregateFunction(const LogicalType &ty
 		break;
 
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		return GetTypedDiscreteQuantileListAggregateFunction<date_t, date_t>(type);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetTypedDiscreteQuantileListAggregateFunction<timestamp_t, timestamp_t>(type);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return GetTypedDiscreteQuantileListAggregateFunction<dtime_t, dtime_t>(type);
 	case LogicalTypeId::INTERVAL:
 		return GetTypedDiscreteQuantileListAggregateFunction<interval_t, interval_t>(type);
@@ -77850,8 +78255,10 @@ AggregateFunction GetContinuousQuantileAggregateFunction(const LogicalType &type
 	case LogicalTypeId::DATE:
 		return GetTypedContinuousQuantileAggregateFunction<date_t, timestamp_t>(type, LogicalType::TIMESTAMP);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetTypedContinuousQuantileAggregateFunction<timestamp_t, timestamp_t>(type, type);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return GetTypedContinuousQuantileAggregateFunction<dtime_t, dtime_t>(type, type);
 
 	default:
@@ -77904,8 +78311,10 @@ AggregateFunction GetContinuousQuantileListAggregateFunction(const LogicalType &
 	case LogicalTypeId::DATE:
 		return GetTypedContinuousQuantileListAggregateFunction<date_t, timestamp_t>(type, LogicalType::TIMESTAMP);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetTypedContinuousQuantileListAggregateFunction<timestamp_t, timestamp_t>(type, type);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return GetTypedContinuousQuantileListAggregateFunction<dtime_t, dtime_t>(type, type);
 
 	default:
@@ -78116,9 +78525,11 @@ AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType
 		return GetTypedMedianAbsoluteDeviationAggregateFunction<date_t, timestamp_t, interval_t>(type,
 		                                                                                         LogicalType::INTERVAL);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetTypedMedianAbsoluteDeviationAggregateFunction<timestamp_t, timestamp_t, interval_t>(
 		    type, LogicalType::INTERVAL);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return GetTypedMedianAbsoluteDeviationAggregateFunction<dtime_t, dtime_t, interval_t>(type,
 		                                                                                      LogicalType::INTERVAL);
 
@@ -78211,6 +78622,8 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimalList(ClientContext &contex
 
 static bool CanInterpolate(const LogicalType &type) {
 	switch (type.id()) {
+	case LogicalTypeId::DATE_TZ:
+		// DATE_TZ cannot be interpolated without a time zone
 	case LogicalTypeId::INTERVAL:
 	case LogicalTypeId::VARCHAR:
 		return false;
@@ -78264,7 +78677,8 @@ void QuantileFun::RegisterFunction(BuiltinFunctions &set) {
 	const vector<LogicalType> QUANTILES = {LogicalType::TINYINT, LogicalType::SMALLINT, LogicalType::INTEGER,
 	                                       LogicalType::BIGINT,  LogicalType::HUGEINT,  LogicalType::FLOAT,
 	                                       LogicalType::DOUBLE,  LogicalType::DATE,     LogicalType::TIMESTAMP,
-	                                       LogicalType::TIME,    LogicalType::INTERVAL, LogicalType::VARCHAR};
+	                                       LogicalType::TIME,    LogicalType::DATE_TZ,  LogicalType::TIMESTAMP_TZ,
+	                                       LogicalType::TIME_TZ, LogicalType::INTERVAL, LogicalType::VARCHAR};
 
 	AggregateFunctionSet median("median");
 	median.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
@@ -78307,8 +78721,9 @@ void QuantileFun::RegisterFunction(BuiltinFunctions &set) {
 	mad.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
 	                                  nullptr, nullptr, nullptr, BindMedianAbsoluteDeviationDecimal));
 
-	const vector<LogicalType> MADS = {LogicalType::FLOAT, LogicalType::DOUBLE, LogicalType::DATE,
-	                                  LogicalType::TIMESTAMP, LogicalType::TIME};
+	const vector<LogicalType> MADS = {LogicalType::FLOAT,     LogicalType::DOUBLE, LogicalType::DATE,
+	                                  LogicalType::TIMESTAMP, LogicalType::TIME,   LogicalType::TIMESTAMP_TZ,
+	                                  LogicalType::TIME_TZ};
 	for (const auto &type : MADS) {
 		mad.AddFunction(GetMedianAbsoluteDeviationAggregateFunction(type));
 	}
@@ -78827,6 +79242,15 @@ unique_ptr<FunctionData> HistogramBindFunction(ClientContext &context, Aggregate
 	return make_unique<VariableReturnBindData>(function.return_type);
 }
 
+template <typename T>
+AggregateFunction GetHistogramFunction(const LogicalType &type) {
+	using STATE_TYPE = HistogramAggState<T>;
+	return AggregateFunction("histogram", {type}, LogicalTypeId::MAP, AggregateFunction::StateSize<STATE_TYPE>,
+	                         AggregateFunction::StateInitialize<STATE_TYPE, HistogramFunction>,
+	                         HistogramUpdateFunction<T>, HistogramCombineFunction<T>, HistogramFinalize<T>, nullptr,
+	                         HistogramBindFunction, AggregateFunction::StateDestroy<STATE_TYPE, HistogramFunction>);
+}
+
 AggregateFunction GetHistogramFunction(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::UINT16:
@@ -78909,12 +79333,8 @@ void HistogramFun::RegisterFunction(BuiltinFunctions &set) {
 	fun.AddFunction(GetHistogramFunction(PhysicalType::FLOAT));
 	fun.AddFunction(GetHistogramFunction(PhysicalType::DOUBLE));
 	fun.AddFunction(GetHistogramFunction(PhysicalType::VARCHAR));
-	fun.AddFunction(AggregateFunction("histogram", {LogicalType::TIMESTAMP}, LogicalTypeId::MAP,
-	                                  AggregateFunction::StateSize<HistogramAggState<int64_t>>,
-	                                  AggregateFunction::StateInitialize<HistogramAggState<int64_t>, HistogramFunction>,
-	                                  HistogramUpdateFunction<int64_t>, HistogramCombineFunction<int64_t>,
-	                                  HistogramFinalize<int64_t>, nullptr, HistogramBindFunction,
-	                                  AggregateFunction::StateDestroy<HistogramAggState<int64_t>, HistogramFunction>));
+	fun.AddFunction(GetHistogramFunction<int64_t>(LogicalType::TIMESTAMP));
+	fun.AddFunction(GetHistogramFunction<int64_t>(LogicalType::TIMESTAMP_TZ));
 	set.AddFunction(fun);
 }
 
@@ -85123,14 +85543,14 @@ static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vecto
 	result.SetVectorType(result_type);
 }
 
+template <typename T, class OP>
+ScalarFunction GetLeastGreatestFunction(const LogicalType &type) {
+	return ScalarFunction({type}, type, LeastGreatestFunction<T, OP>, false, nullptr, nullptr, nullptr, nullptr, type);
+}
+
 template <class OP>
 static void RegisterLeastGreatest(BuiltinFunctions &set, const string &fun_name) {
 	ScalarFunctionSet fun_set(fun_name);
-	fun_set.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::DATE, LeastGreatestFunction<date_t, OP>, false,
-	                                   nullptr, nullptr, nullptr, nullptr, LogicalType::DATE));
-	fun_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
-	                                   LeastGreatestFunction<timestamp_t, OP>, false, nullptr, nullptr, nullptr,
-	                                   nullptr, LogicalType::TIMESTAMP));
 	fun_set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::BIGINT, LeastGreatestFunction<int64_t, OP>,
 	                                   false, nullptr, nullptr, nullptr, nullptr, LogicalType::BIGINT));
 	fun_set.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::HUGEINT,
@@ -85141,6 +85561,15 @@ static void RegisterLeastGreatest(BuiltinFunctions &set, const string &fun_name)
 	fun_set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                                   LeastGreatestFunction<string_t, OP, true>, false, nullptr, nullptr, nullptr,
 	                                   nullptr, LogicalType::VARCHAR));
+
+	fun_set.AddFunction(GetLeastGreatestFunction<timestamp_t, OP>(LogicalType::TIMESTAMP));
+	fun_set.AddFunction(GetLeastGreatestFunction<time_t, OP>(LogicalType::TIME));
+	fun_set.AddFunction(GetLeastGreatestFunction<date_t, OP>(LogicalType::DATE));
+
+	fun_set.AddFunction(GetLeastGreatestFunction<timestamp_t, OP>(LogicalType::TIMESTAMP_TZ));
+	fun_set.AddFunction(GetLeastGreatestFunction<time_t, OP>(LogicalType::TIME_TZ));
+	fun_set.AddFunction(GetLeastGreatestFunction<date_t, OP>(LogicalType::DATE_TZ));
+
 	set.AddFunction(fun_set);
 }
 
@@ -85708,12 +86137,15 @@ static void ExecuteListExtractInternal(const idx_t count, VectorData &list, Vect
 		ListExtractTemplate<double>(count, list, offsets, child_vector, list_size, result);
 		break;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		ListExtractTemplate<date_t>(count, list, offsets, child_vector, list_size, result);
 		break;
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		ListExtractTemplate<dtime_t>(count, list, offsets, child_vector, list_size, result);
 		break;
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		ListExtractTemplate<timestamp_t>(count, list, offsets, child_vector, list_size, result);
 		break;
 	case LogicalTypeId::BLOB:
@@ -88138,8 +88570,8 @@ ScalarFunction AddFun::GetFunction(const LogicalType &left_type, const LogicalTy
 		}
 		break;
 	case LogicalTypeId::INTEGER:
-		if (right_type.id() == LogicalTypeId::DATE) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::DATE,
+		if (right_type.id() == LogicalTypeId::DATE || right_type.id() == LogicalTypeId::DATE_TZ) {
+			return ScalarFunction("+", {left_type, right_type}, right_type,
 			                      ScalarFunction::BinaryFunction<int32_t, date_t, date_t, AddOperator>);
 		}
 		break;
@@ -88170,6 +88602,12 @@ ScalarFunction AddFun::GetFunction(const LogicalType &left_type, const LogicalTy
 			                      ScalarFunction::BinaryFunction<timestamp_t, interval_t, timestamp_t, AddOperator>);
 		}
 		break;
+	case LogicalTypeId::DATE_TZ:
+		if (right_type.id() == LogicalTypeId::INTEGER) {
+			return ScalarFunction("+", {left_type, right_type}, left_type,
+			                      ScalarFunction::BinaryFunction<date_t, int32_t, date_t, AddOperator>);
+		}
+		break;
 	default:
 		break;
 	}
@@ -88190,6 +88628,8 @@ void AddFun::RegisterFunction(BuiltinFunctions &set) {
 	// we can add integers to dates
 	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::INTEGER));
 	functions.AddFunction(GetFunction(LogicalType::INTEGER, LogicalType::DATE));
+	functions.AddFunction(GetFunction(LogicalType::DATE_TZ, LogicalType::INTEGER));
+	functions.AddFunction(GetFunction(LogicalType::INTEGER, LogicalType::DATE_TZ));
 	// we can add intervals together
 	functions.AddFunction(GetFunction(LogicalType::INTERVAL, LogicalType::INTERVAL));
 	// we can add intervals to dates/times/timestamps
@@ -88360,6 +88800,15 @@ ScalarFunction SubtractFun::GetFunction(const LogicalType &left_type, const Logi
 			                      ScalarFunction::BinaryFunction<dtime_t, interval_t, dtime_t, SubtractTimeOperator>);
 		}
 		break;
+	case LogicalTypeId::DATE_TZ:
+		if (right_type.id() == LogicalTypeId::DATE_TZ) {
+			return ScalarFunction("-", {left_type, right_type}, LogicalType::BIGINT,
+			                      ScalarFunction::BinaryFunction<date_t, date_t, int64_t, SubtractOperator>);
+		} else if (right_type.id() == LogicalTypeId::INTEGER) {
+			return ScalarFunction("-", {left_type, right_type}, left_type,
+			                      ScalarFunction::BinaryFunction<date_t, int32_t, date_t, SubtractOperator>);
+		}
+		break;
 	default:
 		break;
 	}
@@ -88379,7 +88828,10 @@ void SubtractFun::RegisterFunction(BuiltinFunctions &set) {
 	}
 	// we can subtract dates from each other
 	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::DATE));
+	functions.AddFunction(GetFunction(LogicalType::DATE_TZ, LogicalType::DATE_TZ));
+	// we can subtract integers from dates
 	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::INTEGER));
+	functions.AddFunction(GetFunction(LogicalType::DATE_TZ, LogicalType::INTEGER));
 	// we can subtract timestamps from each other
 	functions.AddFunction(GetFunction(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP));
 	// we can subtract intervals from each other
@@ -99162,6 +99614,9 @@ void DuckDBTypesFunction(ClientContext &context, const FunctionData *bind_data,
 		case LogicalTypeId::TIMESTAMP:
 		case LogicalTypeId::TIMESTAMP_NS:
 		case LogicalTypeId::INTERVAL:
+		case LogicalTypeId::DATE_TZ:
+		case LogicalTypeId::TIME_TZ:
+		case LogicalTypeId::TIMESTAMP_TZ:
 			category = "DATETIME";
 			break;
 		case LogicalTypeId::CHAR:
@@ -101552,10 +102007,13 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
 	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::TIMESTAMP_MS:
 	case LogicalTypeId::TIMESTAMP_NS:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return DUCKDB_TYPE_TIMESTAMP;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		return DUCKDB_TYPE_DATE;
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return DUCKDB_TYPE_TIME;
 	case LogicalTypeId::VARCHAR:
 		return DUCKDB_TYPE_VARCHAR;
@@ -101940,12 +102398,15 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 			WriteData<double>(out, result->collection, col);
 			break;
 		case LogicalTypeId::DATE:
+		case LogicalTypeId::DATE_TZ:
 			WriteData<date_t>(out, result->collection, col);
 			break;
 		case LogicalTypeId::TIME:
+		case LogicalTypeId::TIME_TZ:
 			WriteData<dtime_t>(out, result->collection, col);
 			break;
 		case LogicalTypeId::TIMESTAMP:
+		case LogicalTypeId::TIMESTAMP_TZ:
 			WriteData<timestamp_t>(out, result->collection, col);
 			break;
 		case LogicalTypeId::VARCHAR: {
@@ -102054,7 +102515,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 
 } // namespace duckdb
 
-static void duckdb_destroy_column(duckdb_column column, idx_t count) {
+static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
 	if (column.data) {
 		if (column.type == DUCKDB_TYPE_VARCHAR) {
 			// varchar, delete individual strings
@@ -102089,7 +102550,7 @@ void duckdb_destroy_result(duckdb_result *result) {
 	}
 	if (result->columns) {
 		for (idx_t i = 0; i < result->column_count; i++) {
-			duckdb_destroy_column(result->columns[i], result->row_count);
+			DuckdbDestroyColumn(result->columns[i], result->row_count);
 		}
 		duckdb_free(result->columns);
 	}
@@ -113854,12 +114315,15 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		child.format = "u";
 		break;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		child.format = "tdD";
 		break;
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		child.format = "ttu";
 		break;
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		child.format = "tsu:";
 		break;
 	case LogicalTypeId::TIMESTAMP_SEC:
@@ -144301,7 +144765,11 @@ unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGNode *
 	// get file_path and is_from
 	info.file_path = stmt->filename;
 	info.is_from = stmt->is_from;
-	info.format = "csv";
+	if (StringUtil::EndsWith(info.file_path, ".parquet")) {
+		info.format = "parquet";
+	} else {
+		info.format = "csv";
+	}
 
 	// get select_list
 	if (stmt->attlist) {
@@ -153263,18 +153731,48 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 		}
 		return true;
 	}
-	if (source_type.id() == LogicalTypeId::TIMESTAMP && target_type.id() == LogicalTypeId::DATE) {
-		return false;
+	if (source_type.id() == LogicalTypeId::TIMESTAMP || source_type.id() == LogicalTypeId::TIMESTAMP_TZ) {
+		switch (target_type.id()) {
+		case LogicalTypeId::DATE:
+		case LogicalTypeId::TIME:
+		case LogicalTypeId::DATE_TZ:
+		case LogicalTypeId::TIME_TZ:
+			return false;
+		default:
+			break;
+		}
 	}
 	if (source_type.id() == LogicalTypeId::VARCHAR) {
-		return target_type.id() == LogicalTypeId::DATE || target_type.id() == LogicalTypeId::TIME ||
-		       target_type.id() == LogicalTypeId::TIMESTAMP || target_type.id() == LogicalTypeId::TIMESTAMP_NS ||
-		       target_type.id() == LogicalTypeId::TIMESTAMP_MS || target_type.id() == LogicalTypeId::TIMESTAMP_SEC;
+		switch (target_type.id()) {
+		case LogicalTypeId::DATE:
+		case LogicalTypeId::TIME:
+		case LogicalTypeId::TIMESTAMP:
+		case LogicalTypeId::TIMESTAMP_NS:
+		case LogicalTypeId::TIMESTAMP_MS:
+		case LogicalTypeId::TIMESTAMP_SEC:
+		case LogicalTypeId::DATE_TZ:
+		case LogicalTypeId::TIME_TZ:
+		case LogicalTypeId::TIMESTAMP_TZ:
+			return true;
+		default:
+			return false;
+		}
 	}
 	if (target_type.id() == LogicalTypeId::VARCHAR) {
-		return source_type.id() == LogicalTypeId::DATE || source_type.id() == LogicalTypeId::TIME ||
-		       source_type.id() == LogicalTypeId::TIMESTAMP || source_type.id() == LogicalTypeId::TIMESTAMP_NS ||
-		       source_type.id() == LogicalTypeId::TIMESTAMP_MS || source_type.id() == LogicalTypeId::TIMESTAMP_SEC;
+		switch (source_type.id()) {
+		case LogicalTypeId::DATE:
+		case LogicalTypeId::TIME:
+		case LogicalTypeId::TIMESTAMP:
+		case LogicalTypeId::TIMESTAMP_NS:
+		case LogicalTypeId::TIMESTAMP_MS:
+		case LogicalTypeId::TIMESTAMP_SEC:
+		case LogicalTypeId::DATE_TZ:
+		case LogicalTypeId::TIME_TZ:
+		case LogicalTypeId::TIMESTAMP_TZ:
+			return true;
+		default:
+			return false;
+		}
 	}
 	return true;
 }