duckdb 0.3.3-dev551.0 → 0.3.3-dev562.0

package/package.json

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

package/src/duckdb.cpp

@@ -104310,7 +104310,7 @@ class SelectStatement;
 
 class QueryRelation : public Relation {
 public:
-	QueryRelation(ClientContext &context, unique_ptr<SelectStatement> select_stmt, string alias);
+	QueryRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt, string alias);
 	~QueryRelation();
 
 	unique_ptr<SelectStatement> select_stmt;
@@ -104348,8 +104348,8 @@ namespace duckdb {
 
 class ReadCSVRelation : public Relation {
 public:
-	ReadCSVRelation(ClientContext &context, string csv_file, vector<ColumnDefinition> columns, bool auto_detect = false,
-	                string alias = string());
+	ReadCSVRelation(const std::shared_ptr<ClientContext> &context, string csv_file, vector<ColumnDefinition> columns,
+	                bool auto_detect = false, string alias = string());
 
 	string csv_file;
 	bool auto_detect;
@@ -104383,7 +104383,7 @@ namespace duckdb {
 
 class TableRelation : public Relation {
 public:
-	TableRelation(ClientContext &context, unique_ptr<TableDescription> description);
+	TableRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description);
 
 	unique_ptr<TableDescription> description;
 
@@ -104418,10 +104418,10 @@ namespace duckdb {
 
 class TableFunctionRelation : public Relation {
 public:
-	TableFunctionRelation(ClientContext &context, string name, vector<Value> parameters,
+	TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
 	                      named_parameter_map_t named_parameters, shared_ptr<Relation> input_relation_p = nullptr);
 
-	TableFunctionRelation(ClientContext &context, string name, vector<Value> parameters,
+	TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
 	                      shared_ptr<Relation> input_relation_p = nullptr);
 
 	string name;
@@ -104458,9 +104458,10 @@ namespace duckdb {
 
 class ValueRelation : public Relation {
 public:
-	ValueRelation(ClientContext &context, const vector<vector<Value>> &values, vector<string> names,
+	ValueRelation(const std::shared_ptr<ClientContext> &context, const vector<vector<Value>> &values,
+	              vector<string> names, string alias = "values");
+	ValueRelation(const std::shared_ptr<ClientContext> &context, const string &values, vector<string> names,
 	              string alias = "values");
-	ValueRelation(ClientContext &context, const string &values, vector<string> names, string alias = "values");
 
 	vector<vector<unique_ptr<ParsedExpression>>> expressions;
 	vector<string> names;
@@ -104495,7 +104496,7 @@ namespace duckdb {
 
 class ViewRelation : public Relation {
 public:
-	ViewRelation(ClientContext &context, string schema_name, string view_name);
+	ViewRelation(const std::shared_ptr<ClientContext> &context, string schema_name, string view_name);
 
 	string schema_name;
 	string view_name;
@@ -104690,7 +104691,7 @@ shared_ptr<Relation> Connection::Table(const string &schema_name, const string &
 	if (!table_info) {
 		throw Exception("Table does not exist!");
 	}
-	return make_shared<TableRelation>(*context, move(table_info));
+	return make_shared<TableRelation>(context, move(table_info));
 }
 
 shared_ptr<Relation> Connection::View(const string &tname) {
@@ -104698,7 +104699,7 @@ shared_ptr<Relation> Connection::View(const string &tname) {
 }
 
 shared_ptr<Relation> Connection::View(const string &schema_name, const string &table_name) {
-	return make_shared<ViewRelation>(*context, schema_name, table_name);
+	return make_shared<ViewRelation>(context, schema_name, table_name);
 }
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname) {
@@ -104709,11 +104710,11 @@ shared_ptr<Relation> Connection::TableFunction(const string &fname) {
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values,
                                                const named_parameter_map_t &named_parameters) {
-	return make_shared<TableFunctionRelation>(*context, fname, values, named_parameters);
+	return make_shared<TableFunctionRelation>(context, fname, values, named_parameters);
 }
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values) {
-	return make_shared<TableFunctionRelation>(*context, fname, values);
+	return make_shared<TableFunctionRelation>(context, fname, values);
 }
 
 shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values) {
@@ -104723,7 +104724,7 @@ shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values) {
 
 shared_ptr<Relation> Connection::Values(const vector<vector<Value>> &values, const vector<string> &column_names,
                                         const string &alias) {
-	return make_shared<ValueRelation>(*context, values, column_names, alias);
+	return make_shared<ValueRelation>(context, values, column_names, alias);
 }
 
 shared_ptr<Relation> Connection::Values(const string &values) {
@@ -104732,7 +104733,7 @@ shared_ptr<Relation> Connection::Values(const string &values) {
 }
 
 shared_ptr<Relation> Connection::Values(const string &values, const vector<string> &column_names, const string &alias) {
-	return make_shared<ValueRelation>(*context, values, column_names, alias);
+	return make_shared<ValueRelation>(context, values, column_names, alias);
 }
 
 shared_ptr<Relation> Connection::ReadCSV(const string &csv_file) {
@@ -104744,7 +104745,7 @@ shared_ptr<Relation> Connection::ReadCSV(const string &csv_file) {
 	for (idx_t i = 0; i < reader.sql_types.size(); i++) {
 		column_list.emplace_back(reader.col_names[i], reader.sql_types[i]);
 	}
-	return make_shared<ReadCSVRelation>(*context, csv_file, move(column_list), true);
+	return make_shared<ReadCSVRelation>(context, csv_file, move(column_list), true);
 }
 
 shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<string> &columns) {
@@ -104757,19 +104758,19 @@ shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<st
 		}
 		column_list.push_back(move(col_list[0]));
 	}
-	return make_shared<ReadCSVRelation>(*context, csv_file, move(column_list));
+	return make_shared<ReadCSVRelation>(context, csv_file, move(column_list));
 }
 
 unordered_set<string> Connection::GetTableNames(const string &query) {
 	return context->GetTableNames(query);
 }
 
-shared_ptr<Relation> Connection::RelationFromQuery(const string &query, string alias, const string &error) {
-	return RelationFromQuery(QueryRelation::ParseStatement(*context, query, error), move(alias));
+shared_ptr<Relation> Connection::RelationFromQuery(const string &query, const string &alias, const string &error) {
+	return RelationFromQuery(QueryRelation::ParseStatement(*context, query, error), alias);
 }
 
-shared_ptr<Relation> Connection::RelationFromQuery(unique_ptr<SelectStatement> select_stmt, string alias) {
-	return make_shared<QueryRelation>(*context, move(select_stmt), move(alias));
+shared_ptr<Relation> Connection::RelationFromQuery(unique_ptr<SelectStatement> select_stmt, const string &alias) {
+	return make_shared<QueryRelation>(context, move(select_stmt), alias);
 }
 
 void Connection::BeginTransaction() {
@@ -114987,7 +114988,7 @@ AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
     : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(move(parsed_expressions)),
       child(move(child_p)) {
 	// bind the expressions
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
@@ -114996,7 +114997,7 @@ AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
     : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(move(parsed_expressions)),
       groups(move(groups_p)), child(move(child_p)) {
 	// bind the expressions
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
@@ -115132,7 +115133,7 @@ namespace duckdb {
 CreateTableRelation::CreateTableRelation(shared_ptr<Relation> child_p, string schema_name, string table_name)
     : Relation(child_p->context, RelationType::CREATE_TABLE_RELATION), child(move(child_p)),
       schema_name(move(schema_name)), table_name(move(table_name)) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement CreateTableRelation::Bind(Binder &binder) {
@@ -115205,7 +115206,7 @@ CreateViewRelation::CreateViewRelation(shared_ptr<Relation> child_p, string view
                                        bool temporary_p)
     : Relation(child_p->context, RelationType::CREATE_VIEW_RELATION), child(move(child_p)),
       view_name(move(view_name_p)), replace(replace_p), temporary(temporary_p) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement CreateViewRelation::Bind(Binder &binder) {
@@ -115275,10 +115276,10 @@ namespace duckdb {
 
 CrossProductRelation::CrossProductRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p)
     : Relation(left_p->context, RelationType::CROSS_PRODUCT_RELATION), left(move(left_p)), right(move(right_p)) {
-	if (&left->context != &right->context) {
+	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> CrossProductRelation::GetQueryNode() {
@@ -115323,7 +115324,7 @@ namespace duckdb {
 
 class DeleteRelation : public Relation {
 public:
-	DeleteRelation(ClientContext &context, unique_ptr<ParsedExpression> condition, string schema_name,
+	DeleteRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition, string schema_name,
 	               string table_name);
 
 	vector<ColumnDefinition> columns;
@@ -115381,11 +115382,11 @@ public:
 
 namespace duckdb {
 
-DeleteRelation::DeleteRelation(ClientContext &context, unique_ptr<ParsedExpression> condition_p, string schema_name_p,
-                               string table_name_p)
+DeleteRelation::DeleteRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition_p,
+                               string schema_name_p, string table_name_p)
     : Relation(context, RelationType::DELETE_RELATION), condition(move(condition_p)), schema_name(move(schema_name_p)),
       table_name(move(table_name_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement DeleteRelation::Bind(Binder &binder) {
@@ -115458,7 +115459,7 @@ namespace duckdb {
 DistinctRelation::DistinctRelation(shared_ptr<Relation> child_p)
     : Relation(child_p->context, RelationType::DISTINCT_RELATION), child(move(child_p)) {
 	vector<ColumnDefinition> dummy_columns;
-	context.TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, dummy_columns);
 }
 
 unique_ptr<QueryNode> DistinctRelation::GetQueryNode() {
@@ -115524,7 +115525,7 @@ namespace duckdb {
 
 ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p)
     : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(move(child_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement ExplainRelation::Bind(Binder &binder) {
@@ -115656,7 +115657,7 @@ namespace duckdb {
 FilterRelation::FilterRelation(shared_ptr<Relation> child_p, unique_ptr<ParsedExpression> condition_p)
     : Relation(child_p->context, RelationType::FILTER_RELATION), condition(move(condition_p)), child(move(child_p)) {
 	vector<ColumnDefinition> dummy_columns;
-	context.TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, dummy_columns);
 }
 
 unique_ptr<QueryNode> FilterRelation::GetQueryNode() {
@@ -115781,7 +115782,7 @@ namespace duckdb {
 InsertRelation::InsertRelation(shared_ptr<Relation> child_p, string schema_name, string table_name)
     : Relation(child_p->context, RelationType::INSERT_RELATION), child(move(child_p)), schema_name(move(schema_name)),
       table_name(move(table_name)) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement InsertRelation::Bind(Binder &binder) {
@@ -115855,20 +115856,20 @@ JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> rig
                            unique_ptr<ParsedExpression> condition_p, JoinType type)
     : Relation(left_p->context, RelationType::JOIN_RELATION), left(move(left_p)), right(move(right_p)),
       condition(move(condition_p)), join_type(type) {
-	if (&left->context != &right->context) {
+	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p, vector<string> using_columns_p,
                            JoinType type)
     : Relation(left_p->context, RelationType::JOIN_RELATION), left(move(left_p)), right(move(right_p)),
       using_columns(move(using_columns_p)), join_type(type) {
-	if (&left->context != &right->context) {
+	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> JoinRelation::GetQueryNode() {
@@ -116035,7 +116036,7 @@ OrderRelation::OrderRelation(shared_ptr<Relation> child_p, vector<OrderByNode> o
     : Relation(child_p->context, RelationType::ORDER_RELATION), orders(move(orders)), child(move(child_p)) {
 	// bind the expressions
 	vector<ColumnDefinition> dummy_columns;
-	context.TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, dummy_columns);
 }
 
 unique_ptr<QueryNode> OrderRelation::GetQueryNode() {
@@ -116122,7 +116123,7 @@ ProjectionRelation::ProjectionRelation(shared_ptr<Relation> child_p,
 		}
 	}
 	// bind the expressions
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> ProjectionRelation::GetQueryNode() {
@@ -116179,9 +116180,10 @@ string ProjectionRelation::ToString(idx_t depth) {
 
 namespace duckdb {
 
-QueryRelation::QueryRelation(ClientContext &context, unique_ptr<SelectStatement> select_stmt_p, string alias_p)
+QueryRelation::QueryRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt_p,
+                             string alias_p)
     : Relation(context, RelationType::QUERY_RELATION), select_stmt(move(select_stmt_p)), alias(move(alias_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context->TryBindRelation(*this, this->columns);
 }
 
 QueryRelation::~QueryRelation() {
@@ -116240,8 +116242,8 @@ string QueryRelation::ToString(idx_t depth) {
 
 namespace duckdb {
 
-ReadCSVRelation::ReadCSVRelation(ClientContext &context, string csv_file_p, vector<ColumnDefinition> columns_p,
-                                 bool auto_detect, string alias_p)
+ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context, string csv_file_p,
+                                 vector<ColumnDefinition> columns_p, bool auto_detect, string alias_p)
     : Relation(context, RelationType::READ_CSV_RELATION), csv_file(move(csv_file_p)), auto_detect(auto_detect),
       alias(move(alias_p)), columns(move(columns_p)) {
 	if (alias.empty()) {
@@ -116334,11 +116336,11 @@ namespace duckdb {
 SetOpRelation::SetOpRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p, SetOperationType setop_type_p)
     : Relation(left_p->context, RelationType::SET_OPERATION_RELATION), left(move(left_p)), right(move(right_p)),
       setop_type(setop_type_p) {
-	if (&left->context != &right->context) {
+	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
 	vector<ColumnDefinition> dummy_columns;
-	context.TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, dummy_columns);
 }
 
 unique_ptr<QueryNode> SetOpRelation::GetQueryNode() {
@@ -116423,7 +116425,7 @@ namespace duckdb {
 SubqueryRelation::SubqueryRelation(shared_ptr<Relation> child_p, string alias_p)
     : Relation(child_p->context, RelationType::SUBQUERY_RELATION), child(move(child_p)), alias(move(alias_p)) {
 	vector<ColumnDefinition> dummy_columns;
-	context.TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, dummy_columns);
 }
 
 unique_ptr<QueryNode> SubqueryRelation::GetQueryNode() {
@@ -116457,19 +116459,20 @@ string SubqueryRelation::ToString(idx_t depth) {
 
 namespace duckdb {
 
-TableFunctionRelation::TableFunctionRelation(ClientContext &context, string name_p, vector<Value> parameters_p,
-                                             named_parameter_map_t named_parameters,
+TableFunctionRelation::TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name_p,
+                                             vector<Value> parameters_p, named_parameter_map_t named_parameters,
                                              shared_ptr<Relation> input_relation_p)
     : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(move(name_p)), parameters(move(parameters_p)),
       named_parameters(move(named_parameters)), input_relation(move(input_relation_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context->TryBindRelation(*this, this->columns);
 }
-TableFunctionRelation::TableFunctionRelation(ClientContext &context, string name_p, vector<Value> parameters_p,
+TableFunctionRelation::TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name_p,
+                                             vector<Value> parameters_p,
 
                                              shared_ptr<Relation> input_relation_p)
     : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(move(name_p)), parameters(move(parameters_p)),
       input_relation(move(input_relation_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> TableFunctionRelation::GetQueryNode() {
@@ -116552,7 +116555,7 @@ namespace duckdb {
 
 class UpdateRelation : public Relation {
 public:
-	UpdateRelation(ClientContext &context, unique_ptr<ParsedExpression> condition, string schema_name,
+	UpdateRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition, string schema_name,
 	               string table_name, vector<string> update_columns, vector<unique_ptr<ParsedExpression>> expressions);
 
 	vector<ColumnDefinition> columns;
@@ -116578,7 +116581,7 @@ public:
 
 namespace duckdb {
 
-TableRelation::TableRelation(ClientContext &context, unique_ptr<TableDescription> description)
+TableRelation::TableRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description)
     : Relation(context, RelationType::TABLE_RELATION), description(move(description)) {
 }
 
@@ -116623,15 +116626,15 @@ static unique_ptr<ParsedExpression> ParseCondition(ClientContext &context, const
 void TableRelation::Update(const string &update_list, const string &condition) {
 	vector<string> update_columns;
 	vector<unique_ptr<ParsedExpression>> expressions;
-	auto cond = ParseCondition(context, condition);
-	Parser::ParseUpdateList(update_list, update_columns, expressions, context.GetParserOptions());
+	auto cond = ParseCondition(*context.GetContext(), condition);
+	Parser::ParseUpdateList(update_list, update_columns, expressions, context.GetContext()->GetParserOptions());
 	auto update = make_shared<UpdateRelation>(context, move(cond), description->schema, description->table,
 	                                          move(update_columns), move(expressions));
 	update->Execute();
 }
 
 void TableRelation::Delete(const string &condition) {
-	auto cond = ParseCondition(context, condition);
+	auto cond = ParseCondition(*context.GetContext(), condition);
 	auto del = make_shared<DeleteRelation>(context, move(cond), description->schema, description->table);
 	del->Execute();
 }
@@ -116680,13 +116683,13 @@ public:
 
 namespace duckdb {
 
-UpdateRelation::UpdateRelation(ClientContext &context, unique_ptr<ParsedExpression> condition_p, string schema_name_p,
-                               string table_name_p, vector<string> update_columns_p,
+UpdateRelation::UpdateRelation(ClientContextWrapper &context, unique_ptr<ParsedExpression> condition_p,
+                               string schema_name_p, string table_name_p, vector<string> update_columns_p,
                                vector<unique_ptr<ParsedExpression>> expressions_p)
     : Relation(context, RelationType::UPDATE_RELATION), condition(move(condition_p)), schema_name(move(schema_name_p)),
       table_name(move(table_name_p)), update_columns(move(update_columns_p)), expressions(move(expressions_p)) {
 	D_ASSERT(update_columns.size() == expressions.size());
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement UpdateRelation::Bind(Binder &binder) {
@@ -116730,8 +116733,8 @@ string UpdateRelation::ToString(idx_t depth) {
 
 namespace duckdb {
 
-ValueRelation::ValueRelation(ClientContext &context, const vector<vector<Value>> &values, vector<string> names_p,
-                             string alias_p)
+ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, const vector<vector<Value>> &values,
+                             vector<string> names_p, string alias_p)
     : Relation(context, RelationType::VALUE_LIST_RELATION), names(move(names_p)), alias(move(alias_p)) {
 	// create constant expressions for the values
 	for (idx_t row_idx = 0; row_idx < values.size(); row_idx++) {
@@ -116742,13 +116745,14 @@ ValueRelation::ValueRelation(ClientContext &context, const vector<vector<Value>>
 		}
 		this->expressions.push_back(move(expressions));
 	}
-	context.TryBindRelation(*this, this->columns);
+	context->TryBindRelation(*this, this->columns);
 }
 
-ValueRelation::ValueRelation(ClientContext &context, const string &values_list, vector<string> names_p, string alias_p)
+ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, const string &values_list,
+                             vector<string> names_p, string alias_p)
     : Relation(context, RelationType::VALUE_LIST_RELATION), names(move(names_p)), alias(move(alias_p)) {
-	this->expressions = Parser::ParseValuesList(values_list, context.GetParserOptions());
-	context.TryBindRelation(*this, this->columns);
+	this->expressions = Parser::ParseValuesList(values_list, context->GetParserOptions());
+	context->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> ValueRelation::GetQueryNode() {
@@ -116819,9 +116823,9 @@ string ValueRelation::ToString(idx_t depth) {
 
 namespace duckdb {
 
-ViewRelation::ViewRelation(ClientContext &context, string schema_name_p, string view_name_p)
+ViewRelation::ViewRelation(const std::shared_ptr<ClientContext> &context, string schema_name_p, string view_name_p)
     : Relation(context, RelationType::VIEW_RELATION), schema_name(move(schema_name_p)), view_name(move(view_name_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> ViewRelation::GetQueryNode() {
@@ -116924,7 +116928,7 @@ namespace duckdb {
 
 WriteCSVRelation::WriteCSVRelation(shared_ptr<Relation> child_p, string csv_file_p)
     : Relation(child_p->context, RelationType::WRITE_CSV_RELATION), child(move(child_p)), csv_file(move(csv_file_p)) {
-	context.TryBindRelation(*this, this->columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement WriteCSVRelation::Bind(Binder &binder) {
@@ -116986,7 +116990,7 @@ shared_ptr<Relation> Relation::Project(const string &expression, const string &a
 }
 
 shared_ptr<Relation> Relation::Project(const string &select_list, const vector<string> &aliases) {
-	auto expressions = Parser::ParseExpressionList(select_list, context.GetParserOptions());
+	auto expressions = Parser::ParseExpressionList(select_list, context.GetContext()->GetParserOptions());
 	return make_shared<ProjectionRelation>(shared_from_this(), move(expressions), aliases);
 }
 
@@ -117012,12 +117016,12 @@ static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(ClientCon
 }
 
 shared_ptr<Relation> Relation::Project(const vector<string> &expressions, const vector<string> &aliases) {
-	auto result_list = StringListToExpressionList(context, expressions);
+	auto result_list = StringListToExpressionList(*context.GetContext(), expressions);
 	return make_shared<ProjectionRelation>(shared_from_this(), move(result_list), aliases);
 }
 
 shared_ptr<Relation> Relation::Filter(const string &expression) {
-	auto expression_list = Parser::ParseExpressionList(expression, context.GetParserOptions());
+	auto expression_list = Parser::ParseExpressionList(expression, context.GetContext()->GetParserOptions());
 	if (expression_list.size() != 1) {
 		throw ParserException("Expected a single expression as filter condition");
 	}
@@ -117026,7 +117030,7 @@ shared_ptr<Relation> Relation::Filter(const string &expression) {
 
 shared_ptr<Relation> Relation::Filter(const vector<string> &expressions) {
 	// if there are multiple expressions, we AND them together
-	auto expression_list = StringListToExpressionList(context, expressions);
+	auto expression_list = StringListToExpressionList(*context.GetContext(), expressions);
 	D_ASSERT(!expression_list.empty());
 
 	auto expr = move(expression_list[0]);
@@ -117042,7 +117046,7 @@ shared_ptr<Relation> Relation::Limit(int64_t limit, int64_t offset) {
 }
 
 shared_ptr<Relation> Relation::Order(const string &expression) {
-	auto order_list = Parser::ParseOrderList(expression, context.GetParserOptions());
+	auto order_list = Parser::ParseOrderList(expression, context.GetContext()->GetParserOptions());
 	return make_shared<OrderRelation>(shared_from_this(), move(order_list));
 }
 
@@ -117052,7 +117056,7 @@ shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
 	}
 	vector<OrderByNode> order_list;
 	for (auto &expression : expressions) {
-		auto inner_list = Parser::ParseOrderList(expression, context.GetParserOptions());
+		auto inner_list = Parser::ParseOrderList(expression, context.GetContext()->GetParserOptions());
 		if (inner_list.size() != 1) {
 			throw ParserException("Expected a single ORDER BY expression in the expression list");
 		}
@@ -117062,7 +117066,7 @@ shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
 }
 
 shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const string &condition, JoinType type) {
-	auto expression_list = Parser::ParseExpressionList(condition, context.GetParserOptions());
+	auto expression_list = Parser::ParseExpressionList(condition, context.GetContext()->GetParserOptions());
 	D_ASSERT(!expression_list.empty());
 
 	if (expression_list.size() > 1 || expression_list[0]->type == ExpressionType::COLUMN_REF) {
@@ -117110,24 +117114,24 @@ shared_ptr<Relation> Relation::Alias(const string &alias) {
 }
 
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetParserOptions());
+	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetContext()->GetParserOptions());
 	return make_shared<AggregateRelation>(shared_from_this(), move(expression_list));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list, const string &group_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetParserOptions());
-	auto groups = Parser::ParseExpressionList(group_list, context.GetParserOptions());
+	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetContext()->GetParserOptions());
+	auto groups = Parser::ParseExpressionList(group_list, context.GetContext()->GetParserOptions());
 	return make_shared<AggregateRelation>(shared_from_this(), move(expression_list), move(groups));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates) {
-	auto aggregate_list = StringListToExpressionList(context, aggregates);
+	auto aggregate_list = StringListToExpressionList(*context.GetContext(), aggregates);
 	return make_shared<AggregateRelation>(shared_from_this(), move(aggregate_list));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const vector<string> &groups) {
-	auto aggregate_list = StringListToExpressionList(context, aggregates);
-	auto group_list = StringListToExpressionList(context, groups);
+	auto aggregate_list = StringListToExpressionList(*context.GetContext(), aggregates);
+	auto group_list = StringListToExpressionList(*context.GetContext(), groups);
 	return make_shared<AggregateRelation>(shared_from_this(), move(aggregate_list), move(group_list));
 }
 
@@ -117142,7 +117146,7 @@ unique_ptr<TableRef> Relation::GetTableRef() {
 }
 
 unique_ptr<QueryResult> Relation::Execute() {
-	return context.Execute(shared_from_this());
+	return context.GetContext()->Execute(shared_from_this());
 }
 
 BoundStatement Relation::Bind(Binder &binder) {
@@ -117165,7 +117169,7 @@ void Relation::Insert(const string &schema_name, const string &table_name) {
 
 void Relation::Insert(const vector<vector<Value>> &values) {
 	vector<string> column_names;
-	auto rel = make_shared<ValueRelation>(context, values, move(column_names), "values");
+	auto rel = make_shared<ValueRelation>(context.GetContext(), values, move(column_names), "values");
 	rel->Insert(GetAlias());
 }
 
@@ -117199,7 +117203,7 @@ shared_ptr<Relation> Relation::CreateView(const string &name, bool replace, bool
 }
 
 unique_ptr<QueryResult> Relation::Query(const string &sql) {
-	return context.Query(sql, false);
+	return context.GetContext()->Query(sql, false);
 }
 
 unique_ptr<QueryResult> Relation::Query(const string &name, const string &sql) {
@@ -117222,11 +117226,12 @@ void Relation::Delete(const string &condition) {
 
 shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values,
                                              const named_parameter_map_t &named_parameters) {
-	return make_shared<TableFunctionRelation>(context, fname, values, named_parameters, shared_from_this());
+	return make_shared<TableFunctionRelation>(context.GetContext(), fname, values, named_parameters,
+	                                          shared_from_this());
 }
 
 shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values) {
-	return make_shared<TableFunctionRelation>(context, fname, values, shared_from_this());
+	return make_shared<TableFunctionRelation>(context.GetContext(), fname, values, shared_from_this());
 }
 
 string Relation::ToString() {