duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

package/src/duckdb/src/main/query_result.cpp

@@ -2,18 +2,19 @@
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/common/box_renderer.hpp"
 
 namespace duckdb {
 
 BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties_p,
                                  vector<LogicalType> types_p, vector<string> names_p)
-    : type(type), statement_type(statement_type), properties(move(properties_p)), types(move(types_p)),
-      names(move(names_p)), success(true) {
+    : type(type), statement_type(statement_type), properties(std::move(properties_p)), types(std::move(types_p)),
+      names(std::move(names_p)), success(true) {
 	D_ASSERT(types.size() == names.size());
 }
 
 BaseQueryResult::BaseQueryResult(QueryResultType type, PreservedError error)
-    : type(type), success(false), error(move(error)) {
+    : type(type), success(false), error(std::move(error)) {
 }
 
 BaseQueryResult::~BaseQueryResult() {
@@ -26,7 +27,7 @@ void BaseQueryResult::ThrowError(const string &prepended_message) const {
 
 void BaseQueryResult::SetError(PreservedError error) {
 	success = !error;
-	this->error = move(error);
+	this->error = std::move(error);
 }
 
 bool BaseQueryResult::HasError() const {
@@ -53,11 +54,11 @@ idx_t BaseQueryResult::ColumnCount() {
 
 QueryResult::QueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties,
                          vector<LogicalType> types_p, vector<string> names_p, ClientProperties client_properties_p)
-    : BaseQueryResult(type, statement_type, move(properties), move(types_p), move(names_p)),
-      client_properties(move(client_properties_p)) {
+    : BaseQueryResult(type, statement_type, std::move(properties), std::move(types_p), std::move(names_p)),
+      client_properties(std::move(client_properties_p)) {
 }
 
-QueryResult::QueryResult(QueryResultType type, PreservedError error) : BaseQueryResult(type, move(error)) {
+QueryResult::QueryResult(QueryResultType type, PreservedError error) : BaseQueryResult(type, std::move(error)) {
 }
 
 QueryResult::~QueryResult() {
@@ -68,6 +69,10 @@ const string &QueryResult::ColumnName(idx_t index) const {
 	return names[index];
 }
 
+string QueryResult::ToBox(ClientContext &context, const BoxRendererConfig &config) {
+	return ToString();
+}
+
 unique_ptr<DataChunk> QueryResult::Fetch() {
 	auto chunk = FetchRaw();
 	if (!chunk) {

package/src/duckdb/src/main/relation/aggregate_relation.cpp

@@ -7,8 +7,8 @@ namespace duckdb {
 
 AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
                                      vector<unique_ptr<ParsedExpression>> parsed_expressions)
-    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(move(parsed_expressions)),
-      child(move(child_p)) {
+    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
+      child(std::move(child_p)) {
 	// bind the expressions
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
@@ -16,8 +16,8 @@ AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
 AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
                                      vector<unique_ptr<ParsedExpression>> parsed_expressions,
                                      vector<unique_ptr<ParsedExpression>> groups_p)
-    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(move(parsed_expressions)),
-      groups(move(groups_p)), child(move(child_p)) {
+    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
+      groups(std::move(groups_p)), child(std::move(child_p)) {
 	// bind the expressions
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
@@ -35,7 +35,7 @@ unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
 		// child node is not a join: create a new select node and push the child as a table reference
 		auto select = make_unique<SelectNode>();
 		select->from_table = child->GetTableRef();
-		result = move(select);
+		result = std::move(select);
 	}
 	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
 	auto &select_node = (SelectNode &)*result;
@@ -48,7 +48,7 @@ unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
 			select_node.groups.group_expressions.push_back(groups[i]->Copy());
 			grouping_set.insert(i);
 		}
-		select_node.groups.grouping_sets.push_back(move(grouping_set));
+		select_node.groups.grouping_sets.push_back(std::move(grouping_set));
 	} else {
 		// no groups provided: automatically figure out groups (if any)
 		select_node.aggregate_handling = AggregateHandling::FORCE_AGGREGATES;

package/src/duckdb/src/main/relation/create_table_relation.cpp

@@ -7,8 +7,8 @@
 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)) {
+    : Relation(child_p->context, RelationType::CREATE_TABLE_RELATION), child(std::move(child_p)),
+      schema_name(std::move(schema_name)), table_name(std::move(table_name)) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
@@ -20,9 +20,9 @@ BoundStatement CreateTableRelation::Bind(Binder &binder) {
 	auto info = make_unique<CreateTableInfo>();
 	info->schema = schema_name;
 	info->table = table_name;
-	info->query = move(select);
+	info->query = std::move(select);
 	info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
-	stmt.info = move(info);
+	stmt.info = std::move(info);
 	return binder.Bind((SQLStatement &)stmt);
 }
 

package/src/duckdb/src/main/relation/create_view_relation.cpp

@@ -7,15 +7,16 @@ namespace duckdb {
 
 CreateViewRelation::CreateViewRelation(shared_ptr<Relation> child_p, string view_name_p, bool replace_p,
                                        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) {
+    : Relation(child_p->context, RelationType::CREATE_VIEW_RELATION), child(std::move(child_p)),
+      view_name(std::move(view_name_p)), replace(replace_p), temporary(temporary_p) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 CreateViewRelation::CreateViewRelation(shared_ptr<Relation> child_p, string schema_name_p, string view_name_p,
                                        bool replace_p, bool temporary_p)
-    : Relation(child_p->context, RelationType::CREATE_VIEW_RELATION), child(move(child_p)),
-      schema_name(move(schema_name_p)), view_name(move(view_name_p)), replace(replace_p), temporary(temporary_p) {
+    : Relation(child_p->context, RelationType::CREATE_VIEW_RELATION), child(std::move(child_p)),
+      schema_name(std::move(schema_name_p)), view_name(std::move(view_name_p)), replace(replace_p),
+      temporary(temporary_p) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
@@ -25,12 +26,12 @@ BoundStatement CreateViewRelation::Bind(Binder &binder) {
 
 	CreateStatement stmt;
 	auto info = make_unique<CreateViewInfo>();
-	info->query = move(select);
+	info->query = std::move(select);
 	info->view_name = view_name;
 	info->temporary = temporary;
 	info->schema = schema_name;
 	info->on_conflict = replace ? OnCreateConflict::REPLACE_ON_CONFLICT : OnCreateConflict::ERROR_ON_CONFLICT;
-	stmt.info = move(info);
+	stmt.info = std::move(info);
 	return binder.Bind((SQLStatement &)stmt);
 }
 

package/src/duckdb/src/main/relation/cross_product_relation.cpp

@@ -2,12 +2,13 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/tableref/crossproductref.hpp"
+#include "duckdb/parser/tableref/joinref.hpp"
 
 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)) {
+    : Relation(left_p->context, RelationType::CROSS_PRODUCT_RELATION), left(std::move(left_p)),
+      right(std::move(right_p)) {
 	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
@@ -18,14 +19,14 @@ unique_ptr<QueryNode> CrossProductRelation::GetQueryNode() {
 	auto result = make_unique<SelectNode>();
 	result->select_list.push_back(make_unique<StarExpression>());
 	result->from_table = GetTableRef();
-	return move(result);
+	return std::move(result);
 }
 
 unique_ptr<TableRef> CrossProductRelation::GetTableRef() {
-	auto cross_product_ref = make_unique<CrossProductRef>();
+	auto cross_product_ref = make_unique<JoinRef>(JoinRefType::CROSS);
 	cross_product_ref->left = left->GetTableRef();
 	cross_product_ref->right = right->GetTableRef();
-	return move(cross_product_ref);
+	return std::move(cross_product_ref);
 }
 
 const vector<ColumnDefinition> &CrossProductRelation::Columns() {

package/src/duckdb/src/main/relation/delete_relation.cpp

@@ -8,8 +8,8 @@ namespace duckdb {
 
 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)) {
+    : Relation(context, RelationType::DELETE_RELATION), condition(std::move(condition_p)),
+      schema_name(std::move(schema_name_p)), table_name(std::move(table_name_p)) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
@@ -20,7 +20,7 @@ BoundStatement DeleteRelation::Bind(Binder &binder) {
 
 	DeleteStatement stmt;
 	stmt.condition = condition ? condition->Copy() : nullptr;
-	stmt.table = move(basetable);
+	stmt.table = std::move(basetable);
 	return binder.Bind((SQLStatement &)stmt);
 }
 

package/src/duckdb/src/main/relation/distinct_relation.cpp

@@ -5,7 +5,7 @@
 namespace duckdb {
 
 DistinctRelation::DistinctRelation(shared_ptr<Relation> child_p)
-    : Relation(child_p->context, RelationType::DISTINCT_RELATION), child(move(child_p)) {
+    : Relation(child_p->context, RelationType::DISTINCT_RELATION), child(std::move(child_p)) {
 	D_ASSERT(child.get() != this);
 	vector<ColumnDefinition> dummy_columns;
 	context.GetContext()->TryBindRelation(*this, dummy_columns);

package/src/duckdb/src/main/relation/explain_relation.cpp

@@ -8,14 +8,14 @@
 namespace duckdb {
 
 ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p)
-    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(move(child_p)) {
+    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement ExplainRelation::Bind(Binder &binder) {
 	auto select = make_unique<SelectStatement>();
 	select->node = child->GetQueryNode();
-	ExplainStatement explain(move(select));
+	ExplainStatement explain(std::move(select));
 	return binder.Bind((SQLStatement &)explain);
 }
 

package/src/duckdb/src/main/relation/filter_relation.cpp

@@ -8,7 +8,8 @@
 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)) {
+    : Relation(child_p->context, RelationType::FILTER_RELATION), condition(std::move(condition_p)),
+      child(std::move(child_p)) {
 	D_ASSERT(child.get() != this);
 	vector<ColumnDefinition> dummy_columns;
 	context.GetContext()->TryBindRelation(*this, dummy_columns);
@@ -28,7 +29,7 @@ unique_ptr<QueryNode> FilterRelation::GetQueryNode() {
 			select_node.where_clause = condition->Copy();
 		} else {
 			select_node.where_clause = make_unique<ConjunctionExpression>(
-			    ExpressionType::CONJUNCTION_AND, move(select_node.where_clause), condition->Copy());
+			    ExpressionType::CONJUNCTION_AND, std::move(select_node.where_clause), condition->Copy());
 		}
 		return child_node;
 	} else {
@@ -36,7 +37,7 @@ unique_ptr<QueryNode> FilterRelation::GetQueryNode() {
 		result->select_list.push_back(make_unique<StarExpression>());
 		result->from_table = child->GetTableRef();
 		result->where_clause = condition->Copy();
-		return move(result);
+		return std::move(result);
 	}
 }
 

package/src/duckdb/src/main/relation/insert_relation.cpp

@@ -8,8 +8,8 @@
 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)) {
+    : Relation(child_p->context, RelationType::INSERT_RELATION), child(std::move(child_p)),
+      schema_name(std::move(schema_name)), table_name(std::move(table_name)) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
@@ -20,7 +20,7 @@ BoundStatement InsertRelation::Bind(Binder &binder) {
 
 	stmt.schema = schema_name;
 	stmt.table = table_name;
-	stmt.select_statement = move(select);
+	stmt.select_statement = std::move(select);
 	return binder.Bind((SQLStatement &)stmt);
 }
 

package/src/duckdb/src/main/relation/join_relation.cpp

@@ -8,8 +8,8 @@ namespace duckdb {
 
 JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p,
                            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) {
+    : Relation(left_p->context, RelationType::JOIN_RELATION), left(std::move(left_p)), right(std::move(right_p)),
+      condition(std::move(condition_p)), join_type(type) {
 	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
@@ -18,8 +18,8 @@ JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> rig
 
 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) {
+    : Relation(left_p->context, RelationType::JOIN_RELATION), left(std::move(left_p)), right(std::move(right_p)),
+      using_columns(std::move(using_columns_p)), join_type(type) {
 	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
@@ -30,11 +30,11 @@ unique_ptr<QueryNode> JoinRelation::GetQueryNode() {
 	auto result = make_unique<SelectNode>();
 	result->select_list.push_back(make_unique<StarExpression>());
 	result->from_table = GetTableRef();
-	return move(result);
+	return std::move(result);
 }
 
 unique_ptr<TableRef> JoinRelation::GetTableRef() {
-	auto join_ref = make_unique<JoinRef>();
+	auto join_ref = make_unique<JoinRef>(JoinRefType::REGULAR);
 	join_ref->left = left->GetTableRef();
 	join_ref->right = right->GetTableRef();
 	if (condition) {
@@ -42,7 +42,7 @@ unique_ptr<TableRef> JoinRelation::GetTableRef() {
 	}
 	join_ref->using_columns = using_columns;
 	join_ref->type = join_type;
-	return move(join_ref);
+	return std::move(join_ref);
 }
 
 const vector<ColumnDefinition> &JoinRelation::Columns() {

package/src/duckdb/src/main/relation/limit_relation.cpp

@@ -8,7 +8,7 @@ namespace duckdb {
 
 LimitRelation::LimitRelation(shared_ptr<Relation> child_p, int64_t limit, int64_t offset)
     : Relation(child_p->context, RelationType::PROJECTION_RELATION), limit(limit), offset(offset),
-      child(move(child_p)) {
+      child(std::move(child_p)) {
 	D_ASSERT(child.get() != this);
 }
 
@@ -22,7 +22,7 @@ unique_ptr<QueryNode> LimitRelation::GetQueryNode() {
 		limit_node->offset = make_unique<ConstantExpression>(Value::BIGINT(offset));
 	}
 
-	child_node->modifiers.push_back(move(limit_node));
+	child_node->modifiers.push_back(std::move(limit_node));
 	return child_node;
 }
 

package/src/duckdb/src/main/relation/order_relation.cpp

@@ -7,7 +7,7 @@
 namespace duckdb {
 
 OrderRelation::OrderRelation(shared_ptr<Relation> child_p, vector<OrderByNode> orders)
-    : Relation(child_p->context, RelationType::ORDER_RELATION), orders(move(orders)), child(move(child_p)) {
+    : Relation(child_p->context, RelationType::ORDER_RELATION), orders(std::move(orders)), child(std::move(child_p)) {
 	D_ASSERT(child.get() != this);
 	// bind the expressions
 	context.GetContext()->TryBindRelation(*this, this->columns);
@@ -21,8 +21,8 @@ unique_ptr<QueryNode> OrderRelation::GetQueryNode() {
 	for (idx_t i = 0; i < orders.size(); i++) {
 		order_node->orders.emplace_back(orders[i].type, orders[i].null_order, orders[i].expression->Copy());
 	}
-	select->modifiers.push_back(move(order_node));
-	return move(select);
+	select->modifiers.push_back(std::move(order_node));
+	return std::move(select);
 }
 
 string OrderRelation::GetAlias() {

package/src/duckdb/src/main/relation/projection_relation.cpp

@@ -7,8 +7,8 @@ namespace duckdb {
 
 ProjectionRelation::ProjectionRelation(shared_ptr<Relation> child_p,
                                        vector<unique_ptr<ParsedExpression>> parsed_expressions, vector<string> aliases)
-    : Relation(child_p->context, RelationType::PROJECTION_RELATION), expressions(move(parsed_expressions)),
-      child(move(child_p)) {
+    : Relation(child_p->context, RelationType::PROJECTION_RELATION), expressions(std::move(parsed_expressions)),
+      child(std::move(child_p)) {
 	if (!aliases.empty()) {
 		if (aliases.size() != expressions.size()) {
 			throw ParserException("Aliases list length must match expression list length!");
@@ -34,7 +34,7 @@ unique_ptr<QueryNode> ProjectionRelation::GetQueryNode() {
 		// child node is not a join: create a new select node and push the child as a table reference
 		auto select = make_unique<SelectNode>();
 		select->from_table = child->GetTableRef();
-		result = move(select);
+		result = std::move(select);
 	}
 	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
 	auto &select_node = (SelectNode &)*result;

package/src/duckdb/src/main/relation/query_relation.cpp

@@ -8,7 +8,8 @@ namespace duckdb {
 
 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)) {
+    : Relation(context, RelationType::QUERY_RELATION), select_stmt(std::move(select_stmt_p)),
+      alias(std::move(alias_p)) {
 	context->TryBindRelation(*this, this->columns);
 }
 
@@ -25,7 +26,7 @@ unique_ptr<SelectStatement> QueryRelation::ParseStatement(ClientContext &context
 	if (parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
 		throw ParserException(error);
 	}
-	return unique_ptr_cast<SQLStatement, SelectStatement>(move(parser.statements[0]));
+	return unique_ptr_cast<SQLStatement, SelectStatement>(std::move(parser.statements[0]));
 }
 
 unique_ptr<SelectStatement> QueryRelation::GetSelectStatement() {
@@ -34,12 +35,12 @@ unique_ptr<SelectStatement> QueryRelation::GetSelectStatement() {
 
 unique_ptr<QueryNode> QueryRelation::GetQueryNode() {
 	auto select = GetSelectStatement();
-	return move(select->node);
+	return std::move(select->node);
 }
 
 unique_ptr<TableRef> QueryRelation::GetTableRef() {
 	auto subquery_ref = make_unique<SubqueryRef>(GetSelectStatement(), GetAlias());
-	return move(subquery_ref);
+	return std::move(subquery_ref);
 }
 
 string QueryRelation::GetAlias() {

package/src/duckdb/src/main/relation/read_csv_relation.cpp

@@ -8,59 +8,51 @@
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/execution/operator/persistent/buffered_csv_reader.hpp"
 
 namespace duckdb {
 
-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)) {
+ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
+                                 vector<ColumnDefinition> columns_p, string alias_p)
+    : TableFunctionRelation(context, "read_csv", {Value(csv_file)}, nullptr, false), alias(std::move(alias_p)),
+      auto_detect(false) {
+
 	if (alias.empty()) {
 		alias = StringUtil::Split(csv_file, ".")[0];
 	}
-}
 
-unique_ptr<QueryNode> ReadCSVRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
-	result->from_table = GetTableRef();
-	return move(result);
-}
+	columns = std::move(columns_p);
 
-unique_ptr<TableRef> ReadCSVRelation::GetTableRef() {
-	auto table_ref = make_unique<TableFunctionRef>();
-	table_ref->alias = alias;
-	vector<unique_ptr<ParsedExpression>> children;
-	// CSV file
-	children.push_back(make_unique<ConstantExpression>(Value(csv_file)));
-	if (!auto_detect) {
-		// parameters
-		child_list_t<Value> column_names;
-		for (idx_t i = 0; i < columns.size(); i++) {
-			column_names.push_back(make_pair(columns[i].Name(), Value(columns[i].Type().ToString())));
-		}
-		auto colnames = make_unique<ConstantExpression>(Value::STRUCT(move(column_names)));
-		children.push_back(make_unique<ComparisonExpression>(
-		    ExpressionType::COMPARE_EQUAL, make_unique<ColumnRefExpression>("columns"), move(colnames)));
-	} else {
-		children.push_back(make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL,
-		                                                     make_unique<ColumnRefExpression>("auto_detect"),
-		                                                     make_unique<ConstantExpression>(Value::BOOLEAN(true))));
+	child_list_t<Value> column_names;
+	for (idx_t i = 0; i < columns.size(); i++) {
+		column_names.push_back(make_pair(columns[i].Name(), Value(columns[i].Type().ToString())));
 	}
-	table_ref->function = make_unique<FunctionExpression>("read_csv", move(children));
-	return move(table_ref);
-}
 
-string ReadCSVRelation::GetAlias() {
-	return alias;
+	AddNamedParameter("columns", Value::STRUCT(std::move(column_names)));
 }
 
-const vector<ColumnDefinition> &ReadCSVRelation::Columns() {
-	return columns;
+ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
+                                 BufferedCSVReaderOptions options, string alias_p)
+    : TableFunctionRelation(context, "read_csv_auto", {Value(csv_file)}, nullptr, false), alias(std::move(alias_p)),
+      auto_detect(true) {
+
+	if (alias.empty()) {
+		alias = StringUtil::Split(csv_file, ".")[0];
+	}
+
+	// Force auto_detect for this constructor
+	options.auto_detect = true;
+	BufferedCSVReader reader(*context, std::move(options));
+
+	for (idx_t i = 0; i < reader.return_types.size(); i++) {
+		columns.emplace_back(reader.names[i], reader.return_types[i]);
+	}
+
+	AddNamedParameter("auto_detect", Value::BOOLEAN(true));
 }
 
-string ReadCSVRelation::ToString(idx_t depth) {
-	return RenderWhitespace(depth) + "Read CSV [" + csv_file + "]";
+string ReadCSVRelation::GetAlias() {
+	return alias;
 }
 
 } // namespace duckdb

package/src/duckdb/src/main/relation/read_json_relation.cpp

@@ -0,0 +1,20 @@
+#include "duckdb/main/relation/read_json_relation.hpp"
+#include "duckdb/parser/column_definition.hpp"
+namespace duckdb {
+
+ReadJSONRelation::ReadJSONRelation(const shared_ptr<ClientContext> &context, string json_file_p,
+                                   named_parameter_map_t options, bool auto_detect, string alias_p)
+    : TableFunctionRelation(context, auto_detect ? "read_json_auto" : "read_json", {Value(json_file_p)},
+                            std::move(options)),
+      json_file(std::move(json_file_p)), alias(std::move(alias_p)) {
+
+	if (alias.empty()) {
+		alias = StringUtil::Split(json_file, ".")[0];
+	}
+}
+
+string ReadJSONRelation::GetAlias() {
+	return alias;
+}
+
+} // namespace duckdb

package/src/duckdb/src/main/relation/setop_relation.cpp

@@ -6,8 +6,8 @@
 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) {
+    : Relation(left_p->context, RelationType::SET_OPERATION_RELATION), left(std::move(left_p)),
+      right(std::move(right_p)), setop_type(setop_type_p) {
 	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
@@ -23,7 +23,7 @@ unique_ptr<QueryNode> SetOpRelation::GetQueryNode() {
 	result->left = left->GetQueryNode();
 	result->right = right->GetQueryNode();
 	result->setop_type = setop_type;
-	return move(result);
+	return std::move(result);
 }
 
 string SetOpRelation::GetAlias() {

package/src/duckdb/src/main/relation/subquery_relation.cpp

@@ -5,7 +5,8 @@
 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)) {
+    : Relation(child_p->context, RelationType::SUBQUERY_RELATION), child(std::move(child_p)),
+      alias(std::move(alias_p)) {
 	D_ASSERT(child.get() != this);
 	vector<ColumnDefinition> dummy_columns;
 	context.GetContext()->TryBindRelation(*this, dummy_columns);