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

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

@@ -1,23 +1,24 @@
 #include "duckdb/common/types.hpp"
 
-#include "duckdb/catalog/default/default_types.hpp"
+#include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
+#include "duckdb/catalog/default/default_types.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/serializer.hpp"
+#include "duckdb/common/string_map_set.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/decimal.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/common/unordered_map.hpp"
+#include "duckdb/function/cast_rules.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 #include "duckdb/parser/parser.hpp"
-#include "duckdb/function/cast_rules.hpp"
-#include "duckdb/common/string_map_set.hpp"
 
 #include <cmath>
 
@@ -30,7 +31,7 @@ LogicalType::LogicalType(LogicalTypeId id) : id_(id) {
 	physical_type_ = GetInternalType();
 }
 LogicalType::LogicalType(LogicalTypeId id, shared_ptr<ExtraTypeInfo> type_info_p)
-    : id_(id), type_info_(move(type_info_p)) {
+    : id_(id), type_info_(std::move(type_info_p)) {
 	physical_type_ = GetInternalType();
 }
 
@@ -39,7 +40,7 @@ LogicalType::LogicalType(const LogicalType &other)
 }
 
 LogicalType::LogicalType(LogicalType &&other) noexcept
-    : id_(other.id_), physical_type_(other.physical_type_), type_info_(move(other.type_info_)) {
+    : id_(other.id_), physical_type_(other.physical_type_), type_info_(std::move(other.type_info_)) {
 }
 
 hash_t LogicalType::Hash() const {
@@ -103,7 +104,7 @@ PhysicalType LogicalType::GetInternalType() {
 	case LogicalTypeId::VARCHAR:
 	case LogicalTypeId::CHAR:
 	case LogicalTypeId::BLOB:
-	case LogicalTypeId::JSON:
+	case LogicalTypeId::BIT:
 		return PhysicalType::VARCHAR;
 	case LogicalTypeId::INTERVAL:
 		return PhysicalType::INTERVAL;
@@ -177,9 +178,9 @@ constexpr const LogicalTypeId LogicalType::HASH;
 constexpr const LogicalTypeId LogicalType::POINTER;
 
 constexpr const LogicalTypeId LogicalType::VARCHAR;
-constexpr const LogicalTypeId LogicalType::JSON;
 
 constexpr const LogicalTypeId LogicalType::BLOB;
+constexpr const LogicalTypeId LogicalType::BIT;
 constexpr const LogicalTypeId LogicalType::INTERVAL;
 constexpr const LogicalTypeId LogicalType::ROW_TYPE;
 
@@ -206,13 +207,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::TIME_TZ,   LogicalType::TIMESTAMP_TZ, LogicalTypeId::MAP,
-	    LogicalTypeId::UNION,  LogicalType::UUID,      LogicalType::JSON};
+	    LogicalType::BOOLEAN,   LogicalType::TINYINT,  LogicalType::SMALLINT,  LogicalType::INTEGER,
+	    LogicalType::BIGINT,    LogicalType::DATE,     LogicalType::TIMESTAMP, LogicalType::DOUBLE,
+	    LogicalType::FLOAT,     LogicalType::VARCHAR,  LogicalType::BLOB,      LogicalType::BIT,
+	    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,     LogicalTypeId::UNION,  LogicalType::UUID};
 	return types;
 }
 
@@ -404,8 +405,8 @@ string LogicalTypeIdToString(LogicalTypeId id) {
 		return "AGGREGATE_STATE";
 	case LogicalTypeId::USER:
 		return "USER";
-	case LogicalTypeId::JSON:
-		return "JSON";
+	case LogicalTypeId::BIT:
+		return "BIT";
 	}
 	return "UNDEFINED";
 }
@@ -503,6 +504,13 @@ LogicalType TransformStringToLogicalType(const string &str) {
 	return Parser::ParseColumnList("dummy " + str).GetColumn(LogicalIndex(0)).Type();
 }
 
+LogicalType TransformStringToLogicalType(const string &str, ClientContext &context) {
+	auto type = TransformStringToLogicalType(str);
+	return type.id() == LogicalTypeId::USER
+	           ? Catalog::GetSystemCatalog(context).GetType(context, SYSTEM_CATALOG, DEFAULT_SCHEMA, str)
+	           : type;
+}
+
 bool LogicalType::IsIntegral() const {
 	switch (id_) {
 	case LogicalTypeId::TINYINT:
@@ -737,12 +745,12 @@ LogicalType LogicalType::MaxLogicalType(const LogicalType &left, const LogicalTy
 	if (type_id == LogicalTypeId::LIST) {
 		// list: perform max recursively on child type
 		auto new_child = MaxLogicalType(ListType::GetChildType(left), ListType::GetChildType(right));
-		return LogicalType::LIST(move(new_child));
+		return LogicalType::LIST(std::move(new_child));
 	}
 	if (type_id == LogicalTypeId::MAP) {
 		// list: perform max recursively on child type
 		auto new_child = MaxLogicalType(ListType::GetChildType(left), ListType::GetChildType(right));
-		return LogicalType::MAP(move(new_child));
+		return LogicalType::MAP(std::move(new_child));
 	}
 	if (type_id == LogicalTypeId::STRUCT) {
 		// struct: perform recursively
@@ -756,10 +764,10 @@ LogicalType LogicalType::MaxLogicalType(const LogicalType &left, const LogicalTy
 		child_list_t<LogicalType> child_types;
 		for (idx_t i = 0; i < left_child_types.size(); i++) {
 			auto child_type = MaxLogicalType(left_child_types[i].second, right_child_types[i].second);
-			child_types.push_back(make_pair(left_child_types[i].first, move(child_type)));
+			child_types.push_back(make_pair(left_child_types[i].first, std::move(child_type)));
 		}
 
-		return LogicalType::STRUCT(move(child_types));
+		return LogicalType::STRUCT(std::move(child_types));
 	}
 	if (type_id == LogicalTypeId::UNION) {
 		auto left_member_count = UnionType::GetMemberCount(left);
@@ -824,7 +832,7 @@ enum class ExtraTypeInfoType : uint8_t {
 struct ExtraTypeInfo {
 	explicit ExtraTypeInfo(ExtraTypeInfoType type) : type(type) {
 	}
-	explicit ExtraTypeInfo(ExtraTypeInfoType type, string alias) : type(type), alias(move(alias)) {
+	explicit ExtraTypeInfo(ExtraTypeInfoType type, string alias) : type(type), alias(std::move(alias)) {
 	}
 	virtual ~ExtraTypeInfo() {
 	}
@@ -873,9 +881,9 @@ protected:
 
 void LogicalType::SetAlias(string alias) {
 	if (!type_info_) {
-		type_info_ = make_shared<ExtraTypeInfo>(ExtraTypeInfoType::GENERIC_TYPE_INFO, move(alias));
+		type_info_ = make_shared<ExtraTypeInfo>(ExtraTypeInfoType::GENERIC_TYPE_INFO, std::move(alias));
 	} else {
-		type_info_->alias = move(alias);
+		type_info_->alias = std::move(alias);
 	}
 }
 
@@ -959,7 +967,7 @@ uint8_t DecimalType::MaxWidth() {
 LogicalType LogicalType::DECIMAL(int width, int scale) {
 	D_ASSERT(width >= scale);
 	auto type_info = make_shared<DecimalTypeInfo>(width, scale);
-	return LogicalType(LogicalTypeId::DECIMAL, move(type_info));
+	return LogicalType(LogicalTypeId::DECIMAL, std::move(type_info));
 }
 
 //===--------------------------------------------------------------------===//
@@ -967,7 +975,7 @@ LogicalType LogicalType::DECIMAL(int width, int scale) {
 //===--------------------------------------------------------------------===//
 struct StringTypeInfo : public ExtraTypeInfo {
 	explicit StringTypeInfo(string collation_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::STRING_TYPE_INFO), collation(move(collation_p)) {
+	    : ExtraTypeInfo(ExtraTypeInfoType::STRING_TYPE_INFO), collation(std::move(collation_p)) {
 	}
 
 	string collation;
@@ -979,7 +987,7 @@ public:
 
 	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
 		auto collation = reader.ReadRequired<string>();
-		return make_shared<StringTypeInfo>(move(collation));
+		return make_shared<StringTypeInfo>(std::move(collation));
 	}
 
 protected:
@@ -1004,8 +1012,8 @@ string StringType::GetCollation(const LogicalType &type) {
 }
 
 LogicalType LogicalType::VARCHAR_COLLATION(string collation) { // NOLINT
-	auto string_info = make_shared<StringTypeInfo>(move(collation));
-	return LogicalType(LogicalTypeId::VARCHAR, move(string_info));
+	auto string_info = make_shared<StringTypeInfo>(std::move(collation));
+	return LogicalType(LogicalTypeId::VARCHAR, std::move(string_info));
 }
 
 //===--------------------------------------------------------------------===//
@@ -1013,7 +1021,7 @@ LogicalType LogicalType::VARCHAR_COLLATION(string collation) { // NOLINT
 //===--------------------------------------------------------------------===//
 struct ListTypeInfo : public ExtraTypeInfo {
 	explicit ListTypeInfo(LogicalType child_type_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::LIST_TYPE_INFO), child_type(move(child_type_p)) {
+	    : ExtraTypeInfo(ExtraTypeInfoType::LIST_TYPE_INFO), child_type(std::move(child_type_p)) {
 	}
 
 	LogicalType child_type;
@@ -1025,7 +1033,7 @@ public:
 
 	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
 		auto child_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-		return make_shared<ListTypeInfo>(move(child_type));
+		return make_shared<ListTypeInfo>(std::move(child_type));
 	}
 
 protected:
@@ -1043,8 +1051,8 @@ const LogicalType &ListType::GetChildType(const LogicalType &type) {
 }
 
 LogicalType LogicalType::LIST(LogicalType child) {
-	auto info = make_shared<ListTypeInfo>(move(child));
-	return LogicalType(LogicalTypeId::LIST, move(info));
+	auto info = make_shared<ListTypeInfo>(std::move(child));
+	return LogicalType(LogicalTypeId::LIST, std::move(info));
 }
 
 //===--------------------------------------------------------------------===//
@@ -1052,7 +1060,7 @@ LogicalType LogicalType::LIST(LogicalType child) {
 //===--------------------------------------------------------------------===//
 struct StructTypeInfo : public ExtraTypeInfo {
 	explicit StructTypeInfo(child_list_t<LogicalType> child_types_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::STRUCT_TYPE_INFO), child_types(move(child_types_p)) {
+	    : ExtraTypeInfo(ExtraTypeInfoType::STRUCT_TYPE_INFO), child_types(std::move(child_types_p)) {
 	}
 
 	child_list_t<LogicalType> child_types;
@@ -1074,9 +1082,9 @@ public:
 		for (uint32_t i = 0; i < child_types_size; i++) {
 			auto name = source.Read<string>();
 			auto type = LogicalType::Deserialize(source);
-			child_list.push_back(make_pair(move(name), move(type)));
+			child_list.push_back(make_pair(std::move(name), std::move(type)));
 		}
-		return make_shared<StructTypeInfo>(move(child_list));
+		return make_shared<StructTypeInfo>(std::move(child_list));
 	}
 
 protected:
@@ -1088,7 +1096,7 @@ protected:
 
 struct AggregateStateTypeInfo : public ExtraTypeInfo {
 	explicit AggregateStateTypeInfo(aggregate_state_t state_type_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO), state_type(move(state_type_p)) {
+	    : ExtraTypeInfo(ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO), state_type(std::move(state_type_p)) {
 	}
 
 	aggregate_state_t state_type;
@@ -1114,10 +1122,10 @@ public:
 
 		for (uint32_t i = 0; i < bound_argument_types_size; i++) {
 			auto type = LogicalType::Deserialize(source);
-			bound_argument_types.push_back(move(type));
+			bound_argument_types.push_back(std::move(type));
 		}
 		return make_shared<AggregateStateTypeInfo>(
-		    aggregate_state_t(move(function_name), move(return_type), move(bound_argument_types)));
+		    aggregate_state_t(std::move(function_name), std::move(return_type), std::move(bound_argument_types)));
 	}
 
 protected:
@@ -1174,28 +1182,28 @@ idx_t StructType::GetChildCount(const LogicalType &type) {
 }
 
 LogicalType LogicalType::STRUCT(child_list_t<LogicalType> children) {
-	auto info = make_shared<StructTypeInfo>(move(children));
-	return LogicalType(LogicalTypeId::STRUCT, move(info));
+	auto info = make_shared<StructTypeInfo>(std::move(children));
+	return LogicalType(LogicalTypeId::STRUCT, std::move(info));
 }
 
 LogicalType LogicalType::AGGREGATE_STATE(aggregate_state_t state_type) { // NOLINT
-	auto info = make_shared<AggregateStateTypeInfo>(move(state_type));
-	return LogicalType(LogicalTypeId::AGGREGATE_STATE, move(info));
+	auto info = make_shared<AggregateStateTypeInfo>(std::move(state_type));
+	return LogicalType(LogicalTypeId::AGGREGATE_STATE, std::move(info));
 }
 
 //===--------------------------------------------------------------------===//
 // Map Type
 //===--------------------------------------------------------------------===//
 LogicalType LogicalType::MAP(LogicalType child) {
-	auto info = make_shared<ListTypeInfo>(move(child));
-	return LogicalType(LogicalTypeId::MAP, move(info));
+	auto info = make_shared<ListTypeInfo>(std::move(child));
+	return LogicalType(LogicalTypeId::MAP, std::move(info));
 }
 
 LogicalType LogicalType::MAP(LogicalType key, LogicalType value) {
 	child_list_t<LogicalType> child_types;
-	child_types.push_back({"key", move(key)});
-	child_types.push_back({"value", move(value)});
-	return LogicalType::MAP(LogicalType::STRUCT(move(child_types)));
+	child_types.push_back({"key", std::move(key)});
+	child_types.push_back({"value", std::move(value)});
+	return LogicalType::MAP(LogicalType::STRUCT(std::move(child_types)));
 }
 
 const LogicalType &MapType::KeyType(const LogicalType &type) {
@@ -1217,8 +1225,8 @@ LogicalType LogicalType::UNION(child_list_t<LogicalType> members) {
 	D_ASSERT(members.size() <= UnionType::MAX_UNION_MEMBERS);
 	// union types always have a hidden "tag" field in front
 	members.insert(members.begin(), {"", LogicalType::TINYINT});
-	auto info = make_shared<StructTypeInfo>(move(members));
-	return LogicalType(LogicalTypeId::UNION, move(info));
+	auto info = make_shared<StructTypeInfo>(std::move(members));
+	return LogicalType(LogicalTypeId::UNION, std::move(info));
 }
 
 const LogicalType &UnionType::GetMemberType(const LogicalType &type, idx_t index) {
@@ -1250,7 +1258,7 @@ const child_list_t<LogicalType> UnionType::CopyMemberTypes(const LogicalType &ty
 //===--------------------------------------------------------------------===//
 struct UserTypeInfo : public ExtraTypeInfo {
 	explicit UserTypeInfo(string name_p)
-	    : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), user_type_name(move(name_p)) {
+	    : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), user_type_name(std::move(name_p)) {
 	}
 
 	string user_type_name;
@@ -1262,7 +1270,7 @@ public:
 
 	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
 		auto enum_name = reader.ReadRequired<string>();
-		return make_shared<UserTypeInfo>(move(enum_name));
+		return make_shared<UserTypeInfo>(std::move(enum_name));
 	}
 
 protected:
@@ -1281,7 +1289,7 @@ const string &UserType::GetTypeName(const LogicalType &type) {
 
 LogicalType LogicalType::USER(const string &user_type_name) {
 	auto info = make_shared<UserTypeInfo>(user_type_name);
-	return LogicalType(LogicalTypeId::USER, move(info));
+	return LogicalType(LogicalTypeId::USER, std::move(info));
 }
 
 //===--------------------------------------------------------------------===//
@@ -1293,7 +1301,7 @@ enum EnumDictType : uint8_t { INVALID = 0, VECTOR_DICT = 1 };
 struct EnumTypeInfo : public ExtraTypeInfo {
 	explicit EnumTypeInfo(string enum_name_p, Vector &values_insert_order_p, idx_t dict_size_p)
 	    : ExtraTypeInfo(ExtraTypeInfoType::ENUM_TYPE_INFO), dict_type(EnumDictType::VECTOR_DICT),
-	      enum_name(move(enum_name_p)), values_insert_order(values_insert_order_p), dict_size(dict_size_p) {
+	      enum_name(std::move(enum_name_p)), values_insert_order(values_insert_order_p), dict_size(dict_size_p) {
 	}
 	EnumDictType dict_type;
 	string enum_name;
@@ -1361,7 +1369,7 @@ struct EnumTypeInfoTemplated : public EnumTypeInfo {
 		auto enum_name = reader.ReadRequired<string>();
 		Vector values_insert_order(LogicalType::VARCHAR, size);
 		values_insert_order.Deserialize(size, reader.GetSource());
-		return make_shared<EnumTypeInfoTemplated>(move(enum_name), values_insert_order, size);
+		return make_shared<EnumTypeInfoTemplated>(std::move(enum_name), values_insert_order, size);
 	}
 
 	string_map_t<T> values;
@@ -1564,7 +1572,7 @@ LogicalType LogicalType::Deserialize(Deserializer &source) {
 	auto info = ExtraTypeInfo::Deserialize(reader);
 	reader.Finalize();
 
-	return LogicalType(id, move(info));
+	return LogicalType(id, std::move(info));
 }
 
 bool LogicalType::EqualTypeInfo(const LogicalType &rhs) const {

package/src/duckdb/src/common/vector_operations/vector_cast.cpp

@@ -1,14 +1,19 @@
-#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/function/scalar_function.hpp"
 
 namespace duckdb {
 
 bool VectorOperations::TryCast(CastFunctionSet &set, GetCastFunctionInput &input, Vector &source, Vector &result,
                                idx_t count, string *error_message, bool strict) {
 	auto cast_function = set.GetCastFunction(source.GetType(), result.GetType(), input);
-	CastParameters parameters(cast_function.cast_data.get(), strict, error_message);
+	unique_ptr<FunctionLocalState> local_state;
+	if (cast_function.init_local_state) {
+		local_state = cast_function.init_local_state(*input.context);
+	}
+	CastParameters parameters(cast_function.cast_data.get(), strict, error_message, local_state.get());
 	return cast_function.function(source, result, count, parameters);
 }
 

package/src/duckdb/src/common/virtual_file_system.cpp

@@ -7,7 +7,7 @@
 namespace duckdb {
 
 VirtualFileSystem::VirtualFileSystem() : default_fs(FileSystem::CreateLocal()) {
-	RegisterSubSystem(FileCompressionType::GZIP, make_unique<GZipFileSystem>());
+	VirtualFileSystem::RegisterSubSystem(FileCompressionType::GZIP, make_unique<GZipFileSystem>());
 }
 
 unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t flags, FileLockType lock,
@@ -26,14 +26,14 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t f
 	// open the base file handle
 	auto file_handle = FindFileSystem(path)->OpenFile(path, flags, lock, FileCompressionType::UNCOMPRESSED, opener);
 	if (file_handle->GetType() == FileType::FILE_TYPE_FIFO) {
-		file_handle = PipeFileSystem::OpenPipe(move(file_handle));
+		file_handle = PipeFileSystem::OpenPipe(std::move(file_handle));
 	} else if (compression != FileCompressionType::UNCOMPRESSED) {
 		auto entry = compressed_fs.find(compression);
 		if (entry == compressed_fs.end()) {
 			throw NotImplementedException(
 			    "Attempting to open a compressed file, but the compression type is not supported");
 		}
-		file_handle = entry->second->OpenCompressedFile(move(file_handle), flags & FileFlags::FILE_FLAGS_WRITE);
+		file_handle = entry->second->OpenCompressedFile(std::move(file_handle), flags & FileFlags::FILE_FLAGS_WRITE);
 	}
 	return file_handle;
 }

package/src/duckdb/src/execution/aggregate_hashtable.cpp

@@ -22,13 +22,13 @@ GroupedAggregateHashTable::GroupedAggregateHashTable(ClientContext &context, All
                                                      vector<LogicalType> group_types, vector<LogicalType> payload_types,
                                                      const vector<BoundAggregateExpression *> &bindings,
                                                      HtEntryType entry_type)
-    : GroupedAggregateHashTable(context, allocator, move(group_types), move(payload_types),
+    : GroupedAggregateHashTable(context, allocator, std::move(group_types), std::move(payload_types),
                                 AggregateObject::CreateAggregateObjects(bindings), entry_type) {
 }
 
 GroupedAggregateHashTable::GroupedAggregateHashTable(ClientContext &context, Allocator &allocator,
                                                      vector<LogicalType> group_types)
-    : GroupedAggregateHashTable(context, allocator, move(group_types), {}, vector<AggregateObject>()) {
+    : GroupedAggregateHashTable(context, allocator, std::move(group_types), {}, vector<AggregateObject>()) {
 }
 
 GroupedAggregateHashTable::GroupedAggregateHashTable(ClientContext &context, Allocator &allocator,
@@ -36,14 +36,15 @@ GroupedAggregateHashTable::GroupedAggregateHashTable(ClientContext &context, All
                                                      vector<LogicalType> payload_types_p,
                                                      vector<AggregateObject> aggregate_objects_p,
                                                      HtEntryType entry_type)
-    : BaseAggregateHashTable(context, allocator, aggregate_objects_p, move(payload_types_p)), entry_type(entry_type),
-      capacity(0), entries(0), payload_page_offset(0), is_finalized(false), ht_offsets(LogicalTypeId::BIGINT),
-      hash_salts(LogicalTypeId::SMALLINT), group_compare_vector(STANDARD_VECTOR_SIZE),
-      no_match_vector(STANDARD_VECTOR_SIZE), empty_vector(STANDARD_VECTOR_SIZE) {
+    : BaseAggregateHashTable(context, allocator, aggregate_objects_p, std::move(payload_types_p)),
+      entry_type(entry_type), capacity(0), entries(0), payload_page_offset(0), is_finalized(false),
+      ht_offsets(LogicalTypeId::BIGINT), hash_salts(LogicalTypeId::SMALLINT),
+      group_compare_vector(STANDARD_VECTOR_SIZE), no_match_vector(STANDARD_VECTOR_SIZE),
+      empty_vector(STANDARD_VECTOR_SIZE) {
 
 	// Append hash column to the end and initialise the row layout
 	group_types_p.emplace_back(LogicalType::HASH);
-	layout.Initialize(move(group_types_p), move(aggregate_objects_p));
+	layout.Initialize(std::move(group_types_p), std::move(aggregate_objects_p));
 
 	// HT layout
 	hash_offset = layout.GetOffsets()[layout.ColumnCount() - 1];
@@ -102,7 +103,7 @@ void GroupedAggregateHashTable::PayloadApply(FUNC fun) {
 
 void GroupedAggregateHashTable::NewBlock() {
 	auto pin = buffer_manager.Allocate(Storage::BLOCK_SIZE);
-	payload_hds.push_back(move(pin));
+	payload_hds.push_back(std::move(pin));
 	payload_hds_ptrs.push_back(payload_hds.back().Ptr());
 	payload_page_offset = 0;
 }
@@ -150,6 +151,7 @@ void GroupedAggregateHashTable::VerifyInternal() {
 			count++;
 		}
 	}
+	(void)count;
 	D_ASSERT(count == entries);
 }
 

package/src/duckdb/src/execution/base_aggregate_hashtable.cpp

@@ -8,7 +8,7 @@ BaseAggregateHashTable::BaseAggregateHashTable(ClientContext &context, Allocator
                                                const vector<AggregateObject> &aggregates,
                                                vector<LogicalType> payload_types_p)
     : allocator(allocator), buffer_manager(BufferManager::GetBufferManager(context)),
-      payload_types(move(payload_types_p)) {
+      payload_types(std::move(payload_types_p)) {
 	filter_set.Initialize(context, aggregates, payload_types);
 }
 

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

@@ -3,6 +3,7 @@
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_create_index.hpp"
 #include "duckdb/planner/operator/logical_delim_join.hpp"
+#include "duckdb/planner/operator/logical_insert.hpp"
 
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
@@ -51,7 +52,7 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		// CREATE INDEX statement, add the columns of the table with table index 0 to the binding set
 		// afterwards bind the expressions of the CREATE INDEX statement
 		auto &create_index = (LogicalCreateIndex &)op;
-		bindings = LogicalOperator::GenerateColumnBindings(0, create_index.table.columns.LogicalColumnCount());
+		bindings = LogicalOperator::GenerateColumnBindings(0, create_index.table.GetColumns().LogicalColumnCount());
 		VisitOperatorExpressions(op);
 		return;
 	} else if (op.type == LogicalOperatorType::LOGICAL_GET) {
@@ -59,6 +60,25 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		bindings = op.GetColumnBindings();
 		VisitOperatorExpressions(op);
 		return;
+	} else if (op.type == LogicalOperatorType::LOGICAL_INSERT) {
+		//! We want to execute the normal path, but also add a dummy 'excluded' binding if there is a
+		// ON CONFLICT DO UPDATE clause
+		auto &insert_op = (LogicalInsert &)op;
+		if (insert_op.action_type != OnConflictAction::THROW) {
+			VisitOperatorChildren(op);
+			auto dummy_bindings = LogicalOperator::GenerateColumnBindings(
+			    insert_op.excluded_table_index, insert_op.table->GetColumns().PhysicalColumnCount());
+			bindings.insert(bindings.begin(), dummy_bindings.begin(), dummy_bindings.end());
+			if (insert_op.on_conflict_condition) {
+				VisitExpression(&insert_op.on_conflict_condition);
+			}
+			if (insert_op.do_update_condition) {
+				VisitExpression(&insert_op.do_update_condition);
+			}
+			VisitOperatorExpressions(op);
+			bindings = op.GetColumnBindings();
+			return;
+		}
 	}
 	// general case
 	// first visit the children of this operator

package/src/duckdb/src/execution/expression_executor/execute_case.cpp

@@ -22,7 +22,7 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCaseE
 	}
 	result->AddChild(expr.else_expr.get());
 	result->Finalize();
-	return move(result);
+	return std::move(result);
 }
 
 void ExpressionExecutor::Execute(const BoundCaseExpression &expr, ExpressionState *state_p, const SelectionVector *sel,

package/src/duckdb/src/execution/expression_executor/execute_cast.cpp

@@ -1,19 +1,25 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/function/scalar_function.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 
 namespace duckdb {
 
 unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCastExpression &expr,
                                                                 ExpressionExecutorState &root) {
-	auto result = make_unique<ExpressionState>(expr, root);
+	auto result = make_unique<ExecuteFunctionState>(expr, root);
 	result->AddChild(expr.child.get());
 	result->Finalize();
-	return result;
+	if (expr.bound_cast.init_local_state) {
+		result->local_state = expr.bound_cast.init_local_state(root.executor->GetContext());
+	}
+	return std::move(result);
 }
 
 void ExpressionExecutor::Execute(const BoundCastExpression &expr, ExpressionState *state, const SelectionVector *sel,
                                  idx_t count, Vector &result) {
+	auto lstate = ExecuteFunctionState::GetFunctionState(*state);
+
 	// resolve the child
 	state->intermediate_chunk.Reset();
 
@@ -23,12 +29,12 @@ void ExpressionExecutor::Execute(const BoundCastExpression &expr, ExpressionStat
 	Execute(*expr.child, child_state, sel, count, child);
 	if (expr.try_cast) {
 		string error_message;
-		CastParameters parameters(expr.bound_cast.cast_data.get(), false, &error_message);
+		CastParameters parameters(expr.bound_cast.cast_data.get(), false, &error_message, lstate);
 		expr.bound_cast.function(child, result, count, parameters);
 	} else {
 		// cast it to the type specified by the cast expression
 		D_ASSERT(result.GetType() == expr.return_type);
-		CastParameters parameters(expr.bound_cast.cast_data.get(), false, nullptr);
+		CastParameters parameters(expr.bound_cast.cast_data.get(), false, nullptr, lstate);
 		expr.bound_cast.function(child, result, count, parameters);
 	}
 }

package/src/duckdb/src/execution/expression_executor/execute_conjunction.cpp

@@ -22,7 +22,7 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundConju
 		result->AddChild(child.get());
 	}
 	result->Finalize();
-	return move(result);
+	return std::move(result);
 }
 
 void ExpressionExecutor::Execute(const BoundConjunctionExpression &expr, ExpressionState *state,

package/src/duckdb/src/execution/expression_executor/execute_function.cpp

@@ -20,7 +20,7 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundFunct
 	if (expr.function.init_local_state) {
 		result->local_state = expr.function.init_local_state(*result, expr, expr.bind_info.get());
 	}
-	return move(result);
+	return std::move(result);
 }
 
 static void VerifyNullHandling(const BoundFunctionExpression &expr, DataChunk &args, Vector &result) {

package/src/duckdb/src/execution/expression_executor/execute_operator.cpp

@@ -20,7 +20,7 @@ void ExpressionExecutor::Execute(const BoundOperatorExpression &expr, Expression
 	// IN has n children
 	if (expr.type == ExpressionType::COMPARE_IN || expr.type == ExpressionType::COMPARE_NOT_IN) {
 		if (expr.children.size() < 2) {
-			throw Exception("IN needs at least two children");
+			throw InvalidInputException("IN needs at least two children");
 		}
 
 		Vector left(expr.children[0]->return_type);

package/src/duckdb/src/execution/expression_executor.cpp

@@ -58,7 +58,7 @@ void ExpressionExecutor::AddExpression(const Expression &expr) {
 	auto state = make_unique<ExpressionExecutorState>(expr.ToString());
 	Initialize(expr, *state);
 	state->Verify();
-	states.push_back(move(state));
+	states.push_back(std::move(state));
 }
 
 void ExpressionExecutor::Initialize(const Expression &expression, ExpressionExecutorState &state) {