duckdb 0.5.2-dev484.0 → 0.5.2-dev492.0

package/package.json

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

package/src/duckdb.cpp

@@ -47073,11 +47073,21 @@ hugeint_t ModuloOperator::Operation(hugeint_t left, hugeint_t right);
 
 namespace duckdb {
 struct MapCastInfo;
+struct MapCastNode;
 
 typedef BoundCastInfo (*bind_cast_function_t)(BindCastInput &input, const LogicalType &source,
                                               const LogicalType &target);
 typedef int64_t (*implicit_cast_cost_t)(const LogicalType &from, const LogicalType &to);
 
+struct GetCastFunctionInput {
+	GetCastFunctionInput(ClientContext *context = nullptr) : context(context) {
+	}
+	GetCastFunctionInput(ClientContext &context) : context(&context) {
+	}
+
+	ClientContext *context;
+};
+
 struct BindCastFunction {
 	BindCastFunction(bind_cast_function_t function,
 	                 unique_ptr<BindCastInfo> info = nullptr); // NOLINT: allow implicit cast
@@ -47096,18 +47106,24 @@ public:
 
 	//! Returns a cast function (from source -> target)
 	//! Note that this always returns a function - since a cast is ALWAYS possible if the value is NULL
-	DUCKDB_API BoundCastInfo GetCastFunction(const LogicalType &source, const LogicalType &target);
+	DUCKDB_API BoundCastInfo GetCastFunction(const LogicalType &source, const LogicalType &target,
+	                                         GetCastFunctionInput &input);
 	//! Returns the implicit cast cost of casting from source -> target
 	//! -1 means an implicit cast is not possible
 	DUCKDB_API int64_t ImplicitCastCost(const LogicalType &source, const LogicalType &target);
 	//! Register a new cast function from source to target
 	DUCKDB_API void RegisterCastFunction(const LogicalType &source, const LogicalType &target, BoundCastInfo function,
 	                                     int64_t implicit_cast_cost = -1);
+	DUCKDB_API void RegisterCastFunction(const LogicalType &source, const LogicalType &target,
+	                                     bind_cast_function_t bind, int64_t implicit_cast_cost = -1);
 
 private:
 	vector<BindCastFunction> bind_functions;
 	//! If any custom cast functions have been defined using RegisterCastFunction, this holds the map
 	MapCastInfo *map_info;
+
+private:
+	void RegisterCastFunction(const LogicalType &source, const LogicalType &target, MapCastNode node);
 };
 
 } // namespace duckdb
@@ -48559,15 +48575,15 @@ bool Value::operator>=(const int64_t &rhs) const {
 	return *this >= Value::Numeric(type_, rhs);
 }
 
-bool Value::TryCastAs(CastFunctionSet &set, const LogicalType &target_type, Value &new_value, string *error_message,
-                      bool strict) const {
+bool Value::TryCastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
+                      Value &new_value, string *error_message, bool strict) const {
 	if (type_ == target_type) {
 		new_value = Copy();
 		return true;
 	}
 	Vector input(*this);
 	Vector result(target_type);
-	if (!VectorOperations::TryCast(set, input, result, 1, error_message, strict)) {
+	if (!VectorOperations::TryCast(set, get_input, input, result, 1, error_message, strict)) {
 		return false;
 	}
 	new_value = result.GetValue(0);
@@ -48576,37 +48592,43 @@ bool Value::TryCastAs(CastFunctionSet &set, const LogicalType &target_type, Valu
 
 bool Value::TryCastAs(ClientContext &context, const LogicalType &target_type, Value &new_value, string *error_message,
                       bool strict) const {
-	return TryCastAs(CastFunctionSet::Get(context), target_type, new_value, error_message, strict);
+	GetCastFunctionInput get_input(context);
+	return TryCastAs(CastFunctionSet::Get(context), get_input, target_type, new_value, error_message, strict);
 }
 
 bool Value::DefaultTryCastAs(const LogicalType &target_type, Value &new_value, string *error_message,
                              bool strict) const {
 	CastFunctionSet set;
-	return TryCastAs(set, target_type, new_value, error_message, strict);
+	GetCastFunctionInput get_input;
+	return TryCastAs(set, get_input, target_type, new_value, error_message, strict);
 }
 
-Value Value::CastAs(CastFunctionSet &set, const LogicalType &target_type, bool strict) const {
+Value Value::CastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
+                    bool strict) const {
 	Value new_value;
 	string error_message;
-	if (!TryCastAs(set, target_type, new_value, &error_message, strict)) {
+	if (!TryCastAs(set, get_input, target_type, new_value, &error_message, strict)) {
 		throw InvalidInputException("Failed to cast value: %s", error_message);
 	}
 	return new_value;
 }
 
 Value Value::CastAs(ClientContext &context, const LogicalType &target_type, bool strict) const {
-	return CastAs(CastFunctionSet::Get(context), target_type, strict);
+	GetCastFunctionInput get_input(context);
+	return CastAs(CastFunctionSet::Get(context), get_input, target_type, strict);
 }
 
 Value Value::DefaultCastAs(const LogicalType &target_type, bool strict) const {
 	CastFunctionSet set;
-	return CastAs(set, target_type, strict);
+	GetCastFunctionInput get_input;
+	return CastAs(set, get_input, target_type, strict);
 }
 
-bool Value::TryCastAs(CastFunctionSet &set, const LogicalType &target_type, bool strict) {
+bool Value::TryCastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
+                      bool strict) {
 	Value new_value;
 	string error_message;
-	if (!TryCastAs(set, target_type, new_value, &error_message, strict)) {
+	if (!TryCastAs(set, get_input, target_type, new_value, &error_message, strict)) {
 		return false;
 	}
 	type_ = target_type;
@@ -48619,12 +48641,14 @@ bool Value::TryCastAs(CastFunctionSet &set, const LogicalType &target_type, bool
 }
 
 bool Value::TryCastAs(ClientContext &context, const LogicalType &target_type, bool strict) {
-	return TryCastAs(CastFunctionSet::Get(context), target_type, strict);
+	GetCastFunctionInput get_input(context);
+	return TryCastAs(CastFunctionSet::Get(context), get_input, target_type, strict);
 }
 
 bool Value::DefaultTryCastAs(const LogicalType &target_type, bool strict) {
 	CastFunctionSet set;
-	return TryCastAs(set, target_type, strict);
+	GetCastFunctionInput get_input;
+	return TryCastAs(set, get_input, target_type, strict);
 }
 
 void Value::Serialize(Serializer &main_serializer) const {
@@ -48759,7 +48783,8 @@ bool Value::NotDistinctFrom(const Value &lvalue, const Value &rvalue) {
 	return ValueOperations::NotDistinctFrom(lvalue, rvalue);
 }
 
-bool Value::ValuesAreEqual(CastFunctionSet &set, const Value &result_value, const Value &value) {
+bool Value::ValuesAreEqual(CastFunctionSet &set, GetCastFunctionInput &get_input, const Value &result_value,
+                           const Value &value) {
 	if (result_value.IsNull() != value.IsNull()) {
 		return false;
 	}
@@ -48769,19 +48794,19 @@ bool Value::ValuesAreEqual(CastFunctionSet &set, const Value &result_value, cons
 	}
 	switch (value.type_.id()) {
 	case LogicalTypeId::FLOAT: {
-		auto other = result_value.CastAs(set, LogicalType::FLOAT);
+		auto other = result_value.CastAs(set, get_input, LogicalType::FLOAT);
 		float ldecimal = value.value_.float_;
 		float rdecimal = other.value_.float_;
 		return ApproxEqual(ldecimal, rdecimal);
 	}
 	case LogicalTypeId::DOUBLE: {
-		auto other = result_value.CastAs(set, LogicalType::DOUBLE);
+		auto other = result_value.CastAs(set, get_input, LogicalType::DOUBLE);
 		double ldecimal = value.value_.double_;
 		double rdecimal = other.value_.double_;
 		return ApproxEqual(ldecimal, rdecimal);
 	}
 	case LogicalTypeId::VARCHAR: {
-		auto other = result_value.CastAs(set, LogicalType::VARCHAR);
+		auto other = result_value.CastAs(set, get_input, LogicalType::VARCHAR);
 		// some results might contain padding spaces, e.g. when rendering
 		// VARCHAR(10) and the string only has 6 characters, they will be padded
 		// with spaces to 10 in the rendering. We don't do that here yet as we
@@ -48795,18 +48820,20 @@ bool Value::ValuesAreEqual(CastFunctionSet &set, const Value &result_value, cons
 	}
 	default:
 		if (result_value.type_.id() == LogicalTypeId::FLOAT || result_value.type_.id() == LogicalTypeId::DOUBLE) {
-			return Value::ValuesAreEqual(set, value, result_value);
+			return Value::ValuesAreEqual(set, get_input, value, result_value);
 		}
 		return value == result_value;
 	}
 }
 
 bool Value::ValuesAreEqual(ClientContext &context, const Value &result_value, const Value &value) {
-	return Value::ValuesAreEqual(CastFunctionSet::Get(context), result_value, value);
+	GetCastFunctionInput get_input(context);
+	return Value::ValuesAreEqual(CastFunctionSet::Get(context), get_input, result_value, value);
 }
 bool Value::DefaultValuesAreEqual(const Value &result_value, const Value &value) {
 	CastFunctionSet set;
-	return Value::ValuesAreEqual(set, result_value, value);
+	GetCastFunctionInput get_input;
+	return Value::ValuesAreEqual(set, get_input, result_value, value);
 }
 
 } // namespace duckdb
@@ -54410,16 +54437,17 @@ void VectorOperations::AddInPlace(Vector &input, int64_t right, idx_t count) {
 
 namespace duckdb {
 
-bool VectorOperations::TryCast(CastFunctionSet &set, Vector &source, Vector &result, idx_t count, string *error_message,
-                               bool strict) {
-	auto cast_function = set.GetCastFunction(source.GetType(), result.GetType());
+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);
 	return cast_function.function(source, result, count, parameters);
 }
 
 bool VectorOperations::DefaultTryCast(Vector &source, Vector &result, idx_t count, string *error_message, bool strict) {
 	CastFunctionSet set;
-	return VectorOperations::TryCast(set, source, result, count, error_message, strict);
+	GetCastFunctionInput input;
+	return VectorOperations::TryCast(set, input, source, result, count, error_message, strict);
 }
 
 void VectorOperations::DefaultCast(Vector &source, Vector &result, idx_t count, bool strict) {
@@ -54430,7 +54458,8 @@ bool VectorOperations::TryCast(ClientContext &context, Vector &source, Vector &r
                                string *error_message, bool strict) {
 	auto &config = DBConfig::GetConfig(context);
 	auto &set = config.GetCastFunctions();
-	return VectorOperations::TryCast(set, source, result, count, error_message, strict);
+	GetCastFunctionInput get_input(context);
+	return VectorOperations::TryCast(set, get_input, source, result, count, error_message, strict);
 }
 
 void VectorOperations::Cast(ClientContext &context, Vector &source, Vector &result, idx_t count, bool strict) {
@@ -76716,6 +76745,7 @@ bool BufferedCSVReader::TryParseComplexCSV(DataChunk &insert_chunk, string &erro
 	bool finished_chunk = false;
 	idx_t column = 0;
 	vector<idx_t> escape_positions;
+	bool has_quotes = false;
 	uint8_t delimiter_pos = 0, escape_pos = 0, quote_pos = 0;
 	idx_t offset = 0;
 
@@ -76778,9 +76808,10 @@ normal:
 	} while (ReadBuffer(start));
 	goto final_state;
 add_value:
-	AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
+	AddValue(buffer.get() + start, position - start - offset, column, escape_positions, has_quotes);
 	// increase position by 1 and move start to the new position
 	offset = 0;
+	has_quotes = false;
 	start = ++position;
 	if (position >= buffer_size && !ReadBuffer(start)) {
 		// file ends right after delimiter, go to final state
@@ -76790,10 +76821,11 @@ add_value:
 add_row : {
 	// check type of newline (\r or \n)
 	bool carriage_return = buffer[position] == '\r';
-	AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
+	AddValue(buffer.get() + start, position - start - offset, column, escape_positions, has_quotes);
 	finished_chunk = AddRow(insert_chunk, column);
 	// increase position by 1 and move start to the new position
 	offset = 0;
+	has_quotes = false;
 	start = ++position;
 	if (position >= buffer_size && !ReadBuffer(start)) {
 		// file ends right after newline, go to final state
@@ -76815,6 +76847,7 @@ in_quotes:
 	// this state parses the remainder of a quoted value
 	quote_pos = 0;
 	escape_pos = 0;
+	has_quotes = true;
 	position++;
 	do {
 		for (; position < buffer_size; position++) {
@@ -76926,7 +76959,7 @@ final_state:
 	}
 	if (column > 0 || position > start) {
 		// remaining values to be added to the chunk
-		AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
+		AddValue(buffer.get() + start, position - start - offset, column, escape_positions, has_quotes);
 		finished_chunk = AddRow(insert_chunk, column);
 	}
 	// final stage, only reached after parsing the file is finished
@@ -76944,6 +76977,7 @@ bool BufferedCSVReader::TryParseSimpleCSV(DataChunk &insert_chunk, string &error
 	bool finished_chunk = false;
 	idx_t column = 0;
 	idx_t offset = 0;
+	bool has_quotes = false;
 	vector<idx_t> escape_positions;
 
 	// read values into the buffer (if any)
@@ -76985,9 +77019,10 @@ normal:
 	// file ends during normal scan: go to end state
 	goto final_state;
 add_value:
-	AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
+	AddValue(buffer.get() + start, position - start - offset, column, escape_positions, has_quotes);
 	// increase position by 1 and move start to the new position
 	offset = 0;
+	has_quotes = false;
 	start = ++position;
 	if (position >= buffer_size && !ReadBuffer(start)) {
 		// file ends right after delimiter, go to final state
@@ -76997,10 +77032,11 @@ add_value:
 add_row : {
 	// check type of newline (\r or \n)
 	bool carriage_return = buffer[position] == '\r';
-	AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
+	AddValue(buffer.get() + start, position - start - offset, column, escape_positions, has_quotes);
 	finished_chunk = AddRow(insert_chunk, column);
 	// increase position by 1 and move start to the new position
 	offset = 0;
+	has_quotes = false;
 	start = ++position;
 	if (position >= buffer_size && !ReadBuffer(start)) {
 		// file ends right after delimiter, go to final state
@@ -77020,6 +77056,7 @@ add_row : {
 in_quotes:
 	/* state: in_quotes */
 	// this state parses the remainder of a quoted value
+	has_quotes = true;
 	position++;
 	do {
 		for (; position < buffer_size; position++) {
@@ -77106,7 +77143,7 @@ final_state:
 
 	if (column > 0 || position > start) {
 		// remaining values to be added to the chunk
-		AddValue(buffer.get() + start, position - start - offset, column, escape_positions);
+		AddValue(buffer.get() + start, position - start - offset, column, escape_positions, has_quotes);
 		finished_chunk = AddRow(insert_chunk, column);
 	}
 
@@ -77206,7 +77243,8 @@ bool BufferedCSVReader::TryParseCSV(ParserMode parser_mode, DataChunk &insert_ch
 	}
 }
 
-void BufferedCSVReader::AddValue(char *str_val, idx_t length, idx_t &column, vector<idx_t> &escape_positions) {
+void BufferedCSVReader::AddValue(char *str_val, idx_t length, idx_t &column, vector<idx_t> &escape_positions,
+                                 bool has_quotes) {
 	if (length == 0 && column == 0) {
 		row_empty = true;
 	} else {
@@ -77237,8 +77275,9 @@ void BufferedCSVReader::AddValue(char *str_val, idx_t length, idx_t &column, vec
 
 	str_val[length] = '\0';
 
-	// test against null string
-	if (!options.force_not_null[column] && strcmp(options.null_str.c_str(), str_val) == 0) {
+	// test against null string, but only if the value was not quoted
+	if ((!has_quotes || sql_types[column].id() != LogicalTypeId::VARCHAR) && !options.force_not_null[column] &&
+	    strcmp(options.null_str.c_str(), str_val) == 0) {
 		FlatVector::SetNull(parse_chunk.data[column], row_entry, true);
 	} else {
 		auto &v = parse_chunk.data[column];
@@ -95279,6 +95318,15 @@ using type_set_t = unordered_set<LogicalType, LogicalTypeHashFunction, LogicalTy
 
 namespace duckdb {
 
+BindCastInput::BindCastInput(CastFunctionSet &function_set, BindCastInfo *info, ClientContext *context)
+    : function_set(function_set), info(info), context(context) {
+}
+
+BoundCastInfo BindCastInput::GetCastFunction(const LogicalType &source, const LogicalType &target) {
+	GetCastFunctionInput input(context);
+	return function_set.GetCastFunction(source, target, input);
+}
+
 BindCastFunction::BindCastFunction(bind_cast_function_t function_p, unique_ptr<BindCastInfo> info_p)
     : function(function_p), info(move(info_p)) {
 }
@@ -95295,7 +95343,8 @@ CastFunctionSet &CastFunctionSet::Get(DatabaseInstance &db) {
 	return DBConfig::GetConfig(db).GetCastFunctions();
 }
 
-BoundCastInfo CastFunctionSet::GetCastFunction(const LogicalType &source, const LogicalType &target) {
+BoundCastInfo CastFunctionSet::GetCastFunction(const LogicalType &source, const LogicalType &target,
+                                               GetCastFunctionInput &get_input) {
 	if (source == target) {
 		return DefaultCasts::NopCast;
 	}
@@ -95303,7 +95352,7 @@ BoundCastInfo CastFunctionSet::GetCastFunction(const LogicalType &source, const
 	// we iterate the set of bind functions backwards
 	for (idx_t i = bind_functions.size(); i > 0; i--) {
 		auto &bind_function = bind_functions[i - 1];
-		BindCastInput input(*this, bind_function.info.get());
+		BindCastInput input(*this, bind_function.info.get(), get_input.context);
 		auto result = bind_function.function(input, source, target);
 		if (result.function) {
 			// found a cast function! return it
@@ -95316,10 +95365,14 @@ BoundCastInfo CastFunctionSet::GetCastFunction(const LogicalType &source, const
 
 struct MapCastNode {
 	MapCastNode(BoundCastInfo info, int64_t implicit_cast_cost)
-	    : cast_info(move(info)), implicit_cast_cost(implicit_cast_cost) {
+	    : cast_info(move(info)), bind_function(nullptr), implicit_cast_cost(implicit_cast_cost) {
+	}
+	MapCastNode(bind_cast_function_t func, int64_t implicit_cast_cost)
+	    : cast_info(nullptr), bind_function(func), implicit_cast_cost(implicit_cast_cost) {
 	}
 
 	BoundCastInfo cast_info;
+	bind_cast_function_t bind_function;
 	int64_t implicit_cast_cost;
 };
 
@@ -95357,18 +95410,30 @@ BoundCastInfo MapCastFunction(BindCastInput &input, const LogicalType &source, c
 		// target type not found
 		return nullptr;
 	}
+	if (target_entry->second.bind_function) {
+		return target_entry->second.bind_function(input, source, target);
+	}
 	return target_entry->second.cast_info.Copy();
 }
 
 void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const LogicalType &target, BoundCastInfo function,
                                            int64_t implicit_cast_cost) {
+	RegisterCastFunction(source, target, MapCastNode(move(function), implicit_cast_cost));
+}
+
+void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const LogicalType &target,
+                                           bind_cast_function_t bind_function, int64_t implicit_cast_cost) {
+	RegisterCastFunction(source, target, MapCastNode(bind_function, implicit_cast_cost));
+}
+
+void CastFunctionSet::RegisterCastFunction(const LogicalType &source, const LogicalType &target, MapCastNode node) {
 	if (!map_info) {
 		// create the cast map and the cast map function
 		auto info = make_unique<MapCastInfo>();
 		map_info = info.get();
 		bind_functions.emplace_back(MapCastFunction, move(info));
 	}
-	map_info->casts[source].insert(make_pair(target, MapCastNode(move(function), implicit_cast_cost)));
+	map_info->casts[source].insert(make_pair(target, move(node)));
 }
 
 } // namespace duckdb
@@ -95902,8 +95967,8 @@ public:
 };
 
 unique_ptr<BoundCastData> BindEnumCast(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-	auto to_varchar_cast = input.function_set.GetCastFunction(source, LogicalType::VARCHAR);
-	auto from_varchar_cast = input.function_set.GetCastFunction(LogicalType::VARCHAR, target);
+	auto to_varchar_cast = input.GetCastFunction(source, LogicalType::VARCHAR);
+	auto from_varchar_cast = input.GetCastFunction(LogicalType::VARCHAR, target);
 	return make_unique<EnumBoundCastData>(move(to_varchar_cast), move(from_varchar_cast));
 }
 
@@ -95979,7 +96044,7 @@ unique_ptr<BoundCastData> BindListToListCast(BindCastInput &input, const Logical
 	vector<BoundCastInfo> child_cast_info;
 	auto &source_child_type = ListType::GetChildType(source);
 	auto &result_child_type = ListType::GetChildType(target);
-	auto child_cast = input.function_set.GetCastFunction(source_child_type, result_child_type);
+	auto child_cast = input.GetCastFunction(source_child_type, result_child_type);
 	return make_unique<ListBoundCastData>(move(child_cast));
 }
 
@@ -96122,8 +96187,8 @@ unique_ptr<BoundCastData> BindMapToMapCast(BindCastInput &input, const LogicalTy
 	auto target_key = LogicalType::LIST(MapType::KeyType(target));
 	auto source_val = LogicalType::LIST(MapType::ValueType(source));
 	auto target_val = LogicalType::LIST(MapType::ValueType(target));
-	auto key_cast = input.function_set.GetCastFunction(source_key, target_key);
-	auto value_cast = input.function_set.GetCastFunction(source_val, target_val);
+	auto key_cast = input.GetCastFunction(source_key, target_key);
+	auto value_cast = input.GetCastFunction(source_val, target_val);
 	return make_unique<MapBoundCastData>(move(key_cast), move(value_cast));
 }
 
@@ -96496,8 +96561,7 @@ unique_ptr<BoundCastData> BindStructToStructCast(BindCastInput &input, const Log
 		throw TypeMismatchException(source, target, "Cannot cast STRUCTs of different size");
 	}
 	for (idx_t i = 0; i < source_child_types.size(); i++) {
-		auto child_cast =
-		    input.function_set.GetCastFunction(source_child_types[i].second, result_child_types[i].second);
+		auto child_cast = input.GetCastFunction(source_child_types[i].second, result_child_types[i].second);
 		child_cast_info.push_back(move(child_cast));
 	}
 	return make_unique<StructBoundCastData>(move(child_cast_info), target);
@@ -185998,11 +186062,13 @@ unique_ptr<Expression> AddCastExpressionInternal(unique_ptr<Expression> expr, co
 
 static BoundCastInfo BindCastFunction(ClientContext &context, const LogicalType &source, const LogicalType &target) {
 	auto &cast_functions = DBConfig::GetConfig(context).GetCastFunctions();
-	return cast_functions.GetCastFunction(source, target);
+	GetCastFunctionInput input(context);
+	return cast_functions.GetCastFunction(source, target, input);
 }
 
 unique_ptr<Expression> AddCastToTypeInternal(unique_ptr<Expression> expr, const LogicalType &target_type,
-                                             CastFunctionSet &cast_functions, bool try_cast) {
+                                             CastFunctionSet &cast_functions, GetCastFunctionInput &get_input,
+                                             bool try_cast) {
 	D_ASSERT(expr);
 	if (expr->expression_class == ExpressionClass::BOUND_PARAMETER) {
 		auto &parameter = (BoundParameterExpression &)*expr;
@@ -186041,20 +186107,23 @@ unique_ptr<Expression> AddCastToTypeInternal(unique_ptr<Expression> expr, const
 	if (!target_type.IsValid()) {
 		return expr;
 	}
-	auto cast_function = cast_functions.GetCastFunction(expr->return_type, target_type);
+
+	auto cast_function = cast_functions.GetCastFunction(expr->return_type, target_type, get_input);
 	return AddCastExpressionInternal(move(expr), target_type, move(cast_function), try_cast);
 }
 
 unique_ptr<Expression> BoundCastExpression::AddDefaultCastToType(unique_ptr<Expression> expr,
                                                                  const LogicalType &target_type, bool try_cast) {
 	CastFunctionSet default_set;
-	return AddCastToTypeInternal(move(expr), target_type, default_set, try_cast);
+	GetCastFunctionInput get_input;
+	return AddCastToTypeInternal(move(expr), target_type, default_set, get_input, try_cast);
 }
 
 unique_ptr<Expression> BoundCastExpression::AddCastToType(ClientContext &context, unique_ptr<Expression> expr,
                                                           const LogicalType &target_type, bool try_cast) {
 	auto &cast_functions = DBConfig::GetConfig(context).GetCastFunctions();
-	return AddCastToTypeInternal(move(expr), target_type, cast_functions, try_cast);
+	GetCastFunctionInput get_input(context);
+	return AddCastToTypeInternal(move(expr), target_type, cast_functions, get_input, try_cast);
 }
 
 bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const LogicalType &target_type) {

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 "b8cecdfc9"
-#define DUCKDB_VERSION "v0.5.2-dev484"
+#define DUCKDB_SOURCE_ID "27a7b4d19"
+#define DUCKDB_VERSION "v0.5.2-dev492"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -2875,6 +2875,7 @@ namespace duckdb {
 class CastFunctionSet;
 class Deserializer;
 class Serializer;
+struct GetCastFunctionInput;
 
 //! The Value object holds a single arbitrary value of any type that can be
 //! stored in the database.
@@ -3054,18 +3055,20 @@ public:
 	DUCKDB_API uintptr_t GetPointer() const;
 
 	//! Cast this value to another type, throws exception if its not possible
-	DUCKDB_API Value CastAs(CastFunctionSet &set, const LogicalType &target_type, bool strict = false) const;
+	DUCKDB_API Value CastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
+	                        bool strict = false) const;
 	DUCKDB_API Value CastAs(ClientContext &context, const LogicalType &target_type, bool strict = false) const;
 	DUCKDB_API Value DefaultCastAs(const LogicalType &target_type, bool strict = false) const;
 	//! Tries to cast this value to another type, and stores the result in "new_value"
-	DUCKDB_API bool TryCastAs(CastFunctionSet &set, const LogicalType &target_type, Value &new_value,
-	                          string *error_message, bool strict = false) const;
+	DUCKDB_API bool TryCastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
+	                          Value &new_value, string *error_message, bool strict = false) const;
 	DUCKDB_API bool TryCastAs(ClientContext &context, const LogicalType &target_type, Value &new_value,
 	                          string *error_message, bool strict = false) const;
 	DUCKDB_API bool DefaultTryCastAs(const LogicalType &target_type, Value &new_value, string *error_message,
 	                                 bool strict = false) const;
 	//! Tries to cast this value to another type, and stores the result in THIS value again
-	DUCKDB_API bool TryCastAs(CastFunctionSet &set, const LogicalType &target_type, bool strict = false);
+	DUCKDB_API bool TryCastAs(CastFunctionSet &set, GetCastFunctionInput &get_input, const LogicalType &target_type,
+	                          bool strict = false);
 	DUCKDB_API bool TryCastAs(ClientContext &context, const LogicalType &target_type, bool strict = false);
 	DUCKDB_API bool DefaultTryCastAs(const LogicalType &target_type, bool strict = false);
 
@@ -3108,7 +3111,8 @@ public:
 
 	//! Returns true if the values are (approximately) equivalent. Note this is NOT the SQL equivalence. For this
 	//! function, NULL values are equivalent and floating point values that are close are equivalent.
-	DUCKDB_API static bool ValuesAreEqual(CastFunctionSet &set, const Value &result_value, const Value &value);
+	DUCKDB_API static bool ValuesAreEqual(CastFunctionSet &set, GetCastFunctionInput &get_input,
+	                                      const Value &result_value, const Value &value);
 	DUCKDB_API static bool ValuesAreEqual(ClientContext &context, const Value &result_value, const Value &value);
 	DUCKDB_API static bool DefaultValuesAreEqual(const Value &result_value, const Value &value);
 	//! Returns true if the values are not distinct from each other, following SQL semantics for NOT DISTINCT FROM.
@@ -4906,6 +4910,7 @@ private:
 
 namespace duckdb {
 class CastFunctionSet;
+struct GetCastFunctionInput;
 
 // VectorOperations contains a set of operations that operate on sets of
 // vectors. In general, the operators must all have the same type, otherwise an
@@ -5047,8 +5052,8 @@ struct VectorOperations {
 	//! Cast the data from the source type to the target type. Any elements that could not be converted are turned into
 	//! NULLs. If any elements cannot be converted, returns false and fills in the error_message. If no error message is
 	//! provided, an exception is thrown instead.
-	DUCKDB_API static bool TryCast(CastFunctionSet &set, Vector &source, Vector &result, idx_t count,
-	                               string *error_message, bool strict = false);
+	DUCKDB_API static bool TryCast(CastFunctionSet &set, GetCastFunctionInput &input, Vector &source, Vector &result,
+	                               idx_t count, string *error_message, bool strict = false);
 	DUCKDB_API static bool DefaultTryCast(Vector &source, Vector &result, idx_t count, string *error_message,
 	                                      bool strict = false);
 	DUCKDB_API static bool TryCast(ClientContext &context, Vector &source, Vector &result, idx_t count,
@@ -14995,11 +15000,14 @@ public:
 };
 
 struct BindCastInput {
-	BindCastInput(CastFunctionSet &function_set, BindCastInfo *info) : function_set(function_set), info(info) {
-	}
+	DUCKDB_API BindCastInput(CastFunctionSet &function_set, BindCastInfo *info, ClientContext *context);
 
 	CastFunctionSet &function_set;
 	BindCastInfo *info;
+	ClientContext *context;
+
+public:
+	DUCKDB_API BoundCastInfo GetCastFunction(const LogicalType &source, const LogicalType &target);
 };
 
 struct DefaultCasts {
@@ -27262,7 +27270,7 @@ private:
 	bool TryParseComplexCSV(DataChunk &insert_chunk, string &error_message);
 
 	//! Adds a value to the current row
-	void AddValue(char *str_val, idx_t length, idx_t &column, vector<idx_t> &escape_positions);
+	void AddValue(char *str_val, idx_t length, idx_t &column, vector<idx_t> &escape_positions, bool has_quotes);
 	//! Adds a row to the insert_chunk, returns true if the chunk is filled as a result of this row being added
 	bool AddRow(DataChunk &insert_chunk, idx_t &column);
 	//! Finalizes a chunk, parsing all values that have been added so far and adding them to the insert_chunk