duckdb 0.6.2-dev2350.0 → 0.6.2-dev2405.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.2-dev2350.0",
+  "version": "0.6.2-dev2405.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

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

@@ -125,21 +125,13 @@ ColumnDataRowCollection::ColumnDataRowCollection(const ColumnDataCollection &col
 	}
 	// read all the chunks
 	ColumnDataScanState temp_scan_state;
-	collection.InitializeScan(temp_scan_state);
+	collection.InitializeScan(temp_scan_state, ColumnDataScanProperties::DISALLOW_ZERO_COPY);
 	while (true) {
 		auto chunk = make_unique<DataChunk>();
 		collection.InitializeScanChunk(*chunk);
 		if (!collection.Scan(temp_scan_state, *chunk)) {
 			break;
 		}
-		// we keep the BufferHandles that are needed for the materialized collection pinned in the supplied scan_state
-		auto &temp_handles = temp_scan_state.current_chunk_state.handles;
-		auto &scan_handles = scan_state.current_chunk_state.handles;
-		for (auto &temp_handle_pair : temp_handles) {
-			auto handle_copy =
-			    make_pair<uint32_t, BufferHandle>(scan_handles.size(), std::move(temp_handle_pair.second));
-			scan_state.current_chunk_state.handles.insert(std::move(handle_copy));
-		}
 		chunks.push_back(std::move(chunk));
 	}
 	// now create all of the column data rows

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

@@ -1584,6 +1584,10 @@ bool Value::DefaultTryCastAs(const LogicalType &target_type, bool strict) {
 	return TryCastAs(set, get_input, target_type, strict);
 }
 
+void Value::Reinterpret(LogicalType new_type) {
+	this->type_ = std::move(new_type);
+}
+
 void Value::Serialize(Serializer &main_serializer) const {
 	FieldWriter writer(main_serializer);
 	writer.WriteSerializable(type_);

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

@@ -588,7 +588,7 @@ Value Vector::GetValue(const Vector &v_p, idx_t index_p) {
 	auto value = GetValueInternal(v_p, index_p);
 	// set the alias of the type to the correct value, if there is a type alias
 	if (v_p.GetType().HasAlias()) {
-		value.type().CopyAuxInfo(v_p.GetType());
+		value.GetTypeMutable().CopyAuxInfo(v_p.GetType());
 	}
 	if (v_p.GetType().id() != LogicalTypeId::AGGREGATE_STATE && value.type().id() != LogicalTypeId::AGGREGATE_STATE) {
 

package/src/duckdb/src/execution/window_segment_tree.cpp

@@ -98,7 +98,7 @@ void WindowSegmentTree::ExtractFrame(idx_t begin, idx_t end) {
 
 void WindowSegmentTree::WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end) {
 	D_ASSERT(begin <= end);
-	if (begin == end) {
+	if (begin == end || inputs.ColumnCount() == 0) {
 		return;
 	}
 
@@ -107,6 +107,7 @@ void WindowSegmentTree::WindowSegmentValue(idx_t l_idx, idx_t begin, idx_t end)
 	if (l_idx == 0) {
 		ExtractFrame(begin, end);
 		AggregateInputData aggr_input_data(bind_info, Allocator::DefaultAllocator());
+		D_ASSERT(inputs.data.size() > 0);
 		aggregate.update(&inputs.data[0], aggr_input_data, input_ref->ColumnCount(), s, inputs.size());
 	} else {
 		// find out where the states begin

package/src/duckdb/src/function/aggregate/holistic/quantile.cpp

@@ -1216,6 +1216,9 @@ static const Value &CheckQuantile(const Value &quantile_val) {
 	if (quantile < -1 || quantile > 1) {
 		throw BinderException("QUANTILE can only take parameters in the range [-1, 1]");
 	}
+	if (Value::IsNan(quantile)) {
+		throw BinderException("QUANTILE parameter cannot be NaN");
+	}
 
 	return quantile_val;
 }

package/src/duckdb/src/function/scalar/date/strftime.cpp

@@ -259,7 +259,7 @@ char *StrfTimeFormat::WriteDateSpecifier(StrTimeSpecifier specifier, date_t date
 }
 
 char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], const char *tz_name,
-                                             char *target) {
+                                             size_t tz_len, char *target) {
 	// data contains [0] year, [1] month, [2] day, [3] hour, [4] minute, [5] second, [6] msec, [7] utc
 	switch (specifier) {
 	case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
@@ -338,7 +338,7 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 	}
 	case StrTimeSpecifier::TZ_NAME:
 		if (tz_name) {
-			strcpy(target, tz_name);
+			memcpy(target, tz_name, tz_len);
 			target += strlen(tz_name);
 		}
 		break;
@@ -391,7 +391,8 @@ void StrfTimeFormat::FormatString(date_t date, int32_t data[8], const char *tz_n
 		if (is_date_specifier[i]) {
 			target = WriteDateSpecifier(specifiers[i], date, target);
 		} else {
-			target = WriteStandardSpecifier(specifiers[i], data, tz_name, target);
+			auto tz_len = tz_name ? strlen(tz_name) : 0;
+			target = WriteStandardSpecifier(specifiers[i], data, tz_name, tz_len, target);
 		}
 	}
 	// copy the final literal into the target

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev2350"
+#define DUCKDB_VERSION "0.6.2-dev2405"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "6bfbe238d4"
+#define DUCKDB_SOURCE_ID "2eb46acc6e"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/types/value.hpp

@@ -63,7 +63,7 @@ public:
 	// move assignment
 	DUCKDB_API Value &operator=(Value &&other) noexcept;
 
-	inline LogicalType &type() {
+	inline LogicalType &GetTypeMutable() {
 		return type_;
 	}
 	inline const LogicalType &type() const {
@@ -221,6 +221,8 @@ public:
 	DUCKDB_API bool TryCastAs(ClientContext &context, const LogicalType &target_type, bool strict = false);
 	DUCKDB_API bool DefaultTryCastAs(const LogicalType &target_type, bool strict = false);
 
+	DUCKDB_API void Reinterpret(LogicalType new_type);
+
 	//! Serializes a Value to a stand-alone binary blob
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 	//! Deserializes a Value from a blob

package/src/duckdb/src/include/duckdb/function/scalar/strftime.hpp

@@ -112,7 +112,8 @@ protected:
 	char *WritePadded(char *target, uint32_t value, size_t padding);
 	bool IsDateSpecifier(StrTimeSpecifier specifier);
 	char *WriteDateSpecifier(StrTimeSpecifier specifier, date_t date, char *target);
-	char *WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], const char *tz_name, char *target);
+	char *WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], const char *tz_name, size_t tz_len,
+	                             char *target);
 };
 
 struct StrpTimeFormat : public StrTimeFormat {

package/src/duckdb/src/include/duckdb/planner/bind_context.hpp

@@ -83,7 +83,7 @@ public:
 
 	//! Adds a base table with the given alias to the BindContext.
 	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
-	                  vector<column_t> &bound_column_ids, StandardEntry *entry);
+	                  vector<column_t> &bound_column_ids, StandardEntry *entry, bool add_row_id = true);
 	//! Adds a call to a table function with the given alias to the BindContext.
 	void AddTableFunction(idx_t index, const string &alias, const vector<string> &names,
 	                      const vector<LogicalType> &types, vector<column_t> &bound_column_ids, StandardEntry *entry);

package/src/duckdb/src/include/duckdb/planner/expression_binder/returning_binder.hpp

@@ -20,10 +20,6 @@ public:
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
-
-	// check certain column ref Names to make sure they are supported in the returning statement
-	// (i.e rowid)
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth);
 };
 
 } // namespace duckdb

package/src/duckdb/src/main/extension/extension_load.cpp

@@ -170,6 +170,12 @@ string ExtensionHelper::ExtractExtensionPrefixFromPath(const string &path) {
 		return "";
 	}
 	auto extension = path.substr(0, first_colon);
+
+	if (path.substr(first_colon, 3) == "://") {
+		// these are not extensions
+		return "";
+	}
+
 	D_ASSERT(extension.size() > 1);
 	// needs to be alphanumeric
 	for (auto &ch : extension) {
@@ -177,10 +183,6 @@ string ExtensionHelper::ExtractExtensionPrefixFromPath(const string &path) {
 			return "";
 		}
 	}
-	if (extension == "http" || extension == "https" || extension == "s3") {
-		// these are not extensions
-		return "";
-	}
 	return extension;
 }
 

package/src/duckdb/src/optimizer/filter_combiner.cpp

@@ -582,7 +582,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 	    comparison.type != ExpressionType::COMPARE_GREATERTHAN &&
 	    comparison.type != ExpressionType::COMPARE_GREATERTHANOREQUALTO &&
 	    comparison.type != ExpressionType::COMPARE_EQUAL && comparison.type != ExpressionType::COMPARE_NOTEQUAL) {
-		// only support [>, >=, <, <=, ==] expressions
+		// only support [>, >=, <, <=, ==, !=] expressions
 		return FilterResult::UNSUPPORTED;
 	}
 	// check if one of the sides is a scalar value
@@ -610,6 +610,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 		// get the current bucket of constant values
 		D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
 		auto &info_list = constant_values.find(equivalence_set)->second;
+		D_ASSERT(node->return_type == info.constant.type());
 		// check the existing constant comparisons to see if we can do any pruning
 		auto ret = AddConstantComparison(info_list, info);
 
@@ -795,7 +796,8 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 			for (auto &stored_exp : stored_expressions) {
 				if (stored_exp.first->type == ExpressionType::BOUND_COLUMN_REF) {
 					auto &st_col_ref = (BoundColumnRefExpression &)*stored_exp.second;
-					if (st_col_ref.binding == col_ref.binding) {
+					if (st_col_ref.binding == col_ref.binding &&
+					    bound_cast_expr.return_type == stored_exp.second->return_type) {
 						bound_cast_expr.child = stored_exp.second->Copy();
 						right_node = GetNode(bound_cast_expr.child.get());
 						break;

package/src/duckdb/src/planner/bind_context.cpp

@@ -454,8 +454,8 @@ void BindContext::AddBinding(const string &alias, unique_ptr<Binding> binding) {
 
 void BindContext::AddBaseTable(idx_t index, const string &alias, const vector<string> &names,
                                const vector<LogicalType> &types, vector<column_t> &bound_column_ids,
-                               StandardEntry *entry) {
-	AddBinding(alias, make_unique<TableBinding>(alias, types, names, bound_column_ids, entry, index, true));
+                               StandardEntry *entry, bool add_row_id) {
+	AddBinding(alias, make_unique<TableBinding>(alias, types, names, bound_column_ids, entry, index, add_row_id));
 }
 
 void BindContext::AddTableFunction(idx_t index, const string &alias, const vector<string> &names,

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

@@ -449,7 +449,7 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 		column_count++;
 	}
 
-	binder->bind_context.AddBaseTable(update_table_index, table->name, names, types, bound_columns, table);
+	binder->bind_context.AddBaseTable(update_table_index, table->name, names, types, bound_columns, table, false);
 	ReturningBinder returning_binder(*binder, context);
 
 	vector<unique_ptr<Expression>> projection_expressions;

package/src/duckdb/src/planner/expression_binder/returning_binder.cpp

@@ -7,14 +7,6 @@ namespace duckdb {
 ReturningBinder::ReturningBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
 }
 
-BindResult ReturningBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth) {
-	auto &expr = **expr_ptr;
-	if (expr.GetName() == "rowid") {
-		return BindResult("rowid is not supported in returning statements");
-	}
-	return ExpressionBinder::BindExpression(expr_ptr, depth);
-}
-
 BindResult ReturningBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = **expr_ptr;
 	switch (expr.GetExpressionClass()) {
@@ -23,7 +15,7 @@ BindResult ReturningBinder::BindExpression(unique_ptr<ParsedExpression> *expr_pt
 	case ExpressionClass::BOUND_SUBQUERY:
 		return BindResult("BOUND SUBQUERY is not supported in returning statements");
 	case ExpressionClass::COLUMN_REF:
-		return BindColumnRef(expr_ptr, depth);
+		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}

package/src/duckdb/src/storage/statistics/numeric_statistics.cpp

@@ -124,15 +124,113 @@ bool NumericStatistics::IsConstant() const {
 	return max <= min;
 }
 
+void SerializeNumericStatsValue(const Value &val, FieldWriter &writer) {
+	writer.WriteField<bool>(val.IsNull());
+	if (val.IsNull()) {
+		return;
+	}
+	switch (val.type().InternalType()) {
+	case PhysicalType::BOOL:
+		writer.WriteField<bool>(BooleanValue::Get(val));
+		break;
+	case PhysicalType::INT8:
+		writer.WriteField<int8_t>(TinyIntValue::Get(val));
+		break;
+	case PhysicalType::INT16:
+		writer.WriteField<int16_t>(SmallIntValue::Get(val));
+		break;
+	case PhysicalType::INT32:
+		writer.WriteField<int32_t>(IntegerValue::Get(val));
+		break;
+	case PhysicalType::INT64:
+		writer.WriteField<int64_t>(BigIntValue::Get(val));
+		break;
+	case PhysicalType::UINT8:
+		writer.WriteField<int8_t>(UTinyIntValue::Get(val));
+		break;
+	case PhysicalType::UINT16:
+		writer.WriteField<int16_t>(USmallIntValue::Get(val));
+		break;
+	case PhysicalType::UINT32:
+		writer.WriteField<int32_t>(UIntegerValue::Get(val));
+		break;
+	case PhysicalType::UINT64:
+		writer.WriteField<int64_t>(UBigIntValue::Get(val));
+		break;
+	case PhysicalType::INT128:
+		writer.WriteField<hugeint_t>(HugeIntValue::Get(val));
+		break;
+	case PhysicalType::FLOAT:
+		writer.WriteField<float>(FloatValue::Get(val));
+		break;
+	case PhysicalType::DOUBLE:
+		writer.WriteField<double>(DoubleValue::Get(val));
+		break;
+	default:
+		throw InternalException("Unsupported type for serializing numeric statistics");
+	}
+}
+
 void NumericStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(min);
-	writer.WriteSerializable(max);
+	SerializeNumericStatsValue(min, writer);
+	SerializeNumericStatsValue(max, writer);
+}
+
+Value DeserializeNumericStatsValue(const LogicalType &type, FieldReader &reader) {
+	auto is_null = reader.ReadRequired<bool>();
+	if (is_null) {
+		return Value(type);
+	}
+	Value result;
+	switch (type.InternalType()) {
+	case PhysicalType::BOOL:
+		result = Value::BOOLEAN(reader.ReadRequired<bool>());
+		break;
+	case PhysicalType::INT8:
+		result = Value::TINYINT(reader.ReadRequired<int8_t>());
+		break;
+	case PhysicalType::INT16:
+		result = Value::SMALLINT(reader.ReadRequired<int16_t>());
+		break;
+	case PhysicalType::INT32:
+		result = Value::INTEGER(reader.ReadRequired<int32_t>());
+		break;
+	case PhysicalType::INT64:
+		result = Value::BIGINT(reader.ReadRequired<int64_t>());
+		break;
+	case PhysicalType::UINT8:
+		result = Value::UTINYINT(reader.ReadRequired<uint8_t>());
+		break;
+	case PhysicalType::UINT16:
+		result = Value::USMALLINT(reader.ReadRequired<uint16_t>());
+		break;
+	case PhysicalType::UINT32:
+		result = Value::UINTEGER(reader.ReadRequired<uint32_t>());
+		break;
+	case PhysicalType::UINT64:
+		result = Value::UBIGINT(reader.ReadRequired<uint64_t>());
+		break;
+	case PhysicalType::INT128:
+		result = Value::HUGEINT(reader.ReadRequired<hugeint_t>());
+		break;
+	case PhysicalType::FLOAT:
+		result = Value::FLOAT(reader.ReadRequired<float>());
+		break;
+	case PhysicalType::DOUBLE:
+		result = Value::DOUBLE(reader.ReadRequired<double>());
+		break;
+	default:
+		throw InternalException("Unsupported type for deserializing numeric statistics");
+	}
+	result.Reinterpret(type);
+	return result;
 }
 
 unique_ptr<BaseStatistics> NumericStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	auto min = reader.ReadRequiredSerializable<Value, Value>();
-	auto max = reader.ReadRequiredSerializable<Value, Value>();
-	return make_unique_base<BaseStatistics, NumericStatistics>(std::move(type), min, max, StatisticsType::LOCAL_STATS);
+	auto min = DeserializeNumericStatsValue(type, reader);
+	auto max = DeserializeNumericStatsValue(type, reader);
+	return make_unique_base<BaseStatistics, NumericStatistics>(std::move(type), std::move(min), std::move(max),
+	                                                           StatisticsType::LOCAL_STATS);
 }
 
 string NumericStatistics::ToString() const {

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 42;
+const uint64_t VERSION_NUMBER = 43;
 
 struct StorageVersionInfo {
 	const char *version_name;