duckdb 0.4.1-dev1110.0 → 0.4.1-dev1131.0

package/package.json

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

package/src/duckdb.cpp

@@ -46020,7 +46020,8 @@ Value Vector::GetValue(const Vector &v_p, idx_t index_p) {
 		case PhysicalType::INT128:
 			return Value::DECIMAL(((hugeint_t *)data)[index], width, scale);
 		default:
-			throw InternalException("Widths bigger than 38 are not supported");
+			throw InternalException("Physical type '%s' has a width bigger than 38, which is not supported",
+			                        TypeIdToString(type.InternalType()));
 		}
 	}
 	case LogicalTypeId::ENUM: {
@@ -47336,6 +47337,28 @@ const sel_t ConstantVector::ZERO_VECTOR[STANDARD_VECTOR_SIZE] = {0};
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/cast_rules.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+//! Contains a list of rules for casting
+class CastRules {
+public:
+	//! Returns the cost of performing an implicit cost from "from" to "to", or -1 if an implicit cast is not possible
+	static int64_t ImplicitCast(const LogicalType &from, const LogicalType &to);
+};
+
+} // namespace duckdb
+
 
 #include <cmath>
 
@@ -47414,7 +47437,8 @@ PhysicalType LogicalType::GetInternalType() {
 		} else if (width <= Decimal::MAX_WIDTH_INT128) {
 			return PhysicalType::INT128;
 		} else {
-			throw InternalException("Widths bigger than %d are not supported", DecimalType::MaxWidth());
+			throw InternalException("Decimal has a width of %d which is bigger than the maximum supported width of %d",
+			                        width, DecimalType::MaxWidth());
 		}
 	}
 	case LogicalTypeId::VARCHAR:
@@ -47952,8 +47976,84 @@ bool LogicalType::GetDecimalProperties(uint8_t &width, uint8_t &scale) const {
 	return true;
 }
 
+//! Grows Decimal width/scale when appropriate
+static LogicalType DecimalSizeCheck(const LogicalType &left, const LogicalType &right) {
+	D_ASSERT(left.id() == LogicalTypeId::DECIMAL || right.id() == LogicalTypeId::DECIMAL);
+	D_ASSERT(left.id() != right.id());
+
+	//! Make sure the 'right' is the DECIMAL type
+	if (left.id() == LogicalTypeId::DECIMAL) {
+		return DecimalSizeCheck(right, left);
+	}
+	auto width = DecimalType::GetWidth(right);
+	auto scale = DecimalType::GetScale(right);
+
+	uint8_t other_width;
+	uint8_t other_scale;
+	bool success = left.GetDecimalProperties(other_width, other_scale);
+	if (!success) {
+		throw InternalException("Type provided to DecimalSizeCheck was not a numeric type");
+	}
+	D_ASSERT(other_scale == 0);
+	const auto effective_width = width - scale;
+	if (other_width > effective_width) {
+		auto new_width = other_width + scale;
+		//! Cap the width at max, if an actual value exceeds this, an exception will be thrown later
+		if (new_width > DecimalType::MaxWidth()) {
+			new_width = DecimalType::MaxWidth();
+		}
+		return LogicalType::DECIMAL(new_width, scale);
+	}
+	return right;
+}
+
+static LogicalType CombineNumericTypes(const LogicalType &left, const LogicalType &right) {
+	D_ASSERT(left.id() != right.id());
+	if (left.id() > right.id()) {
+		// this method is symmetric
+		// arrange it so the left type is smaller to limit the number of options we need to check
+		return CombineNumericTypes(right, left);
+	}
+	if (CastRules::ImplicitCast(left, right) >= 0) {
+		// we can implicitly cast left to right, return right
+		//! Depending on the type, we might need to grow the `width` of the DECIMAL type
+		if (right.id() == LogicalTypeId::DECIMAL) {
+			return DecimalSizeCheck(left, right);
+		}
+		return right;
+	}
+	if (CastRules::ImplicitCast(right, left) >= 0) {
+		// we can implicitly cast right to left, return left
+		//! Depending on the type, we might need to grow the `width` of the DECIMAL type
+		if (left.id() == LogicalTypeId::DECIMAL) {
+			return DecimalSizeCheck(right, left);
+		}
+		return left;
+	}
+	// we can't cast implicitly either way and types are not equal
+	// this happens when left is signed and right is unsigned
+	// e.g. INTEGER and UINTEGER
+	// in this case we need to upcast to make sure the types fit
+
+	if (left.id() == LogicalTypeId::BIGINT || right.id() == LogicalTypeId::UBIGINT) {
+		return LogicalType::HUGEINT;
+	}
+	if (left.id() == LogicalTypeId::INTEGER || right.id() == LogicalTypeId::UINTEGER) {
+		return LogicalType::BIGINT;
+	}
+	if (left.id() == LogicalTypeId::SMALLINT || right.id() == LogicalTypeId::USMALLINT) {
+		return LogicalType::INTEGER;
+	}
+	if (left.id() == LogicalTypeId::TINYINT || right.id() == LogicalTypeId::UTINYINT) {
+		return LogicalType::SMALLINT;
+	}
+	throw InternalException("Cannot combine these numeric types!?");
+}
+
 LogicalType LogicalType::MaxLogicalType(const LogicalType &left, const LogicalType &right) {
-	if (left.id() == LogicalTypeId::UNKNOWN) {
+	if (left.id() != right.id() && left.IsNumeric() && right.IsNumeric()) {
+		return CombineNumericTypes(left, right);
+	} else if (left.id() == LogicalTypeId::UNKNOWN) {
 		return right;
 	} else if (right.id() == LogicalTypeId::UNKNOWN) {
 		return left;
@@ -48150,6 +48250,7 @@ TypeCatalogEntry *LogicalType::GetCatalog(const LogicalType &type) {
 struct DecimalTypeInfo : public ExtraTypeInfo {
 	DecimalTypeInfo(uint8_t width_p, uint8_t scale_p)
 	    : ExtraTypeInfo(ExtraTypeInfoType::DECIMAL_TYPE_INFO), width(width_p), scale(scale_p) {
+		D_ASSERT(width_p >= scale_p);
 	}
 
 	uint8_t width;
@@ -48193,6 +48294,7 @@ uint8_t DecimalType::MaxWidth() {
 }
 
 LogicalType LogicalType::DECIMAL(int width, int scale) {
+	D_ASSERT(width >= scale);
 	auto type_info = make_shared<DecimalTypeInfo>(width, scale);
 	return LogicalType(LogicalTypeId::DECIMAL, move(type_info));
 }
@@ -88621,27 +88723,6 @@ unique_ptr<FunctionData> AggregateFunction::BindSortedAggregate(AggregateFunctio
 	return move(sorted_bind);
 }
 
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/cast_rules.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-//! Contains a list of rules for casting
-class CastRules {
-public:
-	//! Returns the cost of performing an implicit cost from "from" to "to", or -1 if an implicit cast is not possible
-	static int64_t ImplicitCast(const LogicalType &from, const LogicalType &to);
-};
-
 } // namespace duckdb
 
 
@@ -140137,7 +140218,7 @@ unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op,
 		    !BoundCastExpression::CastIsInvertible(cast_expression->return_type, target_type)) {
 			return nullptr;
 		}
-		auto new_constant = constant_value.TryCastAs(target_type);
+		auto new_constant = constant_value.TryCastAs(target_type, true);
 		if (new_constant) {
 			auto child_expression = move(cast_expression->child);
 			auto new_constant_expr = make_unique<BoundConstantExpression>(constant_value);
@@ -143785,6 +143866,62 @@ void Event::SetTasks(vector<unique_ptr<Task>> tasks) {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parallel/pipeline_complete_event.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+class Executor;
+
+class PipelineCompleteEvent : public Event {
+public:
+	PipelineCompleteEvent(Executor &executor, bool complete_pipeline_p);
+
+	bool complete_pipeline;
+
+public:
+	void Schedule() override;
+	void FinalizeFinish() override;
+};
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parallel/pipeline_event.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+class PipelineEvent : public Event {
+public:
+	PipelineEvent(shared_ptr<Pipeline> pipeline);
+
+	//! The pipeline that this event belongs to
+	shared_ptr<Pipeline> pipeline;
+
+public:
+	void Schedule() override;
+	void FinishEvent() override;
+};
+
+} // namespace duckdb
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -143894,36 +144031,6 @@ private:
 
 } // namespace duckdb
 
-
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-class PipelineEvent : public Event {
-public:
-	PipelineEvent(shared_ptr<Pipeline> pipeline);
-
-	//! The pipeline that this event belongs to
-	shared_ptr<Pipeline> pipeline;
-
-public:
-	void Schedule() override;
-	void FinishEvent() override;
-};
-
-} // namespace duckdb
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -143954,34 +144061,6 @@ public:
 
 } // namespace duckdb
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/parallel/pipeline_complete_event.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-class Executor;
-
-class PipelineCompleteEvent : public Event {
-public:
-	PipelineCompleteEvent(Executor &executor, bool complete_pipeline_p);
-
-	bool complete_pipeline;
-
-public:
-	void Schedule() override;
-	void FinalizeFinish() override;
-};
-
-} // namespace duckdb
-
 
 
 
@@ -144179,8 +144258,8 @@ void Executor::ExtractPipelines(shared_ptr<Pipeline> &pipeline, vector<shared_pt
 	}
 	auto child_entry = child_pipelines.find(pipeline_ptr);
 	if (child_entry != child_pipelines.end()) {
-		for (auto &entry : child_entry->second) {
-			ExtractPipelines(entry, result);
+		for (auto entry = child_entry->second.rbegin(); entry != child_entry->second.rend(); ++entry) {
+			ExtractPipelines(*entry, result);
 		}
 		child_pipelines.erase(pipeline_ptr);
 	}

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 "5f0db8f65"
-#define DUCKDB_VERSION "v0.4.1-dev1110"
+#define DUCKDB_SOURCE_ID "67f1ed1a2"
+#define DUCKDB_VERSION "v0.4.1-dev1131"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //