duckdb 0.8.2-dev4653.0 → 0.8.2-dev4871.0

package/src/duckdb/src/include/duckdb/execution/join_hashtable.hpp

@@ -65,7 +65,7 @@ public:
 	//! returned by the JoinHashTable::Scan function and can be used to resume a
 	//! probe.
 	struct ScanStructure {
-		unsafe_unique_array<UnifiedVectorFormat> key_data;
+		TupleDataChunkState &key_state;
 		Vector pointers;
 		idx_t count;
 		SelectionVector sel_vector;
@@ -74,7 +74,7 @@ public:
 		JoinHashTable &ht;
 		bool finished;
 
-		explicit ScanStructure(JoinHashTable &ht);
+		explicit ScanStructure(JoinHashTable &ht, TupleDataChunkState &key_state);
 		//! Get the next batch of data from the scan structure
 		void Next(DataChunk &keys, DataChunk &left, DataChunk &result);
 
@@ -130,7 +130,8 @@ public:
 	//! ever called.
 	void Finalize(idx_t chunk_idx_from, idx_t chunk_idx_to, bool parallel);
 	//! Probe the HT with the given input chunk, resulting in the given result
-	unique_ptr<ScanStructure> Probe(DataChunk &keys, Vector *precomputed_hashes = nullptr);
+	unique_ptr<ScanStructure> Probe(DataChunk &keys, TupleDataChunkState &key_state,
+	                                Vector *precomputed_hashes = nullptr);
 	//! Scan the HT to construct the full outer join result
 	void ScanFullOuter(JoinHTScanState &state, Vector &addresses, DataChunk &result);
 
@@ -166,6 +167,9 @@ public:
 	vector<ExpressionType> predicates;
 	//! Data column layout
 	TupleDataLayout layout;
+	//! Efficiently matches rows
+	RowMatcher row_matcher;
+	RowMatcher row_matcher_no_match_sel;
 	//! The size of an entry as stored in the HashTable
 	idx_t entry_size;
 	//! The total tuple size
@@ -201,7 +205,8 @@ public:
 	} correlated_mark_join_info;
 
 private:
-	unique_ptr<ScanStructure> InitializeScanStructure(DataChunk &keys, const SelectionVector *&current_sel);
+	unique_ptr<ScanStructure> InitializeScanStructure(DataChunk &keys, TupleDataChunkState &key_state,
+	                                                  const SelectionVector *&current_sel);
 	void Hash(DataChunk &keys, const SelectionVector &sel, idx_t count, Vector &hashes);
 
 	//! Apply a bitmask to the hashes
@@ -212,8 +217,8 @@ private:
 	//! Insert the given set of locations into the HT with the given set of hashes
 	void InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[], bool parallel);
 
-	idx_t PrepareKeys(DataChunk &keys, unsafe_unique_array<UnifiedVectorFormat> &key_data,
-	                  const SelectionVector *&current_sel, SelectionVector &sel, bool build_side);
+	idx_t PrepareKeys(DataChunk &keys, vector<TupleDataVectorFormat> &vector_data, const SelectionVector *&current_sel,
+	                  SelectionVector &sel, bool build_side);
 
 	//! Lock for combining data_collection when merging HTs
 	mutex data_lock;
@@ -316,8 +321,9 @@ public:
 	//! Build HT for the next partitioned probe round
 	bool PrepareExternalFinalize();
 	//! Probe whatever we can, sink the rest into a thread-local HT
-	unique_ptr<ScanStructure> ProbeAndSpill(DataChunk &keys, DataChunk &payload, ProbeSpill &probe_spill,
-	                                        ProbeSpillLocalAppendState &spill_state, DataChunk &spill_chunk);
+	unique_ptr<ScanStructure> ProbeAndSpill(DataChunk &keys, TupleDataChunkState &key_state, DataChunk &payload,
+	                                        ProbeSpill &probe_spill, ProbeSpillLocalAppendState &spill_state,
+	                                        DataChunk &spill_chunk);
 
 private:
 	//! First and last partition of the current probe round

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/base_csv_reader.hpp

@@ -78,6 +78,10 @@ public:
 		return line_error + 1;
 	};
 
+	virtual void Increment(idx_t buffer_idx) {
+		return;
+	}
+
 	//! Initialize projection indices to select all columns
 	void InitializeProjection();
 

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_buffer.hpp

@@ -89,7 +89,7 @@ public:
 private:
 	ClientContext &context;
 	//! Actual size can be smaller than the buffer size in case we allocate it too optimistically.
-	idx_t file_size;
+	idx_t actual_buffer_size;
 	//! We need to check for Byte Order Mark, to define the start position of this buffer
 	//! https://en.wikipedia.org/wiki/Byte_order_mark#UTF-8
 	idx_t start_position = 0;

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_line_info.hpp

@@ -20,10 +20,14 @@ public:
 	//! Return the 1-indexed line number
 	idx_t GetLine(idx_t batch_idx, idx_t line_error = 0, idx_t file_idx = 0, idx_t cur_start = 0, bool verify = true,
 	              bool stop_at_first = true);
+	//! In case an error happened we have to increment the lines read of that batch
+	void Increment(idx_t file_idx, idx_t batch_idx);
 	//! Verify if the CSV File was read correctly from [0,batch_idx] batches.
 	void Verify(idx_t file_idx, idx_t batch_idx, idx_t cur_first_pos);
 	//! Lines read per batch, <file_index, <batch_index, count>>
 	vector<unordered_map<idx_t, idx_t>> lines_read;
+	//! Lines read per batch, <file_index, <batch_index, count>>
+	vector<unordered_map<idx_t, idx_t>> lines_errored;
 	//! Set of batches that have been initialized but are not yet finished.
 	vector<set<idx_t>> current_batches;
 	//! Pointer to CSV Reader Mutex

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_reader_options.hpp

@@ -126,12 +126,10 @@ struct CSVReaderOptions {
 	bool normalize_names = false;
 	//! True, if column with that index must skip null check
 	vector<bool> force_not_null;
+	//! Number of sample chunks used in auto-detection
+	idx_t sample_size_chunks = 20480 / STANDARD_VECTOR_SIZE;
 	//! Consider all columns to be of type varchar
 	bool all_varchar = false;
-	//! Size of sample chunk used for dialect and type detection
-	idx_t sample_chunk_size = STANDARD_VECTOR_SIZE;
-	//! Number of sample chunks used for type detection
-	idx_t sample_chunks = 10;
 	//! Whether or not to automatically detect dialect and datatypes
 	bool auto_detect = false;
 	//! The file path of the CSV file to read

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_sniffer.hpp

@@ -28,7 +28,7 @@ struct SnifferResult {
 class CSVSniffer {
 public:
 	explicit CSVSniffer(CSVReaderOptions &options_p, shared_ptr<CSVBufferManager> buffer_manager_p,
-	                    CSVStateMachineCache &state_machine_cache);
+	                    CSVStateMachineCache &state_machine_cache, bool explicit_set_columns = false);
 
 	//! Main method that sniffs the CSV file, returns the types, names and options as a result
 	//! CSV Sniffing consists of five steps:
@@ -110,6 +110,8 @@ private:
 	//! ------------------------------------------------------//
 	void DetectHeader();
 	vector<string> names;
+	//! If Column Names and Types have been explicitly set
+	const bool explicit_set_columns;
 
 	//! ------------------------------------------------------//
 	//! ------------------ Type Replacement ----------------- //

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/csv_state_machine_cache.hpp

@@ -13,7 +13,7 @@
 #include "duckdb/execution/operator/scan/csv/quote_rules.hpp"
 
 namespace duckdb {
-static constexpr uint32_t NUM_STATES = 8;
+static constexpr uint32_t NUM_STATES = 9;
 static constexpr uint32_t NUM_TRANSITIONS = 256;
 typedef uint8_t state_machine_t[NUM_STATES][NUM_TRANSITIONS];
 

package/src/duckdb/src/include/duckdb/execution/operator/scan/csv/parallel_csv_reader.hpp

@@ -134,6 +134,7 @@ public:
 	void ParseCSV(DataChunk &insert_chunk);
 
 	idx_t GetLineError(idx_t line_error, idx_t buffer_idx, bool stop_at_first = true) override;
+	void Increment(idx_t buffer_idx) override;
 
 private:
 	//! Initialize Parser

package/src/duckdb/src/include/duckdb/execution/radix_partitioned_hashtable.hpp

@@ -51,13 +51,12 @@ public:
 	                         OperatorSourceInput &input) const;
 
 	const TupleDataLayout &GetLayout() const;
-	idx_t Count(GlobalSinkState &sink) const;
+	idx_t NumberOfPartitions(GlobalSinkState &sink) const;
 	static void SetMultiScan(GlobalSinkState &sink);
 
 private:
 	void SetGroupingValues();
 	void PopulateGroupChunk(DataChunk &group_chunk, DataChunk &input_chunk) const;
-	idx_t CountInternal(GlobalSinkState &sink) const;
 
 	TupleDataLayout layout;
 };

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -240,6 +240,7 @@ static constexpr ExtensionEntry EXTENSION_FILE_CONTAINS[] = {{".parquet?", "parq
 
 static constexpr const char *AUTOLOADABLE_EXTENSIONS[] = {
     //    "azure",
+    "arrow",
     "aws",
     "autocomplete",
     "excel",
@@ -249,7 +250,9 @@ static constexpr const char *AUTOLOADABLE_EXTENSIONS[] = {
     // "icu",
     "json",
     "parquet",
+    "postgres_scanner",
     "sqlsmith",
+    "sqlite_scanner",
     "tpcds",
     "tpch",
     "visualizer",

package/src/duckdb/src/include/duckdb/main/relation.hpp

@@ -103,6 +103,8 @@ public:
 	// JOIN operation
 	DUCKDB_API shared_ptr<Relation> Join(const shared_ptr<Relation> &other, const string &condition,
 	                                     JoinType type = JoinType::INNER, JoinRefType ref_type = JoinRefType::REGULAR);
+	shared_ptr<Relation> Join(const shared_ptr<Relation> &other, vector<unique_ptr<ParsedExpression>> condition,
+	                          JoinType type = JoinType::INNER, JoinRefType ref_type = JoinRefType::REGULAR);
 
 	// CROSS PRODUCT operation
 	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other,
@@ -121,6 +123,8 @@ public:
 	DUCKDB_API shared_ptr<Relation> Aggregate(const vector<string> &aggregates);
 	DUCKDB_API shared_ptr<Relation> Aggregate(const string &aggregate_list, const string &group_list);
 	DUCKDB_API shared_ptr<Relation> Aggregate(const vector<string> &aggregates, const vector<string> &groups);
+	DUCKDB_API shared_ptr<Relation> Aggregate(vector<unique_ptr<ParsedExpression>> expressions,
+	                                          const string &group_list);
 
 	// ALIAS
 	DUCKDB_API shared_ptr<Relation> Alias(const string &alias);

package/src/duckdb/src/main/config.cpp

@@ -177,7 +177,7 @@ void DBConfig::SetOptionByName(const string &name, const Value &value) {
 void DBConfig::SetOption(DatabaseInstance *db, const ConfigurationOption &option, const Value &value) {
 	lock_guard<mutex> l(config_lock);
 	if (!option.set_global) {
-		throw InternalException("Could not set option \"%s\" as a global option", option.name);
+		throw InvalidInputException("Could not set option \"%s\" as a global option", option.name);
 	}
 	D_ASSERT(option.reset_global);
 	Value input = value.DefaultCastAs(option.parameter_type);

package/src/duckdb/src/main/query_result.cpp

@@ -1,8 +1,9 @@
 #include "duckdb/main/query_result.hpp"
+
+#include "duckdb/common/box_renderer.hpp"
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/main/client_context.hpp"
-#include "duckdb/common/box_renderer.hpp"
 namespace duckdb {
 
 BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties_p,
@@ -100,9 +101,17 @@ bool QueryResult::Equals(QueryResult &other) { // LCOV_EXCL_START
 	}
 	// now compare the actual values
 	// fetch chunks
+	unique_ptr<DataChunk> lchunk, rchunk;
+	idx_t lindex = 0, rindex = 0;
 	while (true) {
-		auto lchunk = Fetch();
-		auto rchunk = other.Fetch();
+		if (!lchunk || lindex == lchunk->size()) {
+			lchunk = Fetch();
+			lindex = 0;
+		}
+		if (!rchunk || rindex == rchunk->size()) {
+			rchunk = other.Fetch();
+			rindex = 0;
+		}
 		if (!lchunk && !rchunk) {
 			return true;
 		}
@@ -112,14 +121,11 @@ bool QueryResult::Equals(QueryResult &other) { // LCOV_EXCL_START
 		if (lchunk->size() == 0 && rchunk->size() == 0) {
 			return true;
 		}
-		if (lchunk->size() != rchunk->size()) {
-			return false;
-		}
 		D_ASSERT(lchunk->ColumnCount() == rchunk->ColumnCount());
-		for (idx_t col = 0; col < rchunk->ColumnCount(); col++) {
-			for (idx_t row = 0; row < rchunk->size(); row++) {
-				auto lvalue = lchunk->GetValue(col, row);
-				auto rvalue = rchunk->GetValue(col, row);
+		for (; lindex < lchunk->size() && rindex < rchunk->size(); lindex++, rindex++) {
+			for (idx_t col = 0; col < rchunk->ColumnCount(); col++) {
+				auto lvalue = lchunk->GetValue(col, lindex);
+				auto rvalue = rchunk->GetValue(col, rindex);
 				if (lvalue.IsNull() && rvalue.IsNull()) {
 					continue;
 				}

package/src/duckdb/src/main/relation.cpp

@@ -130,7 +130,12 @@ shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const str
                                     JoinRefType ref_type) {
 	auto expression_list = Parser::ParseExpressionList(condition, context.GetContext()->GetParserOptions());
 	D_ASSERT(!expression_list.empty());
+	return Join(other, std::move(expression_list), type, ref_type);
+}
 
+shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other,
+                                    vector<unique_ptr<ParsedExpression>> expression_list, JoinType type,
+                                    JoinRefType ref_type) {
 	if (expression_list.size() > 1 || expression_list[0]->type == ExpressionType::COLUMN_REF) {
 		// multiple columns or single column ref: the condition is a USING list
 		vector<string> using_columns;
@@ -197,6 +202,11 @@ shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const
 	return this->Aggregate(aggregate_list, group_list);
 }
 
+shared_ptr<Relation> Relation::Aggregate(vector<unique_ptr<ParsedExpression>> expressions, const string &group_list) {
+	auto groups = Parser::ParseGroupByList(group_list, context.GetContext()->GetParserOptions());
+	return make_shared<AggregateRelation>(shared_from_this(), std::move(expressions), std::move(groups));
+}
+
 string Relation::GetAlias() {
 	return "relation";
 }

package/src/duckdb/src/optimizer/rule/date_part_simplification.cpp

@@ -70,9 +70,6 @@ unique_ptr<Expression> DatePartSimplificationRule::Apply(LogicalOperator &op, ve
 	case DatePartSpecifier::DOY:
 		new_function_name = "dayofyear";
 		break;
-	case DatePartSpecifier::EPOCH:
-		new_function_name = "epoch";
-		break;
 	case DatePartSpecifier::MICROSECONDS:
 		new_function_name = "microsecond";
 		break;

package/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp

@@ -51,6 +51,7 @@ void LogicalComparisonJoin::ExtractJoinConditions(
     unique_ptr<LogicalOperator> &right_child, const unordered_set<idx_t> &left_bindings,
     const unordered_set<idx_t> &right_bindings, vector<unique_ptr<Expression>> &expressions,
     vector<JoinCondition> &conditions, vector<unique_ptr<Expression>> &arbitrary_expressions) {
+
 	for (auto &expr : expressions) {
 		auto total_side = JoinSide::GetJoinSide(*expr, left_bindings, right_bindings);
 		if (total_side != JoinSide::BOTH) {
@@ -77,10 +78,17 @@ void LogicalComparisonJoin::ExtractJoinConditions(
 					continue;
 				}
 			}
-		} else if ((expr->type >= ExpressionType::COMPARE_EQUAL &&
-		            expr->type <= ExpressionType::COMPARE_GREATERTHANOREQUALTO) ||
-		           expr->type == ExpressionType::COMPARE_DISTINCT_FROM ||
-		           expr->type == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
+		} else if (expr->type == ExpressionType::COMPARE_EQUAL || expr->type == ExpressionType::COMPARE_NOTEQUAL ||
+		           expr->type == ExpressionType::COMPARE_BOUNDARY_START ||
+		           expr->type == ExpressionType::COMPARE_LESSTHAN ||
+		           expr->type == ExpressionType::COMPARE_GREATERTHAN ||
+		           expr->type == ExpressionType::COMPARE_LESSTHANOREQUALTO ||
+		           expr->type == ExpressionType::COMPARE_GREATERTHANOREQUALTO ||
+		           expr->type == ExpressionType::COMPARE_BOUNDARY_START ||
+		           expr->type == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
+		           expr->type == ExpressionType::COMPARE_DISTINCT_FROM)
+
+		{
 			// comparison, check if we can create a comparison JoinCondition
 			if (CreateJoinCondition(*expr, left_bindings, right_bindings, conditions)) {
 				// successfully created the join condition

package/src/duckdb/src/storage/compression/validity_uncompressed.cpp

@@ -449,11 +449,10 @@ void ValidityRevertAppend(ColumnSegment &segment, idx_t start_row) {
 	if (start_bit % 8 != 0) {
 		// handle sub-bit stuff (yay)
 		idx_t byte_pos = start_bit / 8;
-		idx_t bit_start = byte_pos * 8;
 		idx_t bit_end = (byte_pos + 1) * 8;
-		ValidityMask mask(reinterpret_cast<validity_t *>(handle.Ptr() + byte_pos));
+		ValidityMask mask(reinterpret_cast<validity_t *>(handle.Ptr()));
 		for (idx_t i = start_bit; i < bit_end; i++) {
-			mask.SetValid(i - bit_start);
+			mask.SetValid(i);
 		}
 		revert_start = bit_end / 8;
 	} else {

package/src/duckdb/src/storage/data_table.cpp

@@ -832,6 +832,7 @@ void DataTable::RevertAppendInternal(idx_t start_row, idx_t count) {
 void DataTable::RevertAppend(idx_t start_row, idx_t count) {
 	lock_guard<mutex> lock(append_lock);
 
+	// revert any appends to indexes
 	if (!info->indexes.Empty()) {
 		idx_t current_row_base = start_row;
 		row_t row_data[STANDARD_VECTOR_SIZE];
@@ -847,6 +848,15 @@ void DataTable::RevertAppend(idx_t start_row, idx_t count) {
 			current_row_base += chunk.size();
 		});
 	}
+
+	// we need to vacuum the indexes to remove any buffers that are now empty
+	// due to reverting the appends
+	info->indexes.Scan([&](Index &index) {
+		index.Vacuum();
+		return false;
+	});
+
+	// revert the data table append
 	RevertAppendInternal(start_row, count);
 }
 

package/src/duckdb/src/storage/serialization/serialize_nodes.cpp

@@ -101,28 +101,27 @@ void CSVReaderOptions::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(111, "normalize_names", normalize_names);
 	serializer.WriteProperty(112, "force_not_null", force_not_null);
 	serializer.WriteProperty(113, "all_varchar", all_varchar);
-	serializer.WriteProperty(114, "sample_chunk_size", sample_chunk_size);
-	serializer.WriteProperty(115, "sample_chunks", sample_chunks);
-	serializer.WriteProperty(116, "auto_detect", auto_detect);
-	serializer.WriteProperty(117, "file_path", file_path);
-	serializer.WriteProperty(118, "decimal_separator", decimal_separator);
-	serializer.WriteProperty(119, "null_padding", null_padding);
-	serializer.WriteProperty(120, "buffer_size", buffer_size);
-	serializer.WriteProperty(121, "file_options", file_options);
-	serializer.WriteProperty(122, "force_quote", force_quote);
-	serializer.WriteProperty(123, "rejects_table_name", rejects_table_name);
-	serializer.WriteProperty(124, "rejects_limit", rejects_limit);
-	serializer.WriteProperty(125, "rejects_recovery_columns", rejects_recovery_columns);
-	serializer.WriteProperty(126, "rejects_recovery_column_ids", rejects_recovery_column_ids);
-	serializer.WriteProperty(127, "dialect_options.state_machine_options.delimiter", dialect_options.state_machine_options.delimiter);
-	serializer.WriteProperty(128, "dialect_options.state_machine_options.quote", dialect_options.state_machine_options.quote);
-	serializer.WriteProperty(129, "dialect_options.state_machine_options.escape", dialect_options.state_machine_options.escape);
-	serializer.WriteProperty(130, "dialect_options.header", dialect_options.header);
-	serializer.WriteProperty(131, "dialect_options.num_cols", dialect_options.num_cols);
-	serializer.WriteProperty(132, "dialect_options.new_line", dialect_options.new_line);
-	serializer.WriteProperty(133, "dialect_options.skip_rows", dialect_options.skip_rows);
-	serializer.WriteProperty(134, "dialect_options.date_format", dialect_options.date_format);
-	serializer.WriteProperty(135, "dialect_options.has_format", dialect_options.has_format);
+	serializer.WriteProperty(114, "sample_size_chunks", sample_size_chunks);
+	serializer.WriteProperty(115, "auto_detect", auto_detect);
+	serializer.WriteProperty(116, "file_path", file_path);
+	serializer.WriteProperty(117, "decimal_separator", decimal_separator);
+	serializer.WriteProperty(118, "null_padding", null_padding);
+	serializer.WriteProperty(119, "buffer_size", buffer_size);
+	serializer.WriteProperty(120, "file_options", file_options);
+	serializer.WriteProperty(121, "force_quote", force_quote);
+	serializer.WriteProperty(122, "rejects_table_name", rejects_table_name);
+	serializer.WriteProperty(123, "rejects_limit", rejects_limit);
+	serializer.WriteProperty(124, "rejects_recovery_columns", rejects_recovery_columns);
+	serializer.WriteProperty(125, "rejects_recovery_column_ids", rejects_recovery_column_ids);
+	serializer.WriteProperty(126, "dialect_options.state_machine_options.delimiter", dialect_options.state_machine_options.delimiter);
+	serializer.WriteProperty(127, "dialect_options.state_machine_options.quote", dialect_options.state_machine_options.quote);
+	serializer.WriteProperty(128, "dialect_options.state_machine_options.escape", dialect_options.state_machine_options.escape);
+	serializer.WriteProperty(129, "dialect_options.header", dialect_options.header);
+	serializer.WriteProperty(130, "dialect_options.num_cols", dialect_options.num_cols);
+	serializer.WriteProperty(131, "dialect_options.new_line", dialect_options.new_line);
+	serializer.WriteProperty(132, "dialect_options.skip_rows", dialect_options.skip_rows);
+	serializer.WriteProperty(133, "dialect_options.date_format", dialect_options.date_format);
+	serializer.WriteProperty(134, "dialect_options.has_format", dialect_options.has_format);
 }
 
 CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) {
@@ -141,28 +140,27 @@ CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) {
 	deserializer.ReadProperty(111, "normalize_names", result.normalize_names);
 	deserializer.ReadProperty(112, "force_not_null", result.force_not_null);
 	deserializer.ReadProperty(113, "all_varchar", result.all_varchar);
-	deserializer.ReadProperty(114, "sample_chunk_size", result.sample_chunk_size);
-	deserializer.ReadProperty(115, "sample_chunks", result.sample_chunks);
-	deserializer.ReadProperty(116, "auto_detect", result.auto_detect);
-	deserializer.ReadProperty(117, "file_path", result.file_path);
-	deserializer.ReadProperty(118, "decimal_separator", result.decimal_separator);
-	deserializer.ReadProperty(119, "null_padding", result.null_padding);
-	deserializer.ReadProperty(120, "buffer_size", result.buffer_size);
-	deserializer.ReadProperty(121, "file_options", result.file_options);
-	deserializer.ReadProperty(122, "force_quote", result.force_quote);
-	deserializer.ReadProperty(123, "rejects_table_name", result.rejects_table_name);
-	deserializer.ReadProperty(124, "rejects_limit", result.rejects_limit);
-	deserializer.ReadProperty(125, "rejects_recovery_columns", result.rejects_recovery_columns);
-	deserializer.ReadProperty(126, "rejects_recovery_column_ids", result.rejects_recovery_column_ids);
-	deserializer.ReadProperty(127, "dialect_options.state_machine_options.delimiter", result.dialect_options.state_machine_options.delimiter);
-	deserializer.ReadProperty(128, "dialect_options.state_machine_options.quote", result.dialect_options.state_machine_options.quote);
-	deserializer.ReadProperty(129, "dialect_options.state_machine_options.escape", result.dialect_options.state_machine_options.escape);
-	deserializer.ReadProperty(130, "dialect_options.header", result.dialect_options.header);
-	deserializer.ReadProperty(131, "dialect_options.num_cols", result.dialect_options.num_cols);
-	deserializer.ReadProperty(132, "dialect_options.new_line", result.dialect_options.new_line);
-	deserializer.ReadProperty(133, "dialect_options.skip_rows", result.dialect_options.skip_rows);
-	deserializer.ReadProperty(134, "dialect_options.date_format", result.dialect_options.date_format);
-	deserializer.ReadProperty(135, "dialect_options.has_format", result.dialect_options.has_format);
+	deserializer.ReadProperty(114, "sample_size_chunks", result.sample_size_chunks);
+	deserializer.ReadProperty(115, "auto_detect", result.auto_detect);
+	deserializer.ReadProperty(116, "file_path", result.file_path);
+	deserializer.ReadProperty(117, "decimal_separator", result.decimal_separator);
+	deserializer.ReadProperty(118, "null_padding", result.null_padding);
+	deserializer.ReadProperty(119, "buffer_size", result.buffer_size);
+	deserializer.ReadProperty(120, "file_options", result.file_options);
+	deserializer.ReadProperty(121, "force_quote", result.force_quote);
+	deserializer.ReadProperty(122, "rejects_table_name", result.rejects_table_name);
+	deserializer.ReadProperty(123, "rejects_limit", result.rejects_limit);
+	deserializer.ReadProperty(124, "rejects_recovery_columns", result.rejects_recovery_columns);
+	deserializer.ReadProperty(125, "rejects_recovery_column_ids", result.rejects_recovery_column_ids);
+	deserializer.ReadProperty(126, "dialect_options.state_machine_options.delimiter", result.dialect_options.state_machine_options.delimiter);
+	deserializer.ReadProperty(127, "dialect_options.state_machine_options.quote", result.dialect_options.state_machine_options.quote);
+	deserializer.ReadProperty(128, "dialect_options.state_machine_options.escape", result.dialect_options.state_machine_options.escape);
+	deserializer.ReadProperty(129, "dialect_options.header", result.dialect_options.header);
+	deserializer.ReadProperty(130, "dialect_options.num_cols", result.dialect_options.num_cols);
+	deserializer.ReadProperty(131, "dialect_options.new_line", result.dialect_options.new_line);
+	deserializer.ReadProperty(132, "dialect_options.skip_rows", result.dialect_options.skip_rows);
+	deserializer.ReadProperty(133, "dialect_options.date_format", result.dialect_options.date_format);
+	deserializer.ReadProperty(134, "dialect_options.has_format", result.dialect_options.has_format);
 	return result;
 }
 

package/src/duckdb/ub_src_common_row_operations.cpp

@@ -4,7 +4,7 @@
 
 #include "src/common/row_operations/row_gather.cpp"
 
-#include "src/common/row_operations/row_match.cpp"
+#include "src/common/row_operations/row_matcher.cpp"
 
 #include "src/common/row_operations/row_external.cpp"
 

package/src/statement.cpp

@@ -93,11 +93,9 @@ Statement::Statement(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Statemen
 	int length = info.Length();
 
 	if (length <= 0 || !Connection::HasInstance(info[0])) {
-		Napi::TypeError::New(env, "Connection object expected").ThrowAsJavaScriptException();
-		return;
+		throw Napi::TypeError::New(env, "Connection object expected");
 	} else if (length <= 1 || !info[1].IsString()) {
-		Napi::TypeError::New(env, "SQL query expected").ThrowAsJavaScriptException();
-		return;
+		throw Napi::TypeError::New(env, "SQL query expected");
 	}
 
 	connection_ref = Napi::ObjectWrap<Connection>::Unwrap(info[0].As<Napi::Object>());

package/test/database_fail.test.ts

@@ -2,6 +2,7 @@ import * as sqlite3 from '..';
 import * as assert from 'assert';
 import {DuckDbError, RowData} from "..";
 import {Worker} from 'worker_threads';
+import {expect} from 'chai';
 
 describe('error handling', function() {
     var db: sqlite3.Database;
@@ -163,4 +164,9 @@ describe('error handling', function() {
       await run_worker(); // first should always succeed
       await run_worker(); // second fails without thread safety
     })
+
+    it("shouldn't crash on an exception", () => {
+        expect(() => new sqlite3.Database(':memory:', {file_search_path: '/'})).to.throw('Could not set option "file_search_path" as a global option');
+    });
 });
+