duckdb 0.3.3-dev1409.0 → 0.3.3-dev1422.0

package/package.json

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

package/src/duckdb.cpp

@@ -57094,7 +57094,7 @@ string PhysicalComparisonJoin::ParamsToString() const {
 	string extra_info = JoinTypeToString(join_type) + "\n";
 	for (auto &it : conditions) {
 		string op = ExpressionTypeToOperator(it.comparison);
-		extra_info += it.left->GetName() + op + it.right->GetName() + "\n";
+		extra_info += it.left->GetName() + " " + op + " " + it.right->GetName() + "\n";
 	}
 	return extra_info;
 }
@@ -91252,14 +91252,11 @@ struct NextSequenceValueOperator {
 		bool overflow = !TryAddOperator::Operation(seq->counter, seq->increment, seq->counter);
 		if (seq->cycle) {
 			if (overflow) {
-				throw SequenceException("overflow in sequence");
-			}
-			if (result < seq->min_value) {
-				result = seq->max_value;
-				seq->counter = seq->max_value + seq->increment;
-			} else if (result > seq->max_value) {
-				result = seq->min_value;
-				seq->counter = seq->min_value + seq->increment;
+				seq->counter = seq->increment < 0 ? seq->max_value : seq->min_value;
+			} else if (seq->counter < seq->min_value) {
+				seq->counter = seq->max_value;
+			} else if (seq->counter > seq->max_value) {
+				seq->counter = seq->min_value;
 			}
 		} else {
 			if (result < seq->min_value || (overflow && seq->increment < 0)) {
@@ -130650,11 +130647,17 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalJoin
 	}
 
 	auto join_type = join.join_type;
+	// depending on the join type, we might need to alter the statistics
+	// LEFT, FULL, RIGHT OUTER and SINGLE joins can introduce null values
+	// this requires us to alter the statistics after this point in the query plan
+	bool adds_null_on_left = IsRightOuterJoin(join_type);
+	bool adds_null_on_right = IsLeftOuterJoin(join_type) || join_type == JoinType::SINGLE;
+
 	vector<ColumnBinding> left_bindings, right_bindings;
-	if (IsRightOuterJoin(join_type)) {
+	if (adds_null_on_left) {
 		left_bindings = join.children[0]->GetColumnBindings();
 	}
-	if (IsLeftOuterJoin(join_type)) {
+	if (adds_null_on_right) {
 		right_bindings = join.children[1]->GetColumnBindings();
 	}
 
@@ -130670,10 +130673,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalJoin
 		break;
 	}
 
-	// now depending on the join type, we might need to alter the statistics
-	// LEFT, FULL and RIGHT OUTER joins can introduce null values
-	// this requires us to alter the statistics after this point in the query plan
-	if (IsLeftOuterJoin(join_type)) {
+	if (adds_null_on_right) {
 		// left or full outer join: set IsNull() to true for all rhs statistics
 		for (auto &binding : right_bindings) {
 			auto stats = statistics_map.find(binding);
@@ -130682,7 +130682,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalJoin
 			}
 		}
 	}
-	if (IsRightOuterJoin(join_type)) {
+	if (adds_null_on_left) {
 		// right or full outer join: set IsNull() to true for all lhs statistics
 		for (auto &binding : left_bindings) {
 			auto stats = statistics_map.find(binding);
@@ -132114,6 +132114,9 @@ bool Pipeline::GetProgressInternal(ClientContext &context, PhysicalOperator *op,
 			if (!GetProgressInternal(context, op_child.get(), child_percentage)) {
 				return false;
 			}
+			if (!Value::DoubleIsFinite(child_percentage)) {
+				return false;
+			}
 			progress.push_back(child_percentage);
 			cardinality.push_back(op_child->estimated_cardinality);
 			total_cardinality += op_child->estimated_cardinality;
@@ -152654,7 +152657,7 @@ unique_ptr<ParsedExpression> ExpressionBinder::CreateStructExtract(unique_ptr<Pa
 	vector<unique_ptr<ParsedExpression>> children;
 	children.push_back(move(base));
 	children.push_back(make_unique_base<ParsedExpression, ConstantExpression>(Value(move(field_name))));
-	auto extract_fun = make_unique<FunctionExpression>("struct_extract", move(children));
+	auto extract_fun = make_unique<OperatorExpression>(ExpressionType::STRUCT_EXTRACT, move(children));
 	return move(extract_fun);
 }
 
@@ -153010,12 +153013,13 @@ BindResult ExpressionBinder::BindFunction(FunctionExpression &function, ScalarFu
 	vector<unique_ptr<Expression>> children;
 	for (idx_t i = 0; i < function.children.size(); i++) {
 		auto &child = (BoundExpression &)*function.children[i];
+		D_ASSERT(child.expr);
 		children.push_back(move(child.expr));
 	}
 	unique_ptr<Expression> result =
 	    ScalarFunction::BindScalarFunction(context, *func, move(children), error, function.is_operator);
 	if (!result) {
-		return BindResult(binder.FormatError(function, error));
+		throw BinderException(binder.FormatError(function, error));
 	}
 	return BindResult(move(result));
 }
@@ -153252,9 +153256,21 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 	case ExpressionType::ARRAY_SLICE:
 		function_name = "array_slice";
 		break;
-	case ExpressionType::STRUCT_EXTRACT:
+	case ExpressionType::STRUCT_EXTRACT: {
+		D_ASSERT(op.children.size() == 2);
+		D_ASSERT(op.children[0]->expression_class == ExpressionClass::BOUND_EXPRESSION);
+		D_ASSERT(op.children[1]->expression_class == ExpressionClass::BOUND_EXPRESSION);
+		auto &extract_exp = (BoundExpression &)*op.children[0];
+		auto &name_exp = (BoundExpression &)*op.children[1];
+		if (extract_exp.expr->return_type.id() != LogicalTypeId::STRUCT &&
+		    extract_exp.expr->return_type.id() != LogicalTypeId::SQLNULL) {
+			return BindResult(
+			    StringUtil::Format("Cannot extract field %s from expression \"%s\" because it is not a struct",
+			                       name_exp.ToString(), extract_exp.ToString()));
+		}
 		function_name = "struct_extract";
 		break;
+	}
 	case ExpressionType::ARRAY_CONSTRUCTOR:
 		function_name = "list_value";
 		break;

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 "6ac91ddc1"
-#define DUCKDB_VERSION "v0.3.3-dev1409"
+#define DUCKDB_SOURCE_ID "f3371d736"
+#define DUCKDB_VERSION "v0.3.3-dev1422"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //