duckdb 0.3.2-dev858.0 → 0.3.2-dev874.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev858.0",
+  "version": "0.3.2-dev874.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -21031,31 +21031,6 @@ 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];
@@ -30387,7 +30362,6 @@ 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);
@@ -32484,7 +32458,7 @@ interval_parse_time : {
 	// parse the remainder of the time as a Time type
 	dtime_t time;
 	idx_t pos;
-	if (!Time::TryConvertTime(str + start_pos, len, pos, time)) {
+	if (!Time::TryConvertTime(str + start_pos, len - start_pos, pos, time)) {
 		return false;
 	}
 	result.micros += time.micros;
@@ -34083,8 +34057,6 @@ Value Value::MinimumValue(const LogicalType &type) {
 		return MinimumValue(LogicalType::TIMESTAMP).CastAs(LogicalType::TIMESTAMP_MS);
 	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:
@@ -34154,8 +34126,6 @@ Value Value::MaximumValue(const LogicalType &type) {
 		return Value::TIMESTAMPNS(timestamp_t(NumericLimits<int64_t>::Maximum()));
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return MaximumValue(LogicalType::TIMESTAMP).CastAs(LogicalType::TIMESTAMP_S);
-	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 - 1));
 	case LogicalTypeId::TIMESTAMP_TZ:
@@ -34371,13 +34341,6 @@ 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));
 }
@@ -34678,7 +34641,6 @@ 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:
@@ -34860,8 +34822,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::DATE_TZ:
-		return Value::DATETZ(date_t(value));
 	case LogicalTypeId::TIME_TZ:
 		return Value::TIMETZ(dtime_t(value));
 	case LogicalTypeId::TIMESTAMP_TZ:
@@ -35041,8 +35001,6 @@ 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:
@@ -35721,7 +35679,6 @@ 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;
@@ -35876,8 +35833,6 @@ 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:
@@ -36913,7 +36868,6 @@ 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:
@@ -37293,7 +37247,6 @@ 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:
@@ -37400,7 +37353,6 @@ 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;
 
@@ -37435,13 +37387,13 @@ const vector<LogicalType> LogicalType::Integral() {
 
 const vector<LogicalType> LogicalType::AllTypes() {
 	vector<LogicalType> types = {
-	    LogicalType::BOOLEAN,  LogicalType::TINYINT,   LogicalType::SMALLINT,  LogicalType::INTEGER,
-	    LogicalType::BIGINT,   LogicalType::DATE,      LogicalType::TIMESTAMP, LogicalType::DOUBLE,
-	    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, LogicalType::DATE_TZ,   LogicalType::TIME_TZ,   LogicalType::TIMESTAMP_TZ,
-	    LogicalTypeId::MAP,    LogicalType::UUID};
+	    LogicalType::BOOLEAN,  LogicalType::TINYINT,   LogicalType::SMALLINT,     LogicalType::INTEGER,
+	    LogicalType::BIGINT,   LogicalType::DATE,      LogicalType::TIMESTAMP,    LogicalType::DOUBLE,
+	    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, LogicalType::TIME_TZ,   LogicalType::TIMESTAMP_TZ, LogicalTypeId::MAP,
+	    LogicalType::UUID};
 	return types;
 }
 
@@ -37628,8 +37580,6 @@ string LogicalTypeIdToString(LogicalTypeId id) {
 		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:
@@ -37791,8 +37741,6 @@ LogicalTypeId TransformStringToLogicalType(const string &str) {
 		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
@@ -41285,7 +41233,6 @@ 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:
@@ -41329,31 +41276,6 @@ static bool DateCastSwitch(Vector &source, Vector &result, idx_t count, string *
 	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);
 	}
@@ -41399,7 +41321,6 @@ 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;
@@ -41438,7 +41359,6 @@ static bool TimestampTzCastSwitch(Vector &source, Vector &result, idx_t count, s
 		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;
@@ -41811,8 +41731,6 @@ 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:
@@ -67329,9 +67247,6 @@ 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);
@@ -67353,7 +67268,6 @@ 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;
@@ -67364,7 +67278,6 @@ 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;
@@ -67375,7 +67288,6 @@ 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;
@@ -67386,7 +67298,6 @@ 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;
@@ -67397,21 +67308,9 @@ 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:
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::INTEGER, LogicalType::TIMESTAMP));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BIGINT, LogicalType::TIMESTAMP));
@@ -67419,7 +67318,6 @@ 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;
@@ -67430,7 +67328,6 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		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));
@@ -67442,7 +67339,6 @@ 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;
@@ -67458,7 +67354,6 @@ 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);
@@ -67480,7 +67375,6 @@ 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);
@@ -68341,7 +68235,6 @@ 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:
@@ -68549,7 +68442,6 @@ 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:
@@ -70764,9 +70656,8 @@ unique_ptr<FunctionData> BindModeDecimal(ClientContext &context, AggregateFuncti
 }
 
 void ModeFun::RegisterFunction(BuiltinFunctions &set) {
-	const vector<LogicalType> TEMPORAL = {LogicalType::DATE,    LogicalType::TIMESTAMP,    LogicalType::TIME,
-	                                      LogicalType::DATE_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ,
-	                                      LogicalType::INTERVAL};
+	const vector<LogicalType> TEMPORAL = {LogicalType::DATE,         LogicalType::TIMESTAMP, LogicalType::TIME,
+	                                      LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ,   LogicalType::INTERVAL};
 
 	AggregateFunctionSet mode("mode");
 	mode.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
@@ -71386,7 +71277,6 @@ 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:
@@ -71578,7 +71468,6 @@ 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:
@@ -72009,8 +71898,6 @@ 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;
@@ -72061,11 +71948,11 @@ AggregateFunction GetContinuousQuantileListAggregate(const LogicalType &type) {
 }
 
 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::DATE_TZ,  LogicalType::TIMESTAMP_TZ,
-	                                       LogicalType::TIME_TZ, LogicalType::INTERVAL, LogicalType::VARCHAR};
+	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::TIMESTAMP_TZ, LogicalType::TIME_TZ,
+	                                       LogicalType::INTERVAL, LogicalType::VARCHAR};
 
 	AggregateFunctionSet median("median");
 	median.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
@@ -79670,7 +79557,6 @@ static void RegisterLeastGreatest(BuiltinFunctions &set, const string &fun_name)
 
 	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);
 }
@@ -80239,7 +80125,6 @@ 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:
@@ -82748,7 +82633,7 @@ ScalarFunction AddFun::GetFunction(const LogicalType &left_type, const LogicalTy
 		}
 		break;
 	case LogicalTypeId::INTEGER:
-		if (right_type.id() == LogicalTypeId::DATE || right_type.id() == LogicalTypeId::DATE_TZ) {
+		if (right_type.id() == LogicalTypeId::DATE) {
 			return ScalarFunction("+", {left_type, right_type}, right_type,
 			                      ScalarFunction::BinaryFunction<int32_t, date_t, date_t, AddOperator>);
 		}
@@ -82780,12 +82665,6 @@ 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;
 	}
@@ -82806,8 +82685,6 @@ 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
@@ -82978,15 +82855,6 @@ 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;
 	}
@@ -83006,10 +82874,8 @@ 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
@@ -94162,7 +94028,6 @@ 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";
@@ -95013,7 +94878,6 @@ static vector<TestType> GetTestTypes() {
 	result.emplace_back(LogicalType::TIMESTAMP_S, "timestamp_s");
 	result.emplace_back(LogicalType::TIMESTAMP_MS, "timestamp_ms");
 	result.emplace_back(LogicalType::TIMESTAMP_NS, "timestamp_ns");
-	result.emplace_back(LogicalType::DATE_TZ, "date_tz");
 	result.emplace_back(LogicalType::TIME_TZ, "time_tz");
 	result.emplace_back(LogicalType::TIMESTAMP_TZ, "timestamp_tz");
 	result.emplace_back(LogicalType::FLOAT, "float");
@@ -96745,7 +96609,6 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
 	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:
@@ -97133,7 +96996,6 @@ 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:
@@ -109310,7 +109172,6 @@ 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:
@@ -141484,8 +141345,10 @@ bool BindContext::CheckExclusionList(StarExpression &expr, Binding *binding, con
 	}
 	auto entry = expr.replace_list.find(column_name);
 	if (entry != expr.replace_list.end()) {
+		auto new_entry = entry->second->Copy();
+		new_entry->alias = entry->first;
 		excluded_columns.insert(entry->first);
-		new_select_list.push_back(entry->second->Copy());
+		new_select_list.push_back(move(new_entry));
 		return true;
 	}
 	return false;
@@ -148624,7 +148487,6 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 		switch (target_type.id()) {
 		case LogicalTypeId::DATE:
 		case LogicalTypeId::TIME:
-		case LogicalTypeId::DATE_TZ:
 		case LogicalTypeId::TIME_TZ:
 			return false;
 		default:
@@ -148639,7 +148501,6 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 		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;
@@ -148655,7 +148516,6 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 		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;

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "e42fd2bd8"
-#define DUCKDB_VERSION "0.3.2-dev858"
+#define DUCKDB_SOURCE_ID "be48a65ba"
+#define DUCKDB_VERSION "0.3.2-dev874"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -927,7 +927,6 @@ enum class LogicalTypeId : uint8_t {
 	UINTEGER = 30,
 	UBIGINT = 31,
 	TIMESTAMP_TZ = 32,
-	DATE_TZ = 33,
 	TIME_TZ = 34,
 
 
@@ -1030,7 +1029,6 @@ public:
 	static constexpr const LogicalTypeId TIMESTAMP_NS = LogicalTypeId::TIMESTAMP_NS;
 	static constexpr const LogicalTypeId TIME = LogicalTypeId::TIME;
 	static constexpr const LogicalTypeId TIMESTAMP_TZ = LogicalTypeId::TIMESTAMP_TZ;
-	static constexpr const LogicalTypeId DATE_TZ = LogicalTypeId::DATE_TZ;
 	static constexpr const LogicalTypeId TIME_TZ = LogicalTypeId::TIME_TZ;
 	static constexpr const LogicalTypeId VARCHAR = LogicalTypeId::VARCHAR;
 	static constexpr const LogicalTypeId ANY = LogicalTypeId::ANY;
@@ -2615,7 +2613,6 @@ public:
 	DUCKDB_API static Value POINTER(uintptr_t value);
 	//! Create a date Value from a specified date
 	DUCKDB_API static Value DATE(date_t date);
-	DUCKDB_API static Value DATETZ(date_t date);
 	//! Create a date Value from a specified date
 	DUCKDB_API static Value DATE(int32_t year, int32_t month, int32_t day);
 	//! Create a time Value from a specified time
@@ -8633,7 +8630,6 @@ private:
 		case LogicalTypeId::BIGINT:
 			return std::is_same<T, int64_t>();
 		case LogicalTypeId::DATE:
-		case LogicalTypeId::DATE_TZ:
 			return std::is_same<T, date_t>();
 		case LogicalTypeId::TIME:
 		case LogicalTypeId::TIME_TZ: