duckdb 0.3.2-dev1323.0 → 0.3.2-dev1335.0

package/package.json

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

package/src/duckdb.cpp

@@ -40015,7 +40015,7 @@ DistinctSelectGenericLoopSwitch(LEFT_TYPE *__restrict ldata, RIGHT_TYPE *__restr
                                 const SelectionVector *__restrict lsel, const SelectionVector *__restrict rsel,
                                 const SelectionVector *__restrict result_sel, idx_t count, ValidityMask &lmask,
                                 ValidityMask &rmask, SelectionVector *true_sel, SelectionVector *false_sel) {
-	if (!lmask.AllValid() || rmask.AllValid()) {
+	if (!lmask.AllValid() || !rmask.AllValid()) {
 		return DistinctSelectGenericLoopSelSwitch<LEFT_TYPE, RIGHT_TYPE, OP, DENSE, false>(
 		    ldata, rdata, lsel, rsel, result_sel, count, lmask, rmask, true_sel, false_sel);
 	} else {
@@ -56738,6 +56738,7 @@ bool TopNHeap::CheckBoundaryValues(DataChunk &sort_chunk, DataChunk &payload) {
 		idx_t false_count = remaining_count - true_count;
 		if (false_count > 0) {
 			// check what we should continue to check
+			compare_chunk.data[i].Slice(sort_chunk.data[i], false_sel, false_count);
 			remaining_count = VectorOperations::NotDistinctFrom(compare_chunk.data[i], boundary_values.data[i],
 			                                                    &false_sel, false_count, &new_remaining_sel, nullptr);
 			if (is_last) {
@@ -63535,11 +63536,14 @@ enum class ExplainType : uint8_t { EXPLAIN_STANDARD, EXPLAIN_ANALYZE };
 
 class ExplainStatement : public SQLStatement {
 public:
-	ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType explain_type = ExplainType::EXPLAIN_STANDARD);
+	explicit ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType explain_type = ExplainType::EXPLAIN_STANDARD);
 
 	unique_ptr<SQLStatement> stmt;
 	ExplainType explain_type;
 
+protected:
+	ExplainStatement(const ExplainStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -89868,7 +89872,7 @@ void SystemFun::RegisterFunction(BuiltinFunctions &set) {
 	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
 
 	set.AddFunction(
-	    ScalarFunction("current_query", {}, LogicalType::VARCHAR, CurrentQueryFunction, false, BindSystemFunction));
+	    ScalarFunction("current_query", {}, LogicalType::VARCHAR, CurrentQueryFunction, true, BindSystemFunction));
 	set.AddFunction(
 	    ScalarFunction("current_schema", {}, LogicalType::VARCHAR, CurrentSchemaFunction, false, BindSystemFunction));
 	set.AddFunction(ScalarFunction("current_schemas", {LogicalType::BOOLEAN}, varchar_list_type, CurrentSchemasFunction,
@@ -98796,6 +98800,9 @@ public:
 
 	unique_ptr<DropInfo> info;
 
+protected:
+	DropStatement(const DropStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -98825,6 +98832,9 @@ public:
 	string name;
 	vector<unique_ptr<ParsedExpression>> values;
 
+protected:
+	ExecuteStatement(const ExecuteStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -98853,6 +98863,9 @@ public:
 	unique_ptr<SQLStatement> statement;
 	string name;
 
+protected:
+	PrepareStatement(const PrepareStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -98938,6 +98951,9 @@ public:
 
 	shared_ptr<Relation> relation;
 
+protected:
+	RelationStatement(const RelationStatement &other) = default;
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -98980,6 +98996,9 @@ public:
 
 	unique_ptr<PragmaInfo> info;
 
+protected:
+	PragmaStatement(const PragmaStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -109274,23 +109293,25 @@ PreparedStatementData::~PreparedStatementData() {
 
 void PreparedStatementData::Bind(vector<Value> values) {
 	// set parameters
-	if (values.size() != value_map.size()) {
+	const auto required = unbound_statement ? unbound_statement->n_param : 0;
+	if (values.size() != required) {
 		throw BinderException("Parameter/argument count mismatch for prepared statement. Expected %llu, got %llu",
-		                      value_map.size(), values.size());
+		                      required, values.size());
 	}
-	// bind the values
-	for (idx_t i = 0; i < values.size(); i++) {
-		auto it = value_map.find(i + 1);
-		if (it == value_map.end()) {
+
+	// bind the required values
+	for (auto &it : value_map) {
+		const idx_t i = it.first - 1;
+		if (i >= values.size()) {
 			throw BinderException("Could not find parameter with index %llu", i + 1);
 		}
-		D_ASSERT(!it->second.empty());
-		if (!values[i].TryCastAs(it->second[0]->type())) {
+		D_ASSERT(!it.second.empty());
+		if (!values[i].TryCastAs(it.second[0]->type())) {
 			throw BinderException(
 			    "Type mismatch for binding parameter with index %llu, expected type %s but got type %s", i + 1,
-			    it->second[0]->type().ToString().c_str(), values[i].type().ToString().c_str());
+			    it.second[0]->type().ToString().c_str(), values[i].type().ToString().c_str());
 		}
-		for (auto &target : it->second) {
+		for (auto &target : it.second) {
 			*target = values[i];
 		}
 	}
@@ -110543,6 +110564,9 @@ public:
 
 	unique_ptr<CreateInfo> info;
 
+protected:
+	CreateStatement(const CreateStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -110793,6 +110817,9 @@ public:
 	unique_ptr<TableRef> table;
 	vector<unique_ptr<TableRef>> using_clauses;
 
+protected:
+	DeleteStatement(const DeleteStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -111186,6 +111213,9 @@ public:
 	//! Schema name to insert to
 	string schema;
 
+protected:
+	InsertStatement(const InsertStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -112085,6 +112115,9 @@ public:
 	vector<string> columns;
 	vector<unique_ptr<ParsedExpression>> expressions;
 
+protected:
+	UpdateStatement(const UpdateStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -112325,6 +112358,9 @@ public:
 	// The SQL statement used instead of a table when copying data out to a file
 	unique_ptr<QueryNode> select_statement;
 
+protected:
+	CopyStatement(const CopyStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -135603,6 +135639,8 @@ private:
 private:
 	//! Transforms a Postgres statement into a single SQL statement
 	unique_ptr<SQLStatement> TransformStatement(duckdb_libpgquery::PGNode *stmt);
+	//! Transforms a Postgres statement into a single SQL statement
+	unique_ptr<SQLStatement> TransformStatementInternal(duckdb_libpgquery::PGNode *stmt);
 	//===--------------------------------------------------------------------===//
 	// Statement transformation
 	//===--------------------------------------------------------------------===//
@@ -136863,10 +136901,12 @@ namespace duckdb {
 class AlterStatement : public SQLStatement {
 public:
 	AlterStatement();
-	explicit AlterStatement(unique_ptr<AlterInfo> info);
 
 	unique_ptr<AlterInfo> info;
 
+protected:
+	AlterStatement(const AlterStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -136878,13 +136918,12 @@ namespace duckdb {
 
 AlterStatement::AlterStatement() : SQLStatement(StatementType::ALTER_STATEMENT) {
 }
-AlterStatement::AlterStatement(unique_ptr<AlterInfo> info)
-    : SQLStatement(StatementType::ALTER_STATEMENT), info(move(info)) {
+
+AlterStatement::AlterStatement(const AlterStatement &other) : SQLStatement(other), info(other.info->Copy()) {
 }
 
 unique_ptr<SQLStatement> AlterStatement::Copy() const {
-	auto result = make_unique<AlterStatement>(info->Copy());
-	return move(result);
+	return unique_ptr<AlterStatement>(new AlterStatement(*this));
 }
 
 } // namespace duckdb
@@ -136910,6 +136949,9 @@ public:
 
 	unique_ptr<ParsedExpression> function;
 
+protected:
+	CallStatement(const CallStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -136921,10 +136963,11 @@ namespace duckdb {
 CallStatement::CallStatement() : SQLStatement(StatementType::CALL_STATEMENT) {
 }
 
+CallStatement::CallStatement(const CallStatement &other) : SQLStatement(other), function(other.function->Copy()) {
+}
+
 unique_ptr<SQLStatement> CallStatement::Copy() const {
-	auto result = make_unique<CallStatement>();
-	result->function = function->Copy();
-	return move(result);
+	return unique_ptr<CallStatement>(new CallStatement(*this));
 }
 
 } // namespace duckdb
@@ -136935,13 +136978,14 @@ namespace duckdb {
 CopyStatement::CopyStatement() : SQLStatement(StatementType::COPY_STATEMENT), info(make_unique<CopyInfo>()) {
 }
 
-unique_ptr<SQLStatement> CopyStatement::Copy() const {
-	auto result = make_unique<CopyStatement>();
-	result->info = info->Copy();
-	if (select_statement) {
-		result->select_statement = select_statement->Copy();
+CopyStatement::CopyStatement(const CopyStatement &other) : SQLStatement(other), info(other.info->Copy()) {
+	if (other.select_statement) {
+		select_statement = other.select_statement->Copy();
 	}
-	return move(result);
+}
+
+unique_ptr<SQLStatement> CopyStatement::Copy() const {
+	return unique_ptr<CopyStatement>(new CopyStatement(*this));
 }
 
 } // namespace duckdb
@@ -136952,10 +136996,11 @@ namespace duckdb {
 CreateStatement::CreateStatement() : SQLStatement(StatementType::CREATE_STATEMENT) {
 }
 
+CreateStatement::CreateStatement(const CreateStatement &other) : SQLStatement(other), info(other.info->Copy()) {
+}
+
 unique_ptr<SQLStatement> CreateStatement::Copy() const {
-	auto result = make_unique<CreateStatement>();
-	result->info = info->Copy();
-	return move(result);
+	return unique_ptr<CreateStatement>(new CreateStatement(*this));
 }
 
 } // namespace duckdb
@@ -136966,16 +137011,17 @@ namespace duckdb {
 DeleteStatement::DeleteStatement() : SQLStatement(StatementType::DELETE_STATEMENT) {
 }
 
-unique_ptr<SQLStatement> DeleteStatement::Copy() const {
-	auto result = make_unique<DeleteStatement>();
-	if (condition) {
-		result->condition = condition->Copy();
+DeleteStatement::DeleteStatement(const DeleteStatement &other) : SQLStatement(other), table(other.table->Copy()) {
+	if (other.condition) {
+		condition = other.condition->Copy();
 	}
-	result->table = table->Copy();
-	for (auto &using_clause : using_clauses) {
-		result->using_clauses.push_back(using_clause->Copy());
+	for (const auto &using_clause : other.using_clauses) {
+		using_clauses.push_back(using_clause->Copy());
 	}
-	return move(result);
+}
+
+unique_ptr<SQLStatement> DeleteStatement::Copy() const {
+	return unique_ptr<DeleteStatement>(new DeleteStatement(*this));
 }
 
 } // namespace duckdb
@@ -136986,10 +137032,11 @@ namespace duckdb {
 DropStatement::DropStatement() : SQLStatement(StatementType::DROP_STATEMENT), info(make_unique<DropInfo>()) {
 }
 
+DropStatement::DropStatement(const DropStatement &other) : SQLStatement(other), info(other.info->Copy()) {
+}
+
 unique_ptr<SQLStatement> DropStatement::Copy() const {
-	auto result = make_unique<DropStatement>();
-	result->info = info->Copy();
-	return move(result);
+	return unique_ptr<DropStatement>(new DropStatement(*this));
 }
 
 } // namespace duckdb
@@ -137000,13 +137047,14 @@ namespace duckdb {
 ExecuteStatement::ExecuteStatement() : SQLStatement(StatementType::EXECUTE_STATEMENT) {
 }
 
-unique_ptr<SQLStatement> ExecuteStatement::Copy() const {
-	auto result = make_unique<ExecuteStatement>();
-	result->name = name;
-	for (auto &value : values) {
-		result->values.push_back(value->Copy());
+ExecuteStatement::ExecuteStatement(const ExecuteStatement &other) : SQLStatement(other), name(other.name) {
+	for (const auto &value : other.values) {
+		values.push_back(value->Copy());
 	}
-	return move(result);
+}
+
+unique_ptr<SQLStatement> ExecuteStatement::Copy() const {
+	return unique_ptr<ExecuteStatement>(new ExecuteStatement(*this));
 }
 
 } // namespace duckdb
@@ -137018,9 +137066,12 @@ ExplainStatement::ExplainStatement(unique_ptr<SQLStatement> stmt, ExplainType ex
     : SQLStatement(StatementType::EXPLAIN_STATEMENT), stmt(move(stmt)), explain_type(explain_type) {
 }
 
+ExplainStatement::ExplainStatement(const ExplainStatement &other)
+    : SQLStatement(other), stmt(other.stmt->Copy()), explain_type(other.explain_type) {
+}
+
 unique_ptr<SQLStatement> ExplainStatement::Copy() const {
-	auto result = make_unique<ExplainStatement>(stmt->Copy(), explain_type);
-	return move(result);
+	return unique_ptr<ExplainStatement>(new ExplainStatement(*this));
 }
 
 } // namespace duckdb
@@ -137046,6 +137097,9 @@ public:
 
 	unique_ptr<CopyInfo> info;
 
+protected:
+	ExportStatement(const ExportStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -137059,8 +137113,11 @@ ExportStatement::ExportStatement(unique_ptr<CopyInfo> info)
     : SQLStatement(StatementType::EXPORT_STATEMENT), info(move(info)) {
 }
 
+ExportStatement::ExportStatement(const ExportStatement &other) : SQLStatement(other), info(other.info->Copy()) {
+}
+
 unique_ptr<SQLStatement> ExportStatement::Copy() const {
-	return make_unique_base<SQLStatement, ExportStatement>(info->Copy());
+	return unique_ptr<ExportStatement>(new ExportStatement(*this));
 }
 
 } // namespace duckdb
@@ -137071,20 +137128,21 @@ namespace duckdb {
 InsertStatement::InsertStatement() : SQLStatement(StatementType::INSERT_STATEMENT), schema(DEFAULT_SCHEMA) {
 }
 
+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) {
+}
+
 unique_ptr<SQLStatement> InsertStatement::Copy() const {
-	auto result = make_unique<InsertStatement>();
-	result->select_statement = unique_ptr_cast<SQLStatement, SelectStatement>(select_statement->Copy());
-	result->columns = columns;
-	result->table = table;
-	result->schema = schema;
-	return move(result);
+	return unique_ptr<InsertStatement>(new InsertStatement(*this));
 }
 
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/statement/set_statement.hpp
+// duckdb/parser/statement/load_statement.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -137100,6 +137158,9 @@ class LoadStatement : public SQLStatement {
 public:
 	LoadStatement();
 
+protected:
+	LoadStatement(const LoadStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 
@@ -137113,10 +137174,11 @@ namespace duckdb {
 LoadStatement::LoadStatement() : SQLStatement(StatementType::LOAD_STATEMENT) {
 }
 
+LoadStatement::LoadStatement(const LoadStatement &other) : SQLStatement(other), info(other.info->Copy()) {
+}
+
 unique_ptr<SQLStatement> LoadStatement::Copy() const {
-	auto result = make_unique<LoadStatement>();
-	result->info = info->Copy();
-	return move(result);
+	return unique_ptr<LoadStatement>(new LoadStatement(*this));
 }
 
 } // namespace duckdb
@@ -137127,10 +137189,11 @@ namespace duckdb {
 PragmaStatement::PragmaStatement() : SQLStatement(StatementType::PRAGMA_STATEMENT), info(make_unique<PragmaInfo>()) {
 }
 
+PragmaStatement::PragmaStatement(const PragmaStatement &other) : SQLStatement(other), info(other.info->Copy()) {
+}
+
 unique_ptr<SQLStatement> PragmaStatement::Copy() const {
-	auto result = make_unique<PragmaStatement>();
-	result->info = info->Copy();
-	return move(result);
+	return unique_ptr<PragmaStatement>(new PragmaStatement(*this));
 }
 
 } // namespace duckdb
@@ -137141,11 +137204,12 @@ namespace duckdb {
 PrepareStatement::PrepareStatement() : SQLStatement(StatementType::PREPARE_STATEMENT), statement(nullptr), name("") {
 }
 
+PrepareStatement::PrepareStatement(const PrepareStatement &other)
+    : SQLStatement(other), statement(other.statement->Copy()), name(other.name) {
+}
+
 unique_ptr<SQLStatement> PrepareStatement::Copy() const {
-	auto result = make_unique<PrepareStatement>();
-	result->statement = statement->Copy();
-	result->name = name;
-	return move(result);
+	return unique_ptr<PrepareStatement>(new PrepareStatement(*this));
 }
 
 } // namespace duckdb
@@ -137158,8 +137222,7 @@ RelationStatement::RelationStatement(shared_ptr<Relation> relation)
 }
 
 unique_ptr<SQLStatement> RelationStatement::Copy() const {
-	auto result = make_unique<RelationStatement>(relation);
-	return move(result);
+	return unique_ptr<RelationStatement>(new RelationStatement(*this));
 }
 
 } // namespace duckdb
@@ -137169,10 +137232,11 @@ unique_ptr<SQLStatement> RelationStatement::Copy() const {
 
 namespace duckdb {
 
+SelectStatement::SelectStatement(const SelectStatement &other) : SQLStatement(other), node(other.node->Copy()) {
+}
+
 unique_ptr<SQLStatement> SelectStatement::Copy() const {
-	auto result = make_unique<SelectStatement>();
-	result->node = node->Copy();
-	return move(result);
+	return unique_ptr<SelectStatement>(new SelectStatement(*this));
 }
 
 void SelectStatement::Serialize(Serializer &serializer) const {
@@ -137214,6 +137278,9 @@ class SetStatement : public SQLStatement {
 public:
 	SetStatement(std::string name_p, Value value_p, SetScope scope_p);
 
+protected:
+	SetStatement(const SetStatement &other) = default;
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 
@@ -137231,7 +137298,7 @@ SetStatement::SetStatement(std::string name_p, Value value_p, SetScope scope_p)
 }
 
 unique_ptr<SQLStatement> SetStatement::Copy() const {
-	return make_unique<SetStatement>(name, value, scope);
+	return unique_ptr<SetStatement>(new SetStatement(*this));
 }
 
 } // namespace duckdb
@@ -137256,6 +137323,9 @@ public:
 
 	unique_ptr<ShowSelectInfo> info;
 
+protected:
+	ShowStatement(const ShowStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -137268,10 +137338,11 @@ namespace duckdb {
 ShowStatement::ShowStatement() : SQLStatement(StatementType::SHOW_STATEMENT), info(make_unique<ShowSelectInfo>()) {
 }
 
+ShowStatement::ShowStatement(const ShowStatement &other) : SQLStatement(other), info(other.info->Copy()) {
+}
+
 unique_ptr<SQLStatement> ShowStatement::Copy() const {
-	auto result = make_unique<ShowStatement>();
-	result->info = info->Copy();
-	return move(result);
+	return unique_ptr<ShowStatement>(new ShowStatement(*this));
 }
 
 } // namespace duckdb
@@ -137296,6 +137367,9 @@ public:
 
 	unique_ptr<TransactionInfo> info;
 
+protected:
+	TransactionStatement(const TransactionStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -137308,8 +137382,12 @@ TransactionStatement::TransactionStatement(TransactionType type)
     : SQLStatement(StatementType::TRANSACTION_STATEMENT), info(make_unique<TransactionInfo>(type)) {
 }
 
+TransactionStatement::TransactionStatement(const TransactionStatement &other)
+    : SQLStatement(other), info(make_unique<TransactionInfo>(other.info->type)) {
+}
+
 unique_ptr<SQLStatement> TransactionStatement::Copy() const {
-	return make_unique_base<SQLStatement, TransactionStatement>(info->type);
+	return unique_ptr<TransactionStatement>(new TransactionStatement(*this));
 }
 
 } // namespace duckdb
@@ -137320,20 +137398,21 @@ namespace duckdb {
 UpdateStatement::UpdateStatement() : SQLStatement(StatementType::UPDATE_STATEMENT) {
 }
 
-unique_ptr<SQLStatement> UpdateStatement::Copy() const {
-	auto result = make_unique<UpdateStatement>();
-	if (condition) {
-		result->condition = condition->Copy();
+UpdateStatement::UpdateStatement(const UpdateStatement &other)
+    : SQLStatement(other), table(other.table->Copy()), columns(other.columns) {
+	if (other.condition) {
+		condition = other.condition->Copy();
 	}
-	result->table = table->Copy();
-	if (from_table) {
-		result->from_table = from_table->Copy();
+	if (other.from_table) {
+		from_table = other.from_table->Copy();
 	}
-	result->columns = columns;
-	for (auto &expr : expressions) {
-		result->expressions.push_back(expr->Copy());
+	for (auto &expr : other.expressions) {
+		expressions.emplace_back(expr->Copy());
 	}
-	return move(result);
+}
+
+unique_ptr<SQLStatement> UpdateStatement::Copy() const {
+	return unique_ptr<UpdateStatement>(new UpdateStatement(*this));
 }
 
 } // namespace duckdb
@@ -137359,6 +137438,9 @@ public:
 
 	unique_ptr<VacuumInfo> info;
 
+protected:
+	VacuumStatement(const VacuumStatement &other) : SQLStatement(other) {};
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -137372,7 +137454,7 @@ VacuumStatement::VacuumStatement() : SQLStatement(StatementType::VACUUM_STATEMEN
 }
 
 unique_ptr<SQLStatement> VacuumStatement::Copy() const {
-	return make_unique<VacuumStatement>();
+	return unique_ptr<VacuumStatement>(new VacuumStatement(*this));
 }
 
 } // namespace duckdb
@@ -141693,7 +141775,10 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 		throw NotImplementedException("Schema element not supported yet!");
 	}
 	D_ASSERT(info);
-	return make_unique<AlterStatement>(move(info));
+
+	auto result = make_unique<AlterStatement>();
+	result->info = move(info);
+	return result;
 }
 
 } // namespace duckdb
@@ -142366,6 +142451,12 @@ StackChecker Transformer::StackCheck(idx_t extra_stack) {
 }
 
 unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode *stmt) {
+	auto result = TransformStatementInternal(stmt);
+	result->n_param = ParamCount();
+	return result;
+}
+
+unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgquery::PGNode *stmt) {
 	switch (stmt->type) {
 	case duckdb_libpgquery::T_PGRawStmt: {
 		auto raw_stmt = (duckdb_libpgquery::PGRawStmt *)stmt;
@@ -148284,7 +148375,9 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		subquery.column_name_alias =
 		    BindContext::AliasColumnNames(subquery.alias, view_catalog_entry->aliases, ref.column_name_alias);
 		// bind the child subquery
+		view_binder->AddBoundView(view_catalog_entry);
 		auto bound_child = view_binder->Bind(subquery);
+
 		D_ASSERT(bound_child->type == TableReferenceType::SUBQUERY);
 		// verify that the types and names match up with the expected types and names
 		auto &bound_subquery = (BoundSubqueryRef &)*bound_child;
@@ -149273,6 +149366,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
 
 
 
+
 #include <algorithm>
 
 namespace duckdb {
@@ -149490,6 +149584,19 @@ bool Binder::CTEIsAlreadyBound(CommonTableExpressionInfo *cte) {
 	return false;
 }
 
+void Binder::AddBoundView(ViewCatalogEntry *view) {
+	// check if the view is already bound
+	auto current = this;
+	while (current) {
+		if (current->bound_views.find(view) != current->bound_views.end()) {
+			throw BinderException("infinite recursion detected: attempting to recursively bind view \"%s\"",
+			                      view->name);
+		}
+		current = current->parent.get();
+	}
+	bound_views.insert(view);
+}
+
 idx_t Binder::GenerateTableIndex() {
 	if (parent) {
 		return parent->GenerateTableIndex();
@@ -153125,7 +153232,9 @@ void Planner::PlanExecute(unique_ptr<SQLStatement> statement) {
 	vector<Value> bind_values;
 	for (idx_t i = 0; i < stmt.values.size(); i++) {
 		ConstantBinder cbinder(*binder, context, "EXECUTE statement");
-		cbinder.target_type = prepared->GetType(i + 1);
+		if (prepared->value_map.count(i + 1)) {
+			cbinder.target_type = prepared->GetType(i + 1);
+		}
 		auto bound_expr = cbinder.Bind(stmt.values[i]);
 
 		Value value = ExpressionExecutor::EvaluateScalar(*bound_expr);