duckdb 0.4.1-dev188.0 → 0.4.1-dev204.0

package/package.json

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

package/src/duckdb.cpp

@@ -1533,7 +1533,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&...args) {
+	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, read the default value
 			return default_value;
@@ -1555,7 +1555,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadRequiredSerializable(ARGS &&...args) {
+	RETURN_TYPE ReadRequiredSerializable(ARGS &&... args) {
 		if (field_count >= max_field_count) {
 			// field is not there, read the default value
 			throw SerializationException("Attempting to read mandatory field, but field is missing");
@@ -128701,6 +128701,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 class DeleteStatement : public SQLStatement {
@@ -128711,6 +128712,8 @@ public:
 	unique_ptr<TableRef> table;
 	vector<unique_ptr<TableRef>> using_clauses;
 	vector<unique_ptr<ParsedExpression>> returning_list;
+	//! CTEs
+	CommonTableExpressionMap cte_map;
 
 protected:
 	DeleteStatement(const DeleteStatement &other);
@@ -129096,6 +129099,7 @@ public:
 
 
 
+
 namespace duckdb {
 class ExpressionListRef;
 
@@ -129116,6 +129120,9 @@ public:
 	//! keep track of optional returningList if statement contains a RETURNING keyword
 	vector<unique_ptr<ParsedExpression>> returning_list;
 
+	//! CTEs
+	CommonTableExpressionMap cte_map;
+
 protected:
 	InsertStatement(const InsertStatement &other);
 
@@ -130022,6 +130029,7 @@ void TableRelation::Delete(const string &condition) {
 
 
 
+
 namespace duckdb {
 
 class UpdateStatement : public SQLStatement {
@@ -130035,6 +130043,8 @@ public:
 	vector<unique_ptr<ParsedExpression>> expressions;
 	//! keep track of optional returningList if statement contains a RETURNING keyword
 	vector<unique_ptr<ParsedExpression>> returning_list;
+	//! CTEs
+	CommonTableExpressionMap cte_map;
 
 protected:
 	UpdateStatement(const UpdateStatement &other);
@@ -149986,7 +149996,7 @@ void ParsedExpressionIterator::EnumerateQueryNodeChildren(
 		EnumerateQueryNodeModifiers(node, callback);
 	}
 
-	for (auto &kv : node.cte_map) {
+	for (auto &kv : node.cte_map.map) {
 		EnumerateQueryNodeChildren(*kv.second->query->node, callback);
 	}
 }
@@ -150015,6 +150025,7 @@ void ParsedExpressionIterator::EnumerateQueryNodeChildren(
 
 
 
+
 // LICENSE_CHANGE_BEGIN
 // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #11
 // See the end of this file for a list
@@ -155191,7 +155202,7 @@ private:
 	//===--------------------------------------------------------------------===//
 	OnCreateConflict TransformOnConflict(duckdb_libpgquery::PGOnCreateConflict conflict);
 	string TransformAlias(duckdb_libpgquery::PGAlias *root, vector<string> &column_name_alias);
-	void TransformCTE(duckdb_libpgquery::PGWithClause *de_with_clause, QueryNode &select);
+	void TransformCTE(duckdb_libpgquery::PGWithClause *de_with_clause, CommonTableExpressionMap &cte_map);
 	unique_ptr<SelectStatement> TransformRecursiveCTE(duckdb_libpgquery::PGCommonTableExpr *node,
 	                                                  CommonTableExpressionInfo &info);
 
@@ -155862,7 +155873,7 @@ SelectNode::SelectNode()
 
 string SelectNode::ToString() const {
 	string result;
-	result = CTEToString();
+	result = cte_map.ToString();
 	result += "SELECT ";
 
 	// search for a distinct modifier
@@ -156075,7 +156086,7 @@ namespace duckdb {
 
 string SetOperationNode::ToString() const {
 	string result;
-	result = CTEToString();
+	result = cte_map.ToString();
 	result += "(" + left->ToString() + ") ";
 	bool is_distinct = false;
 	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
@@ -156158,13 +156169,29 @@ unique_ptr<QueryNode> SetOperationNode::Deserialize(FieldReader &reader) {
 
 namespace duckdb {
 
-string QueryNode::CTEToString() const {
-	if (cte_map.empty()) {
+CommonTableExpressionMap::CommonTableExpressionMap() {
+}
+
+CommonTableExpressionMap CommonTableExpressionMap::Copy() const {
+	CommonTableExpressionMap res;
+	for (auto &kv : this->map) {
+		auto kv_info = make_unique<CommonTableExpressionInfo>();
+		for (auto &al : kv.second->aliases) {
+			kv_info->aliases.push_back(al);
+		}
+		kv_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(kv.second->query->Copy());
+		res.map[kv.first] = move(kv_info);
+	}
+	return res;
+}
+
+string CommonTableExpressionMap::ToString() const {
+	if (map.empty()) {
 		return string();
 	}
 	// check if there are any recursive CTEs
 	bool has_recursive = false;
-	for (auto &kv : cte_map) {
+	for (auto &kv : map) {
 		if (kv.second->query->node->type == QueryNodeType::RECURSIVE_CTE_NODE) {
 			has_recursive = true;
 			break;
@@ -156175,7 +156202,7 @@ string QueryNode::CTEToString() const {
 		result += "RECURSIVE ";
 	}
 	bool first_cte = true;
-	for (auto &kv : cte_map) {
+	for (auto &kv : map) {
 		if (!first_cte) {
 			result += ", ";
 		}
@@ -156252,12 +156279,12 @@ bool QueryNode::Equals(const QueryNode *other) const {
 		}
 	}
 	// WITH clauses (CTEs)
-	if (cte_map.size() != other->cte_map.size()) {
+	if (cte_map.map.size() != other->cte_map.map.size()) {
 		return false;
 	}
-	for (auto &entry : cte_map) {
-		auto other_entry = other->cte_map.find(entry.first);
-		if (other_entry == other->cte_map.end()) {
+	for (auto &entry : cte_map.map) {
+		auto other_entry = other->cte_map.map.find(entry.first);
+		if (other_entry == other->cte_map.map.end()) {
 			return false;
 		}
 		if (entry.second->aliases != other_entry->second->aliases) {
@@ -156274,13 +156301,13 @@ void QueryNode::CopyProperties(QueryNode &other) const {
 	for (auto &modifier : modifiers) {
 		other.modifiers.push_back(modifier->Copy());
 	}
-	for (auto &kv : cte_map) {
+	for (auto &kv : cte_map.map) {
 		auto kv_info = make_unique<CommonTableExpressionInfo>();
 		for (auto &al : kv.second->aliases) {
 			kv_info->aliases.push_back(al);
 		}
 		kv_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(kv.second->query->Copy());
-		other.cte_map[kv.first] = move(kv_info);
+		other.cte_map.map[kv.first] = move(kv_info);
 	}
 }
 
@@ -156289,9 +156316,9 @@ void QueryNode::Serialize(Serializer &main_serializer) const {
 	writer.WriteField<QueryNodeType>(type);
 	writer.WriteSerializableList(modifiers);
 	// cte_map
-	writer.WriteField<uint32_t>((uint32_t)cte_map.size());
+	writer.WriteField<uint32_t>((uint32_t)cte_map.map.size());
 	auto &serializer = writer.GetSerializer();
-	for (auto &cte : cte_map) {
+	for (auto &cte : cte_map.map) {
 		serializer.WriteString(cte.first);
 		serializer.WriteStringVector(cte.second->aliases);
 		cte.second->query->Serialize(serializer);
@@ -156308,15 +156335,14 @@ unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
 	// cte_map
 	auto cte_count = reader.ReadRequired<uint32_t>();
 	auto &source = reader.GetSource();
-	unordered_map<string, unique_ptr<CommonTableExpressionInfo>> cte_map;
+	unordered_map<string, unique_ptr<CommonTableExpressionInfo>> new_map;
 	for (idx_t i = 0; i < cte_count; i++) {
 		auto name = source.Read<string>();
 		auto info = make_unique<CommonTableExpressionInfo>();
 		source.ReadStringVector(info->aliases);
 		info->query = SelectStatement::Deserialize(source);
-		cte_map[name] = move(info);
+		new_map[name] = move(info);
 	}
-
 	unique_ptr<QueryNode> result;
 	switch (type) {
 	case QueryNodeType::SELECT_NODE:
@@ -156332,7 +156358,7 @@ unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
 		throw SerializationException("Could not deserialize Query Node: unknown type!");
 	}
 	result->modifiers = move(modifiers);
-	result->cte_map = move(cte_map);
+	result->cte_map.map = move(new_map);
 	reader.Finalize();
 	return result;
 }
@@ -156691,6 +156717,7 @@ unique_ptr<SQLStatement> CreateStatement::Copy() const {
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 DeleteStatement::DeleteStatement() : SQLStatement(StatementType::DELETE_STATEMENT) {
@@ -156703,10 +156730,12 @@ DeleteStatement::DeleteStatement(const DeleteStatement &other) : SQLStatement(ot
 	for (const auto &using_clause : other.using_clauses) {
 		using_clauses.push_back(using_clause->Copy());
 	}
+	cte_map = other.cte_map.Copy();
 }
 
 string DeleteStatement::ToString() const {
 	string result;
+	result = cte_map.ToString();
 	result += "DELETE FROM ";
 	result += table->ToString();
 	if (!using_clauses.empty()) {
@@ -156891,11 +156920,13 @@ InsertStatement::InsertStatement(const InsertStatement &other)
     : SQLStatement(other),
       select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(other.select_statement->Copy())),
       columns(other.columns), table(other.table), schema(other.schema) {
+	cte_map = other.cte_map.Copy();
 }
 
 string InsertStatement::ToString() const {
 	string result;
-	result = "INSERT INTO ";
+	result = cte_map.ToString();
+	result += "INSERT INTO ";
 	if (!schema.empty()) {
 		result += KeywordHelper::WriteOptionallyQuoted(schema) + ".";
 	}
@@ -156942,7 +156973,7 @@ ExpressionListRef *InsertStatement::GetValuesList() const {
 	if (node.where_clause || node.qualify || node.having) {
 		return nullptr;
 	}
-	if (!node.cte_map.empty()) {
+	if (!node.cte_map.map.empty()) {
 		return nullptr;
 	}
 	if (!node.groups.grouping_sets.empty()) {
@@ -157248,6 +157279,7 @@ unique_ptr<SQLStatement> TransactionStatement::Copy() const {
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 UpdateStatement::UpdateStatement() : SQLStatement(StatementType::UPDATE_STATEMENT) {
@@ -157264,11 +157296,13 @@ UpdateStatement::UpdateStatement(const UpdateStatement &other)
 	for (auto &expr : other.expressions) {
 		expressions.emplace_back(expr->Copy());
 	}
+	cte_map = other.cte_map.Copy();
 }
 
 string UpdateStatement::ToString() const {
 	string result;
-	result = "UPDATE ";
+	result = cte_map.ToString();
+	result += "UPDATE ";
 	result += table->ToString();
 	result += " SET ";
 	D_ASSERT(columns.size() == expressions.size());
@@ -159188,12 +159222,14 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 			    string((reinterpret_cast<duckdb_libpgquery::PGValue *>(root->operName->head->data.ptr_value))->val.str);
 			subquery_expr->comparison_type = OperatorToExpressionType(operator_name);
 		}
-		D_ASSERT(subquery_expr->comparison_type == ExpressionType::COMPARE_EQUAL ||
-		         subquery_expr->comparison_type == ExpressionType::COMPARE_NOTEQUAL ||
-		         subquery_expr->comparison_type == ExpressionType::COMPARE_GREATERTHAN ||
-		         subquery_expr->comparison_type == ExpressionType::COMPARE_GREATERTHANOREQUALTO ||
-		         subquery_expr->comparison_type == ExpressionType::COMPARE_LESSTHAN ||
-		         subquery_expr->comparison_type == ExpressionType::COMPARE_LESSTHANOREQUALTO);
+		if (subquery_expr->comparison_type != ExpressionType::COMPARE_EQUAL &&
+		    subquery_expr->comparison_type != ExpressionType::COMPARE_NOTEQUAL &&
+		    subquery_expr->comparison_type != ExpressionType::COMPARE_GREATERTHAN &&
+		    subquery_expr->comparison_type != ExpressionType::COMPARE_GREATERTHANOREQUALTO &&
+		    subquery_expr->comparison_type != ExpressionType::COMPARE_LESSTHAN &&
+		    subquery_expr->comparison_type != ExpressionType::COMPARE_LESSTHANOREQUALTO) {
+			throw ParserException("ANY and ALL operators require one of =,<>,>,<,>=,<= comparisons!");
+		}
 		if (root->subLinkType == duckdb_libpgquery::PG_ALL_SUBLINK) {
 			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
 			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
@@ -160063,7 +160099,7 @@ string Transformer::TransformAlias(duckdb_libpgquery::PGAlias *root, vector<stri
 
 namespace duckdb {
 
-void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause *de_with_clause, QueryNode &select) {
+void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause *de_with_clause, CommonTableExpressionMap &cte_map) {
 	// TODO: might need to update in case of future lawsuit
 	D_ASSERT(de_with_clause);
 
@@ -160106,12 +160142,12 @@ void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause *de_with_clause,
 		D_ASSERT(info->query);
 		auto cte_name = string(cte->ctename);
 
-		auto it = select.cte_map.find(cte_name);
-		if (it != select.cte_map.end()) {
+		auto it = cte_map.map.find(cte_name);
+		if (it != cte_map.map.end()) {
 			// can't have two CTEs with same name
 			throw ParserException("Duplicate CTE name \"%s\"", cte_name);
 		}
-		select.cte_map[cte_name] = move(info);
+		cte_map.map[cte_name] = move(info);
 	}
 }
 
@@ -161449,6 +161485,9 @@ unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGNo
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGDeleteStmt *>(node);
 	D_ASSERT(stmt);
 	auto result = make_unique<DeleteStatement>();
+	if (stmt->withClause) {
+		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), result->cte_map);
+	}
 
 	result->condition = TransformExpression(stmt->whereClause);
 	result->table = TransformRangeVar(stmt->relation);
@@ -161625,8 +161664,14 @@ unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGNo
 	if (stmt->onConflictClause && stmt->onConflictClause->action != duckdb_libpgquery::PG_ONCONFLICT_NONE) {
 		throw ParserException("ON CONFLICT IGNORE/UPDATE clauses are not supported");
 	}
+	if (!stmt->selectStmt) {
+		throw ParserException("DEFAULT VALUES clause is not supported!");
+	}
 
 	auto result = make_unique<InsertStatement>();
+	if (stmt->withClause) {
+		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), result->cte_map);
+	}
 
 	// first check if there are any columns specified
 	if (stmt->cols) {
@@ -161936,7 +161981,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSele
 		node = make_unique<SelectNode>();
 		auto result = (SelectNode *)node.get();
 		if (stmt->withClause) {
-			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), *node);
+			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), node->cte_map);
 		}
 		if (stmt->windowClause) {
 			for (auto window_ele = stmt->windowClause->head; window_ele != nullptr; window_ele = window_ele->next) {
@@ -161998,7 +162043,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSele
 		node = make_unique<SetOperationNode>();
 		auto result = (SetOperationNode *)node.get();
 		if (stmt->withClause) {
-			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), *node);
+			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), node->cte_map);
 		}
 		result->left = TransformSelectNode(stmt->larg);
 		result->right = TransformSelectNode(stmt->rarg);
@@ -162217,6 +162262,9 @@ unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGNo
 	D_ASSERT(stmt);
 
 	auto result = make_unique<UpdateStatement>();
+	if (stmt->withClause) {
+		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), result->cte_map);
+	}
 
 	result->table = TransformRangeVar(stmt->relation);
 	if (stmt->fromClause) {
@@ -167845,6 +167893,9 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		properties.read_only = false;
 	}
 
+	// Add CTEs as bindable
+	AddCTEMap(stmt.cte_map);
+
 	// plan any tables from the various using clauses
 	if (!stmt.using_clauses.empty()) {
 		unique_ptr<LogicalOperator> child_operator;
@@ -168291,6 +168342,9 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 	auto insert = make_unique<LogicalInsert>(table);
 
+	// Add CTEs as bindable
+	AddCTEMap(stmt.cte_map);
+
 	idx_t generated_column_count = 0;
 	vector<idx_t> named_column_map;
 	if (!stmt.columns.empty()) {
@@ -168912,6 +168966,9 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	auto &table_binding = (BoundBaseTableRef &)*bound_table;
 	auto table = table_binding.table;
 
+	// Add CTEs as bindable
+	AddCTEMap(stmt.cte_map);
+
 	if (stmt.from_table) {
 		BoundCrossProductRef bound_crossproduct;
 		bound_crossproduct.left = move(bound_table);
@@ -170413,11 +170470,15 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 	} // LCOV_EXCL_STOP
 }
 
-unique_ptr<BoundQueryNode> Binder::BindNode(QueryNode &node) {
-	// first we visit the set of CTEs and add them to the bind context
-	for (auto &cte_it : node.cte_map) {
+void Binder::AddCTEMap(CommonTableExpressionMap &cte_map) {
+	for (auto &cte_it : cte_map.map) {
 		AddCTE(cte_it.first, cte_it.second.get());
 	}
+}
+
+unique_ptr<BoundQueryNode> Binder::BindNode(QueryNode &node) {
+	// first we visit the set of CTEs and add them to the bind context
+	AddCTEMap(node.cte_map);
 	// now we bind the node
 	unique_ptr<BoundQueryNode> result;
 	switch (node.type) {