duckdb 0.3.3-dev1404.0 → 0.3.3-dev1418.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.3-dev1404.0",
+  "version": "0.3.3-dev1418.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;
 }
@@ -130650,11 +130650,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 +130676,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 +130685,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);
@@ -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;
@@ -161215,6 +161231,7 @@ string ExpressionBinder::Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, b
 
 
 
+
 namespace duckdb {
 
 void ExpressionIterator::EnumerateChildren(const Expression &expr,
@@ -161376,10 +161393,13 @@ void ExpressionIterator::EnumerateTableRefChildren(BoundTableRef &ref,
 		EnumerateQueryNodeChildren(*bound_subquery.subquery, callback);
 		break;
 	}
-	default:
-		D_ASSERT(ref.type == TableReferenceType::TABLE_FUNCTION || ref.type == TableReferenceType::BASE_TABLE ||
-		         ref.type == TableReferenceType::EMPTY);
+	case TableReferenceType::TABLE_FUNCTION:
+	case TableReferenceType::EMPTY:
+	case TableReferenceType::BASE_TABLE:
+	case TableReferenceType::CTE:
 		break;
+	default:
+		throw NotImplementedException("Unimplemented table reference type in ExpressionIterator");
 	}
 }
 
@@ -161392,8 +161412,13 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 		EnumerateQueryNodeChildren(*bound_setop.right, callback);
 		break;
 	}
-	default:
-		D_ASSERT(node.type == QueryNodeType::SELECT_NODE);
+	case QueryNodeType::RECURSIVE_CTE_NODE: {
+		auto &cte_node = (BoundRecursiveCTENode &)node;
+		EnumerateQueryNodeChildren(*cte_node.left, callback);
+		EnumerateQueryNodeChildren(*cte_node.right, callback);
+		break;
+	}
+	case QueryNodeType::SELECT_NODE: {
 		auto &bound_select = (BoundSelectNode &)node;
 		for (idx_t i = 0; i < bound_select.select_list.size(); i++) {
 			EnumerateExpression(bound_select.select_list[i], callback);
@@ -161417,6 +161442,9 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 		}
 		break;
 	}
+	default:
+		throw NotImplementedException("Unimplemented query node in ExpressionIterator");
+	}
 	for (idx_t i = 0; i < node.modifiers.size(); i++) {
 		switch (node.modifiers[i]->type) {
 		case ResultModifierType::DISTINCT_MODIFIER:

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 "514748429"
-#define DUCKDB_VERSION "v0.3.3-dev1404"
+#define DUCKDB_SOURCE_ID "a5b6279ed"
+#define DUCKDB_VERSION "v0.3.3-dev1418"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //