duckdb 1.3.1-dev6.0 → 1.3.1

package/src/duckdb/src/common/tree_renderer/html_tree_renderer.cpp

@@ -15,25 +15,25 @@
 namespace duckdb {
 
 string HTMLTreeRenderer::ToString(const LogicalOperator &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string HTMLTreeRenderer::ToString(const PhysicalOperator &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string HTMLTreeRenderer::ToString(const ProfilingNode &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string HTMLTreeRenderer::ToString(const Pipeline &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }

package/src/duckdb/src/common/tree_renderer/json_tree_renderer.cpp

@@ -19,25 +19,25 @@ using namespace duckdb_yyjson; // NOLINT
 namespace duckdb {
 
 string JSONTreeRenderer::ToString(const LogicalOperator &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string JSONTreeRenderer::ToString(const PhysicalOperator &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string JSONTreeRenderer::ToString(const ProfilingNode &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string JSONTreeRenderer::ToString(const Pipeline &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }

package/src/duckdb/src/common/tree_renderer/text_tree_renderer.cpp

@@ -283,25 +283,25 @@ void TextTreeRenderer::RenderBoxContent(RenderTree &root, std::ostream &ss, idx_
 }
 
 string TextTreeRenderer::ToString(const LogicalOperator &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string TextTreeRenderer::ToString(const PhysicalOperator &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string TextTreeRenderer::ToString(const ProfilingNode &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string TextTreeRenderer::ToString(const Pipeline &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }

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

@@ -26,7 +26,7 @@ static inline void SwapTupleDataChunk(TupleDataChunk &a, TupleDataChunk &b) noex
 	std::swap(a.lock, b.lock);
 }
 
-TupleDataChunk::TupleDataChunk(TupleDataChunk &&other) noexcept {
+TupleDataChunk::TupleDataChunk(TupleDataChunk &&other) noexcept : count(0) {
 	SwapTupleDataChunk(*this, other);
 }
 

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

@@ -1,4 +1,5 @@
 #include "duckdb/common/types/uuid.hpp"
+#include "duckdb/common/chrono.hpp"
 #include "duckdb/common/random_engine.hpp"
 
 namespace duckdb {
@@ -210,7 +211,10 @@ hugeint_t UUIDv7::GenerateRandomUUID(RandomEngine &engine) {
 	// Fill in variant field.
 	bytes[8] = (bytes[8] & 0x3f) | 0x80;
 
-	return Convert(bytes);
+	// Flip the top byte
+	auto result = Convert(bytes);
+	result.upper ^= NumericLimits<int64_t>::Minimum();
+	return result;
 }
 
 hugeint_t UUIDv7::GenerateRandomUUID() {

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

@@ -648,6 +648,34 @@ bool LogicalType::IsIntegral() const {
 	}
 }
 
+bool LogicalType::IsSigned() const {
+	switch (id_) {
+	case LogicalTypeId::TINYINT:
+	case LogicalTypeId::SMALLINT:
+	case LogicalTypeId::INTEGER:
+	case LogicalTypeId::BIGINT:
+	case LogicalTypeId::HUGEINT:
+		return true;
+	default:
+		break;
+	}
+	return false;
+}
+
+bool LogicalType::IsUnsigned() const {
+	switch (id_) {
+	case LogicalTypeId::UTINYINT:
+	case LogicalTypeId::USMALLINT:
+	case LogicalTypeId::UINTEGER:
+	case LogicalTypeId::UBIGINT:
+	case LogicalTypeId::UHUGEINT:
+		return true;
+	default:
+		break;
+	}
+	return false;
+}
+
 bool LogicalType::IsFloating() const {
 	switch (id_) {
 	case LogicalTypeId::FLOAT:

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

@@ -41,6 +41,11 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFileExtended(const OpenFileInfo &f
 	} else if (compression != FileCompressionType::UNCOMPRESSED) {
 		auto entry = compressed_fs.find(compression);
 		if (entry == compressed_fs.end()) {
+			if (compression == FileCompressionType::ZSTD) {
+				throw NotImplementedException(
+				    "Attempting to open a compressed file, but the compression type is not supported.\nConsider "
+				    "explicitly \"INSTALL parquet; LOAD parquet;\" to support this compression scheme");
+			}
 			throw NotImplementedException(
 			    "Attempting to open a compressed file, but the compression type is not supported");
 		}

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

@@ -26,13 +26,6 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		for (auto &cond : comp_join.conditions) {
 			VisitExpression(&cond.left);
 		}
-		// resolve any single-side predicates
-		// for now, only ASOF supports this, and we are guaranteed that all right side predicates
-		// have been pushed into a filter.
-		if (comp_join.predicate) {
-			D_ASSERT(op.type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
-			VisitExpression(&comp_join.predicate);
-		}
 		// visit the duplicate eliminated columns on the LHS, if any
 		for (auto &expr : comp_join.duplicate_eliminated_columns) {
 			VisitExpression(&expr);
@@ -44,40 +37,38 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		}
 		// finally update the bindings with the result bindings of the join
 		bindings = op.GetColumnBindings();
+		types = op.types;
+		// resolve any mixed predicates
+		// for now, only ASOF supports this.
+		if (comp_join.predicate) {
+			D_ASSERT(op.type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
+			VisitExpression(&comp_join.predicate);
+		}
 		return;
 	}
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
 		auto &comp_join = op.Cast<LogicalComparisonJoin>();
-		// depending on whether the delim join has been flipped, get the appropriate bindings
-		if (comp_join.delim_flipped) {
-			VisitOperator(*comp_join.children[1]);
-			for (auto &cond : comp_join.conditions) {
-				VisitExpression(&cond.right);
-			}
-		} else {
-			VisitOperator(*comp_join.children[0]);
-			for (auto &cond : comp_join.conditions) {
-				VisitExpression(&cond.left);
-			}
+		// get bindings from the duplicate-eliminated side
+		auto &delim_side = comp_join.delim_flipped ? *comp_join.children[1] : *comp_join.children[0];
+		VisitOperator(delim_side);
+		for (auto &cond : comp_join.conditions) {
+			auto &expr = comp_join.delim_flipped ? cond.right : cond.left;
+			VisitExpression(&expr);
 		}
 		// visit the duplicate eliminated columns
 		for (auto &expr : comp_join.duplicate_eliminated_columns) {
 			VisitExpression(&expr);
 		}
-		// now get the other side
-		if (comp_join.delim_flipped) {
-			VisitOperator(*comp_join.children[0]);
-			for (auto &cond : comp_join.conditions) {
-				VisitExpression(&cond.left);
-			}
-		} else {
-			VisitOperator(*comp_join.children[1]);
-			for (auto &cond : comp_join.conditions) {
-				VisitExpression(&cond.right);
-			}
+		// now the other side
+		auto &other_side = comp_join.delim_flipped ? *comp_join.children[0] : *comp_join.children[1];
+		VisitOperator(other_side);
+		for (auto &cond : comp_join.conditions) {
+			auto &expr = comp_join.delim_flipped ? cond.left : cond.right;
+			VisitExpression(&expr);
 		}
 		// finally update the bindings with the result bindings of the join
 		bindings = op.GetColumnBindings();
+		types = op.types;
 		return;
 	}
 	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
@@ -86,10 +77,13 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		// this operator
 		VisitOperatorChildren(op);
 		bindings = op.GetColumnBindings();
+		types = op.types;
 		auto &any_join = op.Cast<LogicalAnyJoin>();
 		if (any_join.join_type == JoinType::SEMI || any_join.join_type == JoinType::ANTI) {
 			auto right_bindings = op.children[1]->GetColumnBindings();
 			bindings.insert(bindings.end(), right_bindings.begin(), right_bindings.end());
+			auto &right_types = op.children[1]->types;
+			types.insert(types.end(), right_types.begin(), right_types.end());
 		}
 		if (any_join.join_type == JoinType::RIGHT_SEMI || any_join.join_type == JoinType::RIGHT_ANTI) {
 			throw InternalException("RIGHT SEMI/ANTI any join not supported yet");
@@ -102,12 +96,15 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		// afterwards bind the expressions of the CREATE INDEX statement
 		auto &create_index = op.Cast<LogicalCreateIndex>();
 		bindings = LogicalOperator::GenerateColumnBindings(0, create_index.table.GetColumns().LogicalColumnCount());
+		// TODO: fill types in too (clearing skips type checks)
+		types.clear();
 		VisitOperatorExpressions(op);
 		return;
 	}
 	case LogicalOperatorType::LOGICAL_GET: {
 		//! We first need to update the current set of bindings and then visit operator expressions
 		bindings = op.GetColumnBindings();
+		types = op.types;
 		VisitOperatorExpressions(op);
 		return;
 	}
@@ -123,6 +120,8 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 			// Now insert our dummy bindings at the start of the bindings,
 			// so the first 'column_count' indices of the chunk are reserved for our 'excluded' columns
 			bindings.insert(bindings.begin(), dummy_bindings.begin(), dummy_bindings.end());
+			// TODO: fill types in too (clearing skips type checks)
+			types.clear();
 			if (insert_op.on_conflict_condition) {
 				VisitExpression(&insert_op.on_conflict_condition);
 			}
@@ -131,20 +130,25 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 			}
 			VisitOperatorExpressions(op);
 			bindings = op.GetColumnBindings();
+			types = op.types;
 			return;
 		}
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR: {
 		auto &ext_op = op.Cast<LogicalExtensionOperator>();
+		// Just to be very sure, we clear before and after resolving extension operator column bindings
+		// This skips checks, but makes sure we don't break any extension operators with type verification
+		types.clear();
 		ext_op.ResolveColumnBindings(*this, bindings);
+		types.clear();
 		return;
 	}
 	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE: {
 		auto &rec = op.Cast<LogicalRecursiveCTE>();
 		VisitOperatorChildren(op);
 		bindings = op.GetColumnBindings();
-
+		types = op.types;
 		for (auto &expr : rec.key_targets) {
 			VisitExpression(&expr);
 		}
@@ -161,6 +165,7 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 	VisitOperatorExpressions(op);
 	// finally update the current set of bindings to the current set of column bindings
 	bindings = op.GetColumnBindings();
+	types = op.types;
 }
 
 unique_ptr<Expression> ColumnBindingResolver::VisitReplace(BoundColumnRefExpression &expr,
@@ -169,6 +174,19 @@ unique_ptr<Expression> ColumnBindingResolver::VisitReplace(BoundColumnRefExpress
 	// check the current set of column bindings to see which index corresponds to the column reference
 	for (idx_t i = 0; i < bindings.size(); i++) {
 		if (expr.binding == bindings[i]) {
+			if (!types.empty()) {
+				if (bindings.size() != types.size()) {
+					throw InternalException(
+					    "Failed to bind column reference \"%s\" [%d.%d]: inequal num bindings/types (%llu != %llu)",
+					    expr.GetAlias(), expr.binding.table_index, expr.binding.column_index, bindings.size(),
+					    types.size());
+				}
+				if (expr.return_type != types[i]) {
+					throw InternalException("Failed to bind column reference \"%s\" [%d.%d]: inequal types (%s != %s)",
+					                        expr.GetAlias(), expr.binding.table_index, expr.binding.column_index,
+					                        expr.return_type.ToString(), types[i].ToString());
+				}
+			}
 			if (verify_only) {
 				// in verification mode
 				return nullptr;
@@ -210,6 +228,7 @@ unordered_set<idx_t> ColumnBindingResolver::VerifyInternal(LogicalOperator &op)
 
 void ColumnBindingResolver::Verify(LogicalOperator &op) {
 #ifdef DEBUG
+	op.ResolveOperatorTypes();
 	ColumnBindingResolver resolver(true);
 	resolver.VisitOperator(op);
 	VerifyInternal(op);

package/src/duckdb/src/execution/index/fixed_size_allocator.cpp

@@ -316,6 +316,10 @@ void FixedSizeAllocator::Init(const FixedSizeAllocatorInfo &info) {
 		}
 
 		auto buffer_block_pointer = info.block_pointers[i];
+		if (buffer_block_pointer.block_id >= MAXIMUM_BLOCK) {
+			throw SerializationException("invalid block ID in index storage information");
+		}
+
 		auto segment_count = info.segment_counts[i];
 		auto allocation_size = info.allocation_sizes[i];
 

package/src/duckdb/src/execution/join_hashtable.cpp

@@ -8,6 +8,7 @@
 #include "duckdb/storage/buffer_manager.hpp"
 
 namespace duckdb {
+
 using ValidityBytes = JoinHashTable::ValidityBytes;
 using ScanStructure = JoinHashTable::ScanStructure;
 using ProbeSpill = JoinHashTable::ProbeSpill;
@@ -29,9 +30,10 @@ JoinHashTable::InsertState::InsertState(const JoinHashTable &ht)
 	ht.data_collection->InitializeChunkState(chunk_state, ht.equality_predicate_columns);
 }
 
-JoinHashTable::JoinHashTable(ClientContext &context_p, const vector<JoinCondition> &conditions_p,
-                             vector<LogicalType> btypes, JoinType type_p, const vector<idx_t> &output_columns_p)
-    : context(context_p), buffer_manager(BufferManager::GetBufferManager(context)), conditions(conditions_p),
+JoinHashTable::JoinHashTable(ClientContext &context_p, const PhysicalOperator &op_p,
+                             const vector<JoinCondition> &conditions_p, vector<LogicalType> btypes, JoinType type_p,
+                             const vector<idx_t> &output_columns_p)
+    : context(context_p), op(op_p), buffer_manager(BufferManager::GetBufferManager(context)), conditions(conditions_p),
       build_types(std::move(btypes)), output_columns(output_columns_p), entry_size(0), tuple_size(0),
       vfound(Value::BOOLEAN(false)), join_type(type_p), finalized(false), has_null(false),
       radix_bits(INITIAL_RADIX_BITS) {
@@ -258,7 +260,6 @@ static void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &key_sta
 
 	// densify hashes: If there is no sel, flatten the hashes, else densify via UnifiedVectorFormat
 	if (has_row_sel) {
-
 		hashes_v.ToUnifiedFormat(count, hashes_unified_v);
 		uses_unified = true;
 
@@ -271,8 +272,7 @@ static void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &key_sta
 			hashes_dense[i] = hashes_unified[uvf_index];
 		}
 	} else {
-		hashes_v.Flatten(count);
-		state.hashes_dense_v.Reference(hashes_v);
+		VectorOperations::Copy(hashes_v, state.hashes_dense_v, count, 0, 0);
 	}
 
 	// the number of keys that match for all iterations of the following loop
@@ -282,7 +282,6 @@ static void GetRowPointersInternal(DataChunk &keys, TupleDataChunkState &key_sta
 	idx_t elements_to_probe_count = count;
 
 	do {
-
 		const idx_t keys_to_compare_count = ProbeForPointers<USE_SALTS>(state, ht, entries, hashes_v, pointers_result_v,
 		                                                                row_sel, elements_to_probe_count, has_row_sel);
 
@@ -756,6 +755,10 @@ void JoinHashTable::AllocatePointerTable() {
 	D_ASSERT(hash_map.GetSize() == capacity * sizeof(ht_entry_t));
 
 	bitmask = capacity - 1;
+
+	DUCKDB_LOG(context, PhysicalOperatorLogType, op, "JoinHashTable", "Build",
+	           {{"rows", to_string(data_collection->Count())},
+	            {"size", to_string(data_collection->SizeInBytes() + hash_map.GetSize())}});
 }
 
 void JoinHashTable::InitializePointerTable(idx_t entry_idx_from, idx_t entry_idx_to) {

package/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp

@@ -4,7 +4,6 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/aggregate_function.hpp"
 #include "duckdb/parallel/thread_context.hpp"
-#include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/expression/bound_window_expression.hpp"
 
 namespace duckdb {
@@ -109,7 +108,7 @@ public:
 
 	struct LeadLagState {
 		//	Fixed size
-		static constexpr idx_t MAX_BUFFER = 2048U;
+		static constexpr int64_t MAX_BUFFER = 2048;
 
 		static bool ComputeOffset(ClientContext &context, BoundWindowExpression &wexpr, int64_t &offset) {
 			offset = 1;
@@ -132,7 +131,7 @@ public:
 			if (wexpr.GetExpressionType() == ExpressionType::WINDOW_LEAD) {
 				offset = -offset;
 			}
-			return idx_t(std::abs(offset)) < MAX_BUFFER;
+			return std::abs(offset) < MAX_BUFFER;
 		}
 
 		static bool ComputeDefault(ClientContext &context, BoundWindowExpression &wexpr, Value &result) {
@@ -413,6 +412,7 @@ void StreamingWindowState::AggregateState::Execute(ExecutionContext &context, Da
 
 	// Compute the arguments
 	auto &arg_chunk = aggr_state.arg_chunk;
+	arg_chunk.Reset();
 	executor.Execute(input, arg_chunk);
 	arg_chunk.Flatten();
 

package/src/duckdb/src/execution/operator/csv_scanner/encode/csv_encoder.cpp

@@ -8,7 +8,7 @@ namespace duckdb {
 
 void CSVEncoderBuffer::Initialize(idx_t encoded_size) {
 	encoded_buffer_size = encoded_size;
-	encoded_buffer = std::unique_ptr<char[]>(new char[encoded_size]);
+	encoded_buffer = duckdb::unique_ptr<char[]>(new char[encoded_size]);
 }
 
 char *CSVEncoderBuffer::Ptr() const {

package/src/duckdb/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp

@@ -15,6 +15,7 @@ void ColumnCountResult::AddValue(ColumnCountResult &result, idx_t buffer_pos) {
 inline void ColumnCountResult::InternalAddRow() {
 	const idx_t column_count = current_column_count + 1;
 	column_counts[result_position].number_of_columns = column_count;
+	column_counts[result_position].empty_lines = empty_lines;
 	rows_per_column_count[column_count]++;
 	current_column_count = 0;
 }
@@ -102,7 +103,7 @@ void ColumnCountResult::InvalidState(ColumnCountResult &result) {
 }
 
 bool ColumnCountResult::EmptyLine(ColumnCountResult &result, idx_t buffer_pos) {
-	// nop
+	result.empty_lines++;
 	return false;
 }
 

package/src/duckdb/src/execution/operator/csv_scanner/scanner/skip_scanner.cpp

@@ -51,10 +51,7 @@ void SkipResult::InvalidState(SkipResult &result) {
 }
 
 bool SkipResult::EmptyLine(SkipResult &result, const idx_t buffer_pos) {
-	if (result.state_machine.dialect_options.num_cols == 1) {
-		return AddRow(result, buffer_pos);
-	}
-	return false;
+	return AddRow(result, buffer_pos);
 }
 
 SkipScanner::SkipScanner(shared_ptr<CSVBufferManager> buffer_manager, const shared_ptr<CSVStateMachine> &state_machine,

package/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp

@@ -26,7 +26,9 @@ StringValueResult::StringValueResult(CSVStates &states, CSVStateMachine &state_m
     : ScannerResult(states, state_machine, result_size_p),
       number_of_columns(NumericCast<uint32_t>(state_machine.dialect_options.num_cols)),
       null_padding(state_machine.options.null_padding), ignore_errors(state_machine.options.ignore_errors.GetValue()),
-      extra_delimiter_bytes(state_machine.dialect_options.state_machine_options.delimiter.GetValue().size() - 1),
+      extra_delimiter_bytes(state_machine.dialect_options.state_machine_options.delimiter.GetValue().empty()
+                                ? 0
+                                : state_machine.dialect_options.state_machine_options.delimiter.GetValue().size() - 1),
       error_handler(error_hander_p), iterator(iterator_p), store_line_size(store_line_size_p),
       csv_file_scan(std::move(csv_file_scan_p)), lines_read(lines_read_p),
       current_errors(scan_id, state_machine.options.IgnoreErrors()), sniffing(sniffing_p), path(std::move(path_p)) {
@@ -565,6 +567,22 @@ void StringValueResult::AddPossiblyEscapedValue(StringValueResult &result, const
 				result.cur_col_id++;
 				result.chunk_col_id++;
 			} else {
+				if (result.parse_chunk.data[result.chunk_col_id].GetType() != LogicalType::VARCHAR) {
+					// We cant have escapes on non varchar columns
+					result.current_errors.Insert(CAST_ERROR, result.cur_col_id, result.chunk_col_id,
+					                             result.last_position);
+					if (!result.state_machine.options.IgnoreErrors()) {
+						// We have to write the cast error message.
+						std::ostringstream error;
+						// Casting Error Message
+						error << "Could not convert string \"" << std::string(value_ptr, length) << "\" to \'"
+						      << LogicalTypeIdToString(result.parse_types[result.chunk_col_id].type_id) << "\'";
+						auto error_string = error.str();
+						FullLinePosition::SanitizeError(error_string);
+						result.current_errors.ModifyErrorMessageOfLastError(error_string);
+					}
+					return;
+				}
 				auto value = StringValueScanner::RemoveEscape(
 				    value_ptr, length, result.state_machine.dialect_options.state_machine_options.escape.GetValue(),
 				    result.state_machine.dialect_options.state_machine_options.quote.GetValue(),
@@ -1446,6 +1464,23 @@ void StringValueScanner::ProcessOverBufferValue() {
 			if (result.escaped) {
 				if (!result.HandleTooManyColumnsError(over_buffer_string.c_str(), over_buffer_string.size())) {
 					const auto str_ptr = over_buffer_string.c_str() + result.quoted_position;
+					if (result.parse_chunk.data[result.chunk_col_id].GetType() != LogicalType::VARCHAR) {
+						// We cant have escapes on non varchar columns
+						result.current_errors.Insert(CAST_ERROR, result.cur_col_id, result.chunk_col_id,
+						                             result.last_position);
+						if (!result.state_machine.options.IgnoreErrors()) {
+							// We have to write the cast error message.
+							std::ostringstream error;
+							// Casting Error Message
+							error << "Could not convert string \""
+							      << std::string(over_buffer_string.c_str(), over_buffer_string.size()) << "\" to \'"
+							      << LogicalTypeIdToString(result.parse_types[result.chunk_col_id].type_id) << "\'";
+							auto error_string = error.str();
+							FullLinePosition::SanitizeError(error_string);
+							result.current_errors.ModifyErrorMessageOfLastError(error_string);
+						}
+						return;
+					}
 					value =
 					    RemoveEscape(str_ptr, over_buffer_string.size() - 2,
 					                 state_machine->dialect_options.state_machine_options.escape.GetValue(),
@@ -1457,6 +1492,23 @@ void StringValueScanner::ProcessOverBufferValue() {
 		} else {
 			value = string_t(over_buffer_string.c_str(), UnsafeNumericCast<uint32_t>(over_buffer_string.size()));
 			if (result.escaped) {
+				if (result.parse_chunk.data[result.chunk_col_id].GetType() != LogicalType::VARCHAR) {
+					// We cant have escapes on non varchar columns
+					result.current_errors.Insert(CAST_ERROR, result.cur_col_id, result.chunk_col_id,
+					                             result.last_position);
+					if (!result.state_machine.options.IgnoreErrors()) {
+						// We have to write the cast error message.
+						std::ostringstream error;
+						// Casting Error Message
+						error << "Could not convert string \""
+						      << std::string(over_buffer_string.c_str(), over_buffer_string.size()) << "\" to \'"
+						      << LogicalTypeIdToString(result.parse_types[result.chunk_col_id].type_id) << "\'";
+						auto error_string = error.str();
+						FullLinePosition::SanitizeError(error_string);
+						result.current_errors.ModifyErrorMessageOfLastError(error_string);
+					}
+					return;
+				}
 				if (!result.HandleTooManyColumnsError(over_buffer_string.c_str(), over_buffer_string.size())) {
 					value =
 					    RemoveEscape(over_buffer_string.c_str(), over_buffer_string.size(),