duckdb 0.3.2-dev1325.0 → 0.3.2-dev1329.0

package/package.json

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

package/src/duckdb.cpp

@@ -63535,11 +63535,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;
 };
@@ -98796,6 +98799,9 @@ public:
 
 	unique_ptr<DropInfo> info;
 
+protected:
+	DropStatement(const DropStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -98825,6 +98831,9 @@ public:
 	string name;
 	vector<unique_ptr<ParsedExpression>> values;
 
+protected:
+	ExecuteStatement(const ExecuteStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -98853,6 +98862,9 @@ public:
 	unique_ptr<SQLStatement> statement;
 	string name;
 
+protected:
+	PrepareStatement(const PrepareStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -98938,6 +98950,9 @@ public:
 
 	shared_ptr<Relation> relation;
 
+protected:
+	RelationStatement(const RelationStatement &other) = default;
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -98980,6 +98995,9 @@ public:
 
 	unique_ptr<PragmaInfo> info;
 
+protected:
+	PragmaStatement(const PragmaStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -109274,23 +109292,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 +110563,9 @@ public:
 
 	unique_ptr<CreateInfo> info;
 
+protected:
+	CreateStatement(const CreateStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -110793,6 +110816,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 +111212,9 @@ public:
 	//! Schema name to insert to
 	string schema;
 
+protected:
+	InsertStatement(const InsertStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -112085,6 +112114,9 @@ public:
 	vector<string> columns;
 	vector<unique_ptr<ParsedExpression>> expressions;
 
+protected:
+	UpdateStatement(const UpdateStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -112325,6 +112357,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 +135638,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 +136900,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 +136917,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 +136948,9 @@ public:
 
 	unique_ptr<ParsedExpression> function;
 
+protected:
+	CallStatement(const CallStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -136921,10 +136962,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 +136977,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 +136995,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 +137010,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 +137031,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 +137046,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 +137065,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 +137096,9 @@ public:
 
 	unique_ptr<CopyInfo> info;
 
+protected:
+	ExportStatement(const ExportStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -137059,8 +137112,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 +137127,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 +137157,9 @@ class LoadStatement : public SQLStatement {
 public:
 	LoadStatement();
 
+protected:
+	LoadStatement(const LoadStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 
@@ -137113,10 +137173,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 +137188,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 +137203,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 +137221,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 +137231,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 +137277,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 +137297,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 +137322,9 @@ public:
 
 	unique_ptr<ShowSelectInfo> info;
 
+protected:
+	ShowStatement(const ShowStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -137268,10 +137337,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 +137366,9 @@ public:
 
 	unique_ptr<TransactionInfo> info;
 
+protected:
+	TransactionStatement(const TransactionStatement &other);
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -137308,8 +137381,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 +137397,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 +137437,9 @@ public:
 
 	unique_ptr<VacuumInfo> info;
 
+protected:
+	VacuumStatement(const VacuumStatement &other) : SQLStatement(other) {};
+
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 };
@@ -137372,7 +137453,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 +141774,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 +142450,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;
@@ -153141,7 +153231,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);

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 "86af59255"
-#define DUCKDB_VERSION "v0.3.2-dev1325"
+#define DUCKDB_SOURCE_ID "a9e63a665"
+#define DUCKDB_VERSION "v0.3.2-dev1329"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -11055,6 +11055,9 @@ public:
 	//! The query text that corresponds to this SQL statement
 	string query;
 
+protected:
+	SQLStatement(const SQLStatement &other) = default;
+
 public:
 	//! Create a copy of this SelectStatement
 	virtual unique_ptr<SQLStatement> Copy() const = 0;
@@ -16273,6 +16276,9 @@ public:
 	//! The main query node
 	unique_ptr<QueryNode> node;
 
+protected:
+	SelectStatement(const SelectStatement &other);
+
 public:
 	//! Create a copy of this SelectStatement
 	unique_ptr<SQLStatement> Copy() const override;