duckdb 0.3.5-dev368.0 → 0.3.5-dev372.0

package/package.json

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

package/src/duckdb.cpp

@@ -6923,17 +6923,6 @@ string StatementTypeToString(StatementType type) {
 }
 // LCOV_EXCL_STOP
 
-bool StatementTypeReturnChanges(StatementType type) {
-	switch (type) {
-	case StatementType::INSERT_STATEMENT:
-	case StatementType::UPDATE_STATEMENT:
-	case StatementType::DELETE_STATEMENT:
-		return true;
-	default:
-		return false;
-	}
-}
-
 } // namespace duckdb
 
 
@@ -60088,15 +60077,8 @@ public:
 	//! The result types of the transaction
 	vector<LogicalType> types;
 
-	//! Whether or not the statement is a read-only statement, or whether it can result in changes to the database
-	bool read_only;
-	//! Whether or not the statement requires a valid transaction. Almost all statements require this, with the
-	//! exception of
-	bool requires_valid_transaction;
-	//! Whether or not the result can be streamed to the client
-	bool allow_stream_result;
-	//! Whether or not all parameters have successfully had their types determined
-	bool bound_all_parameters;
+	//! The statement properties
+	StatementProperties properties;
 
 	//! The catalog version of when the prepared statement was bound
 	//! If this version is lower than the current catalog version, we have to rebind the prepared statement
@@ -109137,7 +109119,7 @@ idx_t duckdb_arrow_rows_changed(duckdb_arrow result) {
 	auto wrapper = (ArrowResultWrapper *)result;
 	idx_t rows_changed = 0;
 	idx_t row_count = wrapper->result->collection.Count();
-	if (row_count > 0 && StatementTypeReturnChanges(wrapper->result->statement_type)) {
+	if (row_count > 0 && wrapper->result->properties.return_type == duckdb::StatementReturnType::CHANGED_ROWS) {
 		auto row_changes = wrapper->result->GetValue(0, 0);
 		if (!row_changes.IsNull() && row_changes.TryCastAs(LogicalType::BIGINT)) {
 			rows_changed = row_changes.GetValue<int64_t>();
@@ -110595,7 +110577,8 @@ bool deprecated_materialize_result(duckdb_result *result) {
 		result->__deprecated_columns[i].__deprecated_name = (char *)result_data->result->names[i].c_str();
 	}
 	result->__deprecated_row_count = materialized.collection.Count();
-	if (result->__deprecated_row_count > 0 && StatementTypeReturnChanges(materialized.statement_type)) {
+	if (result->__deprecated_row_count > 0 &&
+	    materialized.properties.return_type == StatementReturnType::CHANGED_ROWS) {
 		// update total changes
 		auto row_changes = materialized.GetValue(0, 0);
 		if (!row_changes.IsNull() && row_changes.TryCastAs(LogicalType::BIGINT)) {
@@ -111809,10 +111792,7 @@ public:
 	shared_ptr<Binder> binder;
 	ClientContext &context;
 
-	bool read_only;
-	bool requires_valid_transaction;
-	bool allow_stream_result;
-	bool bound_all_parameters;
+	StatementProperties properties;
 
 private:
 	void CreatePlan(SQLStatement &statement);
@@ -112101,20 +112081,22 @@ unique_ptr<QueryResult> ClientContext::FetchResultInternal(ClientContextLock &lo
 	D_ASSERT(active_query->open_result == &pending);
 	D_ASSERT(active_query->prepared);
 	auto &prepared = *active_query->prepared;
-	bool create_stream_result = prepared.allow_stream_result && allow_stream_result;
+	bool create_stream_result = prepared.properties.allow_stream_result && allow_stream_result;
 	if (create_stream_result) {
 		active_query->progress_bar.reset();
 		query_progress = -1;
 
 		// successfully compiled SELECT clause and it is the last statement
 		// return a StreamQueryResult so the client can call Fetch() on it and stream the result
-		auto stream_result =
-		    make_unique<StreamQueryResult>(pending.statement_type, shared_from_this(), pending.types, pending.names);
+		auto stream_result = make_unique<StreamQueryResult>(pending.statement_type, pending.properties,
+		                                                    shared_from_this(), pending.types, pending.names);
 		active_query->open_result = stream_result.get();
 		return move(stream_result);
 	}
 	// create a materialized result by continuously fetching
-	auto result = make_unique<MaterializedQueryResult>(pending.statement_type, pending.types, pending.names);
+	auto result =
+	    make_unique<MaterializedQueryResult>(pending.statement_type, pending.properties, pending.types, pending.names);
+	result->properties = pending.properties;
 	while (true) {
 		auto chunk = FetchInternal(lock, GetExecutor(), *result);
 		if (!chunk || chunk->size() == 0) {
@@ -112155,14 +112137,11 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	plan->Verify();
 #endif
 	// extract the result column names from the plan
-	result->read_only = planner.read_only;
-	result->requires_valid_transaction = planner.requires_valid_transaction;
-	result->allow_stream_result = planner.allow_stream_result;
+	result->properties = planner.properties;
 	result->names = planner.names;
 	result->types = planner.types;
 	result->value_map = move(planner.value_map);
 	result->catalog_version = Transaction::GetTransaction(*this).catalog_version;
-	result->bound_all_parameters = planner.bound_all_parameters;
 
 	if (config.enable_optimizer) {
 		profiler.StartPhase("optimizer");
@@ -112198,11 +112177,11 @@ unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientCon
                                                                        vector<Value> bound_values) {
 	D_ASSERT(active_query);
 	auto &statement = *statement_p;
-	if (ActiveTransaction().IsInvalidated() && statement.requires_valid_transaction) {
+	if (ActiveTransaction().IsInvalidated() && statement.properties.requires_valid_transaction) {
 		throw Exception("Current transaction is aborted (please ROLLBACK)");
 	}
 	auto &db_config = DBConfig::GetConfig(*this);
-	if (db_config.access_mode == AccessMode::READ_ONLY && !statement.read_only) {
+	if (db_config.access_mode == AccessMode::READ_ONLY && !statement.properties.read_only) {
 		throw Exception(StringUtil::Format("Cannot execute statement of type \"%s\" in read-only mode!",
 		                                   StatementTypeToString(statement.statement_type)));
 	}
@@ -112471,17 +112450,17 @@ ClientContext::PendingStatementOrPreparedStatement(ClientContextLock &lock, cons
 			result = PendingStatementInternal(lock, query, move(statement));
 		} else {
 			auto &catalog = Catalog::GetCatalog(*this);
-			if (prepared->unbound_statement &&
-			    (catalog.GetCatalogVersion() != prepared->catalog_version || !prepared->bound_all_parameters)) {
+			if (prepared->unbound_statement && (catalog.GetCatalogVersion() != prepared->catalog_version ||
+			                                    !prepared->properties.bound_all_parameters)) {
 				// catalog was modified: rebind the statement before execution
 				auto new_prepared = CreatePreparedStatement(lock, query, prepared->unbound_statement->Copy(), values);
-				if (prepared->types != new_prepared->types && prepared->bound_all_parameters) {
+				if (prepared->types != new_prepared->types && prepared->properties.bound_all_parameters) {
 					throw BinderException("Rebinding statement after catalog change resulted in change of types");
 				}
-				D_ASSERT(new_prepared->bound_all_parameters);
+				D_ASSERT(new_prepared->properties.bound_all_parameters);
 				new_prepared->unbound_statement = move(prepared->unbound_statement);
 				prepared = move(new_prepared);
-				prepared->bound_all_parameters = false;
+				prepared->properties.bound_all_parameters = false;
 			}
 			result = PendingPreparedStatement(lock, prepared, *values);
 		}
@@ -112539,7 +112518,11 @@ unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_str
 	}
 	if (statements.empty()) {
 		// no statements, return empty successful result
-		return make_unique<MaterializedQueryResult>(StatementType::INVALID_STATEMENT);
+		StatementProperties properties;
+		vector<LogicalType> types;
+		vector<string> names;
+		return make_unique<MaterializedQueryResult>(StatementType::INVALID_STATEMENT, properties, move(types),
+		                                            move(names));
 	}
 
 	unique_ptr<QueryResult> result;
@@ -122905,13 +122888,9 @@ Extension::~Extension() {
 
 namespace duckdb {
 
-MaterializedQueryResult::MaterializedQueryResult(StatementType statement_type)
-    : QueryResult(QueryResultType::MATERIALIZED_RESULT, statement_type) {
-}
-
-MaterializedQueryResult::MaterializedQueryResult(StatementType statement_type, vector<LogicalType> types,
-                                                 vector<string> names)
-    : QueryResult(QueryResultType::MATERIALIZED_RESULT, statement_type, move(types), move(names)) {
+MaterializedQueryResult::MaterializedQueryResult(StatementType statement_type, StatementProperties properties,
+                                                 vector<LogicalType> types, vector<string> names)
+    : QueryResult(QueryResultType::MATERIALIZED_RESULT, statement_type, properties, move(types), move(names)) {
 }
 
 MaterializedQueryResult::MaterializedQueryResult(string error)
@@ -122964,7 +122943,8 @@ namespace duckdb {
 
 PendingQueryResult::PendingQueryResult(shared_ptr<ClientContext> context_p, PreparedStatementData &statement,
                                        vector<LogicalType> types_p)
-    : BaseQueryResult(QueryResultType::PENDING_RESULT, statement.statement_type, move(types_p), statement.names),
+    : BaseQueryResult(QueryResultType::PENDING_RESULT, statement.statement_type, statement.properties, move(types_p),
+                      statement.names),
       context(move(context_p)) {
 }
 
@@ -123054,6 +123034,11 @@ StatementType PreparedStatement::GetStatementType() {
 	return data->statement_type;
 }
 
+StatementProperties PreparedStatement::GetStatementProperties() {
+	D_ASSERT(data);
+	return data->properties;
+}
+
 const vector<LogicalType> &PreparedStatement::GetTypes() {
 	D_ASSERT(data);
 	return data->types;
@@ -123069,7 +123054,7 @@ unique_ptr<QueryResult> PreparedStatement::Execute(vector<Value> &values, bool a
 	if (!pending->success) {
 		return make_unique<MaterializedQueryResult>(pending->error);
 	}
-	return pending->Execute(allow_stream_result && data->allow_stream_result);
+	return pending->Execute(allow_stream_result && data->properties.allow_stream_result);
 }
 
 unique_ptr<PendingQueryResult> PreparedStatement::PendingQuery(vector<Value> &values) {
@@ -123088,9 +123073,7 @@ unique_ptr<PendingQueryResult> PreparedStatement::PendingQuery(vector<Value> &va
 
 namespace duckdb {
 
-PreparedStatementData::PreparedStatementData(StatementType type)
-    : statement_type(type), read_only(true), requires_valid_transaction(true), allow_stream_result(false),
-      bound_all_parameters(true) {
+PreparedStatementData::PreparedStatementData(StatementType type) : statement_type(type) {
 }
 
 PreparedStatementData::~PreparedStatementData() {
@@ -123835,13 +123818,10 @@ ExpressionRootInfo::ExpressionRootInfo(ExpressionExecutorState &state, string na
 
 namespace duckdb {
 
-BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type)
-    : type(type), statement_type(statement_type), success(true) {
-}
-
-BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type, vector<LogicalType> types_p,
-                                 vector<string> names_p)
-    : type(type), statement_type(statement_type), types(move(types_p)), names(move(names_p)), success(true) {
+BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties,
+                                 vector<LogicalType> types_p, vector<string> names_p)
+    : type(type), statement_type(statement_type), properties(properties), types(move(types_p)), names(move(names_p)),
+      success(true) {
 	D_ASSERT(types.size() == names.size());
 }
 
@@ -123861,12 +123841,9 @@ idx_t BaseQueryResult::ColumnCount() {
 	return types.size();
 }
 
-QueryResult::QueryResult(QueryResultType type, StatementType statement_type) : BaseQueryResult(type, statement_type) {
-}
-
-QueryResult::QueryResult(QueryResultType type, StatementType statement_type, vector<LogicalType> types_p,
-                         vector<string> names_p)
-    : BaseQueryResult(type, statement_type, move(types_p), move(names_p)) {
+QueryResult::QueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties,
+                         vector<LogicalType> types_p, vector<string> names_p)
+    : BaseQueryResult(type, statement_type, properties, move(types_p), move(names_p)) {
 }
 
 QueryResult::QueryResult(QueryResultType type, string error) : BaseQueryResult(type, move(error)) {
@@ -127147,9 +127124,10 @@ Value ThreadsSetting::GetSetting(ClientContext &context) {
 
 namespace duckdb {
 
-StreamQueryResult::StreamQueryResult(StatementType statement_type, shared_ptr<ClientContext> context,
-                                     vector<LogicalType> types, vector<string> names)
-    : QueryResult(QueryResultType::STREAM_RESULT, statement_type, move(types), move(names)), context(move(context)) {
+StreamQueryResult::StreamQueryResult(StatementType statement_type, StatementProperties properties,
+                                     shared_ptr<ClientContext> context, vector<LogicalType> types, vector<string> names)
+    : QueryResult(QueryResultType::STREAM_RESULT, statement_type, properties, move(types), move(names)),
+      context(move(context)) {
 }
 
 StreamQueryResult::~StreamQueryResult() {
@@ -127199,7 +127177,7 @@ unique_ptr<MaterializedQueryResult> StreamQueryResult::Materialize() {
 	if (!success) {
 		return make_unique<MaterializedQueryResult>(error);
 	}
-	auto result = make_unique<MaterializedQueryResult>(statement_type, types, names);
+	auto result = make_unique<MaterializedQueryResult>(statement_type, properties, types, names);
 	while (true) {
 		auto chunk = Fetch();
 		if (!chunk || chunk->size() == 0) {
@@ -161132,6 +161110,7 @@ BoundStatement Binder::Bind(CallStatement &stmt) {
 	result.types = get.returned_types;
 	result.names = get.names;
 	result.plan = CreatePlan(*bound_func);
+	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;
 }
 
@@ -161278,7 +161257,8 @@ BoundStatement Binder::Bind(CopyStatement &stmt) {
 		}
 		stmt.select_statement = move(statement);
 	}
-	this->allow_stream_result = false;
+	properties.allow_stream_result = false;
+	properties.return_type = StatementReturnType::CHANGED_ROWS;
 	if (stmt.info->is_from) {
 		return BindCopyFrom(stmt);
 	} else {
@@ -161417,7 +161397,7 @@ SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
 		if (info.schema == TEMP_SCHEMA) {
 			throw ParserException("Only TEMPORARY table names can use the \"temp\" schema");
 		}
-		this->read_only = false;
+		properties.read_only = false;
 	} else {
 		if (info.schema != TEMP_SCHEMA) {
 			throw ParserException("TEMPORARY table names can *only* use the \"%s\" schema", TEMP_SCHEMA);
@@ -161562,6 +161542,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Count"};
 	result.types = {LogicalType::BIGINT};
+	properties.return_type = StatementReturnType::NOTHING;
 
 	auto catalog_type = stmt.info->type;
 	switch (catalog_type) {
@@ -161672,6 +161653,8 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		auto &schema = bound_info->schema;
 		auto create_table = make_unique<LogicalCreateTable>(schema, move(bound_info));
 		if (root) {
+			// CREATE TABLE AS
+			properties.return_type = StatementReturnType::CHANGED_ROWS;
 			create_table->children.push_back(move(root));
 		}
 		result.plan = move(create_table);
@@ -161685,7 +161668,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	default:
 		throw Exception("Unrecognized type!");
 	}
-	this->allow_stream_result = false;
+	properties.allow_stream_result = false;
 	return result;
 }
 
@@ -161939,7 +161922,7 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 			}
 		}
 	}
-	this->allow_stream_result = false;
+	properties.allow_stream_result = false;
 	return result;
 }
 
@@ -161999,7 +161982,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 
 	if (!table->temporary) {
 		// delete from persistent table: not read only!
-		this->read_only = false;
+		properties.read_only = false;
 	}
 
 	// plan any tables from the various using clauses
@@ -162060,7 +162043,8 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		result.plan = move(del);
 		result.names = {"Count"};
 		result.types = {LogicalType::BIGINT};
-		this->allow_stream_result = false;
+		properties.allow_stream_result = false;
+		properties.return_type = StatementReturnType::CHANGED_ROWS;
 	}
 	return result;
 }
@@ -162082,11 +162066,11 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 	case CatalogType::PREPARED_STATEMENT:
 		// dropping prepared statements is always possible
 		// it also does not require a valid transaction
-		this->requires_valid_transaction = false;
+		properties.requires_valid_transaction = false;
 		break;
 	case CatalogType::SCHEMA_ENTRY:
 		// dropping a schema is never read-only because there are no temporary schemas
-		this->read_only = false;
+		properties.read_only = false;
 		break;
 	case CatalogType::VIEW_ENTRY:
 	case CatalogType::SEQUENCE_ENTRY:
@@ -162102,7 +162086,7 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 		}
 		if (!entry->temporary) {
 			// we can only drop temporary tables in read-only mode
-			this->read_only = false;
+			properties.read_only = false;
 		}
 		stmt.info->schema = entry->schema->name;
 		break;
@@ -162113,7 +162097,8 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_DROP, move(stmt.info));
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
-	this->allow_stream_result = false;
+	properties.allow_stream_result = false;
+	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
 
@@ -162137,6 +162122,7 @@ BoundStatement Binder::Bind(ExplainStatement &stmt) {
 	result.plan = move(explain);
 	result.names = {"explain_key", "explain_value"};
 	result.types = {LogicalType::VARCHAR, LogicalType::VARCHAR};
+	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;
 }
 
@@ -162340,7 +162326,8 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	}
 
 	result.plan = move(export_node);
-	this->allow_stream_result = false;
+	properties.allow_stream_result = false;
+	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
 
@@ -162408,7 +162395,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	D_ASSERT(table);
 	if (!table->temporary) {
 		// inserting into a non-temporary table: alters underlying database
-		this->read_only = false;
+		properties.read_only = false;
 	}
 
 	auto insert = make_unique<LogicalInsert>(table);
@@ -162514,7 +162501,8 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	} else {
 		D_ASSERT(result.types.size() == result.names.size());
 		result.plan = move(insert);
-		this->allow_stream_result = false;
+		properties.allow_stream_result = false;
+		properties.return_type = StatementReturnType::CHANGED_ROWS;
 		return result;
 	}
 }
@@ -162533,7 +162521,8 @@ BoundStatement Binder::Bind(LoadStatement &stmt) {
 	result.names = {"Success"};
 
 	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_LOAD, move(stmt.info));
-	this->allow_stream_result = false;
+	properties.allow_stream_result = false;
+	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
 
@@ -162569,6 +162558,7 @@ BoundStatement Binder::Bind(PragmaStatement &stmt) {
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
 	result.plan = make_unique<LogicalPragma>(bound_function, *stmt.info);
+	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;
 }
 
@@ -162594,7 +162584,8 @@ BoundStatement Binder::Bind(RelationStatement &stmt) {
 namespace duckdb {
 
 BoundStatement Binder::Bind(SelectStatement &stmt) {
-	this->allow_stream_result = true;
+	properties.allow_stream_result = true;
+	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return Bind(*stmt.node);
 }
 
@@ -162612,6 +162603,7 @@ BoundStatement Binder::Bind(SetStatement &stmt) {
 	result.names = {"Success"};
 
 	result.plan = make_unique<LogicalSet>(stmt.name, stmt.value, stmt.scope);
+	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
 
@@ -162641,6 +162633,7 @@ BoundStatement Binder::Bind(ShowStatement &stmt) {
 	result.names = {"column_name", "column_type", "null", "key", "default", "extra"};
 	result.types = {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR,
 	                LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR};
+	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;
 }
 
@@ -162666,20 +162659,22 @@ BoundStatement Binder::Bind(AlterStatement &stmt) {
 	auto entry = catalog.GetEntry(context, stmt.info->GetCatalogType(), stmt.info->schema, stmt.info->name, true);
 	if (entry && !entry->temporary) {
 		// we can only alter temporary tables/views in read-only mode
-		this->read_only = false;
+		properties.read_only = false;
 	}
 	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, move(stmt.info));
+	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
 
 BoundStatement Binder::Bind(TransactionStatement &stmt) {
 	// transaction statements do not require a valid transaction
-	this->requires_valid_transaction = false;
+	properties.requires_valid_transaction = false;
 
 	BoundStatement result;
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
 	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_TRANSACTION, move(stmt.info));
+	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
 
@@ -162814,6 +162809,7 @@ BoundStatement Binder::BindSummarize(ShowStatement &stmt) {
 	select_node->select_list.push_back(SummarizeWrapUnnest(null_percentage_children, "null_percentage"));
 	select_node->from_table = move(subquery_ref);
 
+	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return Bind(*select_node);
 }
 
@@ -163022,7 +163018,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 
 	if (!table->temporary) {
 		// update of persistent table: not read only!
-		this->read_only = false;
+		properties.read_only = false;
 	}
 	auto update = make_unique<LogicalUpdate>(table);
 
@@ -163103,7 +163099,8 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 		result.names = {"Count"};
 		result.types = {LogicalType::BIGINT};
 		result.plan = move(update);
-		this->allow_stream_result = false;
+		properties.allow_stream_result = false;
+		properties.return_type = StatementReturnType::CHANGED_ROWS;
 	}
 	return result;
 }
@@ -163120,6 +163117,7 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
 	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_VACUUM, move(stmt.info));
+	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
 
@@ -164413,8 +164411,7 @@ shared_ptr<Binder> Binder::CreateBinder(ClientContext &context, Binder *parent,
 }
 
 Binder::Binder(bool, ClientContext &context, shared_ptr<Binder> parent_p, bool inherit_ctes_p)
-    : context(context), read_only(true), requires_valid_transaction(true), allow_stream_result(false),
-      parent(move(parent_p)), bound_tables(0), inherit_ctes(inherit_ctes_p) {
+    : context(context), parent(move(parent_p)), bound_tables(0), inherit_ctes(inherit_ctes_p) {
 	parameters = nullptr;
 	parameter_types = nullptr;
 	if (parent) {
@@ -164815,7 +164812,8 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 	projection->AddChild(move(child_operator));
 	D_ASSERT(result.types.size() == result.names.size());
 	result.plan = move(projection);
-	this->allow_stream_result = true;
+	properties.allow_stream_result = true;
+	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;
 }
 
@@ -168234,19 +168232,17 @@ void Planner::CreatePlan(SQLStatement &statement) {
 	auto bound_statement = binder->Bind(statement);
 	profiler.EndPhase();
 
-	this->read_only = binder->read_only;
-	this->requires_valid_transaction = binder->requires_valid_transaction;
-	this->allow_stream_result = binder->allow_stream_result;
+	this->properties = binder->properties;
 	this->names = bound_statement.names;
 	this->types = bound_statement.types;
 	this->plan = move(bound_statement.plan);
-	this->bound_all_parameters = true;
+	properties.bound_all_parameters = true;
 
 	// set up a map of parameter number -> value entries
 	for (auto &expr : bound_parameters) {
 		// check if the type of the parameter could be resolved
 		if (expr->return_type.id() == LogicalTypeId::INVALID || expr->return_type.id() == LogicalTypeId::UNKNOWN) {
-			this->bound_all_parameters = false;
+			properties.bound_all_parameters = false;
 			continue;
 		}
 		auto value = make_unique<Value>(expr->return_type);
@@ -168274,11 +168270,8 @@ shared_ptr<PreparedStatementData> Planner::PrepareSQLStatement(unique_ptr<SQLSta
 	prepared_data->names = names;
 	prepared_data->types = types;
 	prepared_data->value_map = move(value_map);
-	prepared_data->read_only = this->read_only;
-	prepared_data->requires_valid_transaction = this->requires_valid_transaction;
-	prepared_data->allow_stream_result = this->allow_stream_result;
+	prepared_data->properties = properties;
 	prepared_data->catalog_version = Transaction::GetTransaction(context).catalog_version;
-	prepared_data->bound_all_parameters = this->bound_all_parameters;
 	return prepared_data;
 }
 
@@ -168308,7 +168301,7 @@ void Planner::PlanExecute(unique_ptr<SQLStatement> statement) {
 		Value value = ExpressionExecutor::EvaluateScalar(*bound_expr);
 		bind_values.push_back(move(value));
 	}
-	bool all_bound = prepared->bound_all_parameters;
+	bool all_bound = prepared->properties.bound_all_parameters;
 	if (catalog.GetCatalogVersion() != entry->second->catalog_version || !all_bound) {
 		// catalog was modified or statement does not have clear types: rebind the statement before running the execute
 		for (auto &value : bind_values) {
@@ -168319,7 +168312,7 @@ void Planner::PlanExecute(unique_ptr<SQLStatement> statement) {
 			throw BinderException("Rebinding statement \"%s\" after catalog change resulted in change of types",
 			                      stmt.name);
 		}
-		D_ASSERT(prepared->bound_all_parameters);
+		D_ASSERT(prepared->properties.bound_all_parameters);
 		rebound = true;
 	}
 	// add casts to the prepared statement parameters as required
@@ -168339,12 +168332,9 @@ void Planner::PlanExecute(unique_ptr<SQLStatement> statement) {
 	}
 
 	// copy the properties of the prepared statement into the planner
-	this->read_only = prepared->read_only;
-	this->requires_valid_transaction = prepared->requires_valid_transaction;
-	this->allow_stream_result = prepared->allow_stream_result;
+	this->properties = prepared->properties;
 	this->names = prepared->names;
 	this->types = prepared->types;
-	this->bound_all_parameters = prepared->bound_all_parameters;
 	this->plan = make_unique<LogicalExecute>(move(prepared));
 }
 
@@ -168354,12 +168344,13 @@ void Planner::PlanPrepare(unique_ptr<SQLStatement> statement) {
 
 	auto prepare = make_unique<LogicalPrepare>(stmt.name, move(prepared_data), move(plan));
 	// we can prepare in read-only mode: prepared statements are not written to the catalog
-	this->read_only = true;
+	properties.read_only = true;
 	// we can always prepare, even if the transaction has been invalidated
 	// this is required because most clients ALWAYS invoke prepared statements
-	this->requires_valid_transaction = false;
-	this->allow_stream_result = false;
-	this->bound_all_parameters = true;
+	properties.requires_valid_transaction = false;
+	properties.allow_stream_result = false;
+	properties.bound_all_parameters = true;
+	properties.return_type = StatementReturnType::NOTHING;
 	this->names = {"Success"};
 	this->types = {LogicalType::BOOLEAN};
 	this->plan = move(prepare);