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

package/src/duckdb/src/include/duckdb/function/scalar/math_functions.hpp

@@ -110,6 +110,10 @@ struct IsNanFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct SignBitFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct IsInfiniteFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

package/src/duckdb/src/include/duckdb/function/scalar/nested_functions.hpp

@@ -23,7 +23,7 @@ enum class UnionInvalidReason : uint8_t { VALID, TAG_OUT_OF_RANGE, NO_MEMBERS, V
 struct VariableReturnBindData : public FunctionData {
 	LogicalType stype;
 
-	explicit VariableReturnBindData(LogicalType stype_p) : stype(move(stype_p)) {
+	explicit VariableReturnBindData(LogicalType stype_p) : stype(std::move(stype_p)) {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
@@ -43,7 +43,7 @@ struct VariableReturnBindData : public FunctionData {
 	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
 	                                            ScalarFunction &bound_function) {
 		auto stype = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-		return make_unique<VariableReturnBindData>(move(stype));
+		return make_unique<VariableReturnBindData>(std::move(stype));
 	}
 };
 

package/src/duckdb/src/include/duckdb/function/scalar/strftime.hpp

@@ -112,7 +112,8 @@ protected:
 	char *WritePadded(char *target, uint32_t value, size_t padding);
 	bool IsDateSpecifier(StrTimeSpecifier specifier);
 	char *WriteDateSpecifier(StrTimeSpecifier specifier, date_t date, char *target);
-	char *WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], const char *tz_name, char *target);
+	char *WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], const char *tz_name, size_t tz_len,
+	                             char *target);
 };
 
 struct StrpTimeFormat : public StrTimeFormat {
@@ -138,8 +139,8 @@ public:
 
 	DUCKDB_API bool Parse(string_t str, ParseResult &result);
 
-	bool TryParseDate(string_t str, date_t &result, string &error_message);
-	bool TryParseTimestamp(string_t str, timestamp_t &result, string &error_message);
+	DUCKDB_API bool TryParseDate(string_t str, date_t &result, string &error_message);
+	DUCKDB_API bool TryParseTimestamp(string_t str, timestamp_t &result, string &error_message);
 
 	date_t ParseDate(string_t str);
 	timestamp_t ParseTimestamp(string_t str);

package/src/duckdb/src/include/duckdb/function/scalar/string_functions.hpp

@@ -184,6 +184,10 @@ struct StringSplitFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct BarFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct ASCII {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

package/src/duckdb/src/include/duckdb/function/scalar_function.hpp

@@ -110,6 +110,13 @@ public:
 		BinaryExecutor::ExecuteStandard<TA, TB, TR, OP>(input.data[0], input.data[1], result, input.size());
 	}
 
+	template <class TA, class TB, class TC, class TR, class OP>
+	static void TernaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+		D_ASSERT(input.ColumnCount() == 3);
+		TernaryExecutor::ExecuteStandard<TA, TB, TC, TR, OP>(input.data[0], input.data[1], input.data[2], result,
+		                                                     input.size());
+	}
+
 public:
 	template <class OP>
 	static scalar_function_t GetScalarUnaryFunction(LogicalType type) {

package/src/duckdb/src/include/duckdb/function/table/arrow.hpp

@@ -78,7 +78,7 @@ struct ArrowScanFunctionData : public PyTableFunctionData {
 };
 
 struct ArrowScanLocalState : public LocalTableFunctionState {
-	explicit ArrowScanLocalState(unique_ptr<ArrowArrayWrapper> current_chunk) : chunk(move(current_chunk)) {
+	explicit ArrowScanLocalState(unique_ptr<ArrowArrayWrapper> current_chunk) : chunk(std::move(current_chunk)) {
 	}
 
 	unique_ptr<ArrowArrayStreamWrapper> stream;

package/src/duckdb/src/include/duckdb/function/table/read_csv.hpp

@@ -21,7 +21,8 @@ namespace duckdb {
 
 class ReadCSV {
 public:
-	static unique_ptr<CSVFileHandle> OpenCSV(const BufferedCSVReaderOptions &options, ClientContext &context);
+	static unique_ptr<CSVFileHandle> OpenCSV(const string &file_path, FileCompressionType compression,
+	                                         ClientContext &context);
 };
 
 struct BaseCSVData : public TableFunctionData {
@@ -39,9 +40,10 @@ struct BaseCSVData : public TableFunctionData {
 };
 
 struct WriteCSVData : public BaseCSVData {
-	WriteCSVData(string file_path, vector<LogicalType> sql_types, vector<string> names) : sql_types(move(sql_types)) {
-		files.push_back(move(file_path));
-		options.names = move(names);
+	WriteCSVData(string file_path, vector<LogicalType> sql_types, vector<string> names)
+	    : sql_types(std::move(sql_types)) {
+		files.push_back(std::move(file_path));
+		options.names = std::move(names);
 	}
 
 	//! The SQL types to write

package/src/duckdb/src/include/duckdb/function/table/system_functions.hpp

@@ -37,10 +37,6 @@ struct PragmaVersion {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-struct PragmaDatabaseList {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct PragmaDatabaseSize {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -57,6 +53,10 @@ struct DuckDBConstraintsFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct DuckDBDatabasesFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct DuckDBDependenciesFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -99,11 +99,11 @@ struct DuckDBViewsFun {
 
 struct TestType {
 	TestType(LogicalType type_p, string name_p)
-	    : type(move(type_p)), name(move(name_p)), min_value(Value::MinimumValue(type)),
+	    : type(std::move(type_p)), name(std::move(name_p)), min_value(Value::MinimumValue(type)),
 	      max_value(Value::MaximumValue(type)) {
 	}
 	TestType(LogicalType type_p, string name_p, Value min, Value max)
-	    : type(move(type_p)), name(move(name_p)), min_value(move(min)), max_value(move(max)) {
+	    : type(std::move(type_p)), name(std::move(name_p)), min_value(std::move(min)), max_value(std::move(max)) {
 	}
 
 	LogicalType type;

package/src/duckdb/src/include/duckdb/function/table/table_scan.hpp

@@ -13,14 +13,15 @@
 #include "duckdb/function/built_in_functions.hpp"
 
 namespace duckdb {
+class DuckTableEntry;
 class TableCatalogEntry;
 
 struct TableScanBindData : public TableFunctionData {
-	explicit TableScanBindData(TableCatalogEntry *table) : table(table), is_index_scan(false), is_create_index(false) {
+	explicit TableScanBindData(DuckTableEntry *table) : table(table), is_index_scan(false), is_create_index(false) {
 	}
 
 	//! The table to scan
-	TableCatalogEntry *table;
+	DuckTableEntry *table;
 
 	//! Whether or not the table scan is an index scan
 	bool is_index_scan;

package/src/duckdb/src/include/duckdb/function/udf_function.hpp

@@ -121,8 +121,8 @@ public:
 	                                                 bind_aggregate_function_t bind = nullptr,
 	                                                 aggregate_destructor_t destructor = nullptr) {
 
-		AggregateFunction aggr_function(move(name), move(arguments), move(return_type), state_size, initialize, update,
-		                                combine, finalize, simple_update, bind, destructor);
+		AggregateFunction aggr_function(std::move(name), std::move(arguments), std::move(return_type), state_size,
+		                                initialize, update, combine, finalize, simple_update, bind, destructor);
 		aggr_function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 		return aggr_function;
 	}

package/src/duckdb/src/include/duckdb/main/attached_database.hpp

@@ -19,6 +19,9 @@ class Catalog;
 class DatabaseInstance;
 class StorageManager;
 class TransactionManager;
+class StorageExtension;
+
+struct AttachInfo;
 
 enum class AttachedDatabaseType {
 	READ_WRITE_DATABASE,
@@ -34,6 +37,9 @@ public:
 	explicit AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType type = AttachedDatabaseType::SYSTEM_DATABASE);
 	//! Create an attached database instance with the specified name and storage
 	AttachedDatabase(DatabaseInstance &db, Catalog &catalog, string name, string file_path, AccessMode access_mode);
+	//! Create an attached database instance with the specified storage extension
+	AttachedDatabase(DatabaseInstance &db, Catalog &catalog, StorageExtension &ext, string name, AttachInfo &info,
+	                 AccessMode access_mode);
 	~AttachedDatabase();
 
 	void Initialize();

package/src/duckdb/src/include/duckdb/main/client_config.hpp

@@ -79,6 +79,9 @@ struct ClientConfig {
 	//! Callback to create a progress bar display
 	progress_bar_display_create_func_t display_create_func = nullptr;
 
+	//! Override for the default extension repository
+	string custom_extension_repo = "";
+
 	//! The explain output type used when none is specified (default: PHYSICAL_ONLY)
 	ExplainOutputType explain_output_type = ExplainOutputType::PHYSICAL_ONLY;
 

package/src/duckdb/src/include/duckdb/main/client_context.hpp

@@ -64,7 +64,7 @@ public:
 class ClientContext : public std::enable_shared_from_this<ClientContext> {
 	friend class PendingQueryResult;
 	friend class StreamQueryResult;
-	friend class TransactionManager;
+	friend class DuckTransactionManager;
 
 public:
 	DUCKDB_API explicit ClientContext(shared_ptr<DatabaseInstance> db);
@@ -122,6 +122,8 @@ public:
 	DUCKDB_API void TryBindRelation(Relation &relation, vector<ColumnDefinition> &result_columns);
 
 	//! Execute a relation
+	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(const shared_ptr<Relation> &relation,
+	                                                       bool allow_stream_result);
 	DUCKDB_API unique_ptr<QueryResult> Execute(const shared_ptr<Relation> &relation);
 
 	//! Prepare a query
@@ -186,6 +188,9 @@ public:
 
 	DUCKDB_API ClientProperties GetClientProperties() const;
 
+	//! Returns true if execution of the current query is finished
+	DUCKDB_API bool ExecutionIsFinished();
+
 private:
 	//! Parse statements and resolve pragmas from a query
 	bool ParseStatements(ClientContextLock &lock, const string &query, vector<unique_ptr<SQLStatement>> &result,
@@ -245,6 +250,9 @@ private:
 	                                                            shared_ptr<PreparedStatementData> &prepared,
 	                                                            PendingQueryParameters parameters);
 
+	unique_ptr<PendingQueryResult> PendingQueryInternal(ClientContextLock &, const shared_ptr<Relation> &relation,
+	                                                    bool allow_stream_result);
+
 private:
 	//! Lock on using the ClientContext in parallel
 	mutex context_lock;

package/src/duckdb/src/include/duckdb/main/config.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/enums/access_mode.hpp"
 #include "duckdb/common/allocator.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/common.hpp"
@@ -23,8 +24,8 @@
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/storage/compression/bitpacking.hpp"
 #include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/replacement_open.hpp"
 #include "duckdb/function/replacement_scan.hpp"
+#include "duckdb/function/create_database_extension.hpp"
 #include "duckdb/optimizer/optimizer_extension.hpp"
 #include "duckdb/parser/parser_extension.hpp"
 #include "duckdb/planner/operator_extension.hpp"
@@ -35,12 +36,12 @@ class ClientContext;
 class ErrorManager;
 class CompressionFunction;
 class TableFunctionRef;
+class OperatorExtension;
+class StorageExtension;
 
 struct CompressionFunctionSet;
 struct DBConfig;
 
-enum class AccessMode : uint8_t { UNDEFINED = 0, AUTOMATIC = 1, READ_ONLY = 2, READ_WRITE = 3 };
-
 enum class CheckpointAbort : uint8_t {
 	NO_ABORT = 0,
 	DEBUG_ABORT_BEFORE_TRUNCATE = 1,
@@ -70,8 +71,8 @@ typedef void (*set_option_callback_t)(ClientContext &context, SetScope scope, Va
 struct ExtensionOption {
 	ExtensionOption(string description_p, LogicalType type_p, set_option_callback_t set_function_p,
 	                Value default_value_p)
-	    : description(move(description_p)), type(move(type_p)), set_function(set_function_p),
-	      default_value(move(default_value_p)) {
+	    : description(std::move(description_p)), type(std::move(type_p)), set_function(set_function_p),
+	      default_value(std::move(default_value_p)) {
 	}
 
 	string description;
@@ -144,6 +145,8 @@ struct DBConfigOptions {
 	bool experimental_parallel_csv_reader = false;
 	//! Start transactions immediately in all attached databases - instead of lazily when a database is referenced
 	bool immediate_transaction_mode = false;
+	//! The set of unrecognized (other) options
+	unordered_map<string, Value> unrecognized_options;
 
 	bool operator==(const DBConfigOptions &other) const;
 };
@@ -161,9 +164,6 @@ public:
 	//! Replacement table scans are automatically attempted when a table name cannot be found in the schema
 	vector<ReplacementScan> replacement_scans;
 
-	//! Replacement open handlers are callbacks that run pre and post database initialization
-	vector<ReplacementOpen> replacement_opens;
-
 	//! Extra parameters that can be SET for loaded extensions
 	case_insensitive_map_t<ExtensionOption> extension_parameters;
 	//! The FileSystem to use, can be overwritten to allow for injecting custom file systems for testing purposes (e.g.
@@ -183,6 +183,10 @@ public:
 	shared_ptr<Allocator> default_allocator;
 	//! Extensions made to binder
 	vector<std::unique_ptr<OperatorExtension>> operator_extensions;
+	//! Extensions made to storage
+	case_insensitive_map_t<std::unique_ptr<StorageExtension>> storage_extensions;
+	//! Extensions made to binder to implement the create_database functionality
+	vector<CreateDatabaseExtension> create_database_extensions;
 
 public:
 	DUCKDB_API static DBConfig &GetConfig(ClientContext &context);
@@ -203,6 +207,7 @@ public:
 
 	DUCKDB_API void SetOption(const ConfigurationOption &option, const Value &value);
 	DUCKDB_API void SetOption(DatabaseInstance *db, const ConfigurationOption &option, const Value &value);
+	DUCKDB_API void SetOptionByName(const string &name, const Value &value);
 	DUCKDB_API void ResetOption(DatabaseInstance *db, const ConfigurationOption &option);
 	DUCKDB_API void SetOption(const string &name, Value value);
 	DUCKDB_API void ResetOption(const string &name);

package/src/duckdb/src/include/duckdb/main/connection.hpp

@@ -30,6 +30,7 @@ class DatabaseInstance;
 class DuckDB;
 class LogicalOperator;
 class SelectStatement;
+struct BufferedCSVReaderOptions;
 
 typedef void (*warning_callback)(std::string);
 
@@ -127,8 +128,10 @@ public:
 	DUCKDB_API shared_ptr<Relation> Values(const string &values);
 	DUCKDB_API shared_ptr<Relation> Values(const string &values, const vector<string> &column_names,
 	                                       const string &alias = "values");
+
 	//! Reads CSV file
 	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file);
+	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file, BufferedCSVReaderOptions &options);
 	DUCKDB_API shared_ptr<Relation> ReadCSV(const string &csv_file, const vector<string> &columns);
 
 	//! Reads Parquet file
@@ -167,19 +170,20 @@ public:
 	void CreateScalarFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
 	                          TR (*udf_func)(Args...)) {
 		scalar_function_t function =
-		    UDFWrapper::CreateScalarFunction<TR, Args...>(name, args, move(ret_type), udf_func);
+		    UDFWrapper::CreateScalarFunction<TR, Args...>(name, args, std::move(ret_type), udf_func);
 		UDFWrapper::RegisterFunction(name, args, ret_type, function, *context);
 	}
 
 	template <typename TR, typename... Args>
 	void CreateVectorizedFunction(const string &name, scalar_function_t udf_func,
 	                              LogicalType varargs = LogicalType::INVALID) {
-		UDFWrapper::RegisterFunction<TR, Args...>(name, udf_func, *context, move(varargs));
+		UDFWrapper::RegisterFunction<TR, Args...>(name, udf_func, *context, std::move(varargs));
 	}
 
 	DUCKDB_API void CreateVectorizedFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
 	                                         scalar_function_t udf_func, LogicalType varargs = LogicalType::INVALID) {
-		UDFWrapper::RegisterFunction(name, move(args), move(ret_type), udf_func, *context, move(varargs));
+		UDFWrapper::RegisterFunction(name, std::move(args), std::move(ret_type), udf_func, *context,
+		                             std::move(varargs));
 	}
 
 	//------------------------------------- Aggreate Functions ----------------------------------------//

package/src/duckdb/src/include/duckdb/main/connection_manager.hpp

@@ -40,7 +40,7 @@ public:
 				connections.erase(it.first);
 				continue;
 			} else {
-				result.push_back(move(connection));
+				result.push_back(std::move(connection));
 			}
 		}
 

package/src/duckdb/src/include/duckdb/main/database.hpp

@@ -23,6 +23,7 @@ class ConnectionManager;
 class FileSystem;
 class TaskScheduler;
 class ObjectCache;
+struct AttachInfo;
 
 class DatabaseInstance : public std::enable_shared_from_this<DatabaseInstance> {
 	friend class DuckDB;
@@ -48,9 +49,14 @@ public:
 	DUCKDB_API static DatabaseInstance &GetDatabase(ClientContext &context);
 
 	DUCKDB_API const unordered_set<std::string> &LoadedExtensions();
+	DUCKDB_API bool ExtensionIsLoaded(const std::string &name);
 
 	DUCKDB_API bool TryGetCurrentSetting(const std::string &key, Value &result);
 
+	//! Get the database extension type from a given path
+	string ExtractDatabaseType(string &path);
+	unique_ptr<AttachedDatabase> CreateAttachedDatabase(AttachInfo &info, const string &type, AccessMode access_mode);
+
 private:
 	void Initialize(const char *path, DBConfig *config);
 

package/src/duckdb/src/include/duckdb/main/database_manager.hpp

@@ -52,6 +52,9 @@ public:
 	transaction_t ActiveQueryNumber() const {
 		return current_query_number;
 	}
+	idx_t ModifyCatalog() {
+		return catalog_version++;
+	}
 
 private:
 	//! The system database is a special database that holds system entries (e.g. functions)

package/src/duckdb/src/include/duckdb/main/extension_functions.hpp

@@ -46,6 +46,7 @@ static constexpr ExtensionFunction EXTENSION_FUNCTIONS[] = {
     {"json_group_array", "json"},
     {"json_group_object", "json"},
     {"json_group_structure", "json"},
+    {"json_keys", "json"},
     {"json_merge_patch", "json"},
     {"json_object", "json"},
     {"json_quote", "json"},
@@ -62,7 +63,11 @@ static constexpr ExtensionFunction EXTENSION_FUNCTIONS[] = {
     {"postgres_attach", "postgres_scanner"},
     {"postgres_scan", "postgres_scanner"},
     {"postgres_scan_pushdown", "postgres_scanner"},
+    {"read_json", "json"},
+    {"read_json_auto", "json"},
     {"read_json_objects", "json"},
+    {"read_ndjson", "json"},
+    {"read_ndjson_auto", "json"},
     {"read_ndjson_objects", "json"},
     {"read_parquet", "parquet"},
     {"row_to_json", "json"},

package/src/duckdb/src/include/duckdb/main/extension_helper.hpp

@@ -42,6 +42,7 @@ public:
 
 	static void InstallExtension(ClientContext &context, const string &extension, bool force_install);
 	static void LoadExternalExtension(ClientContext &context, const string &extension);
+	static void LoadExternalExtension(DatabaseInstance &db, FileOpener *opener, const string &extension);
 
 	static string ExtensionDirectory(ClientContext &context);
 
@@ -53,13 +54,14 @@ public:
 
 	static const vector<string> GetPublicKeys();
 
-	static unique_ptr<ReplacementOpenData> ReplacementOpenPre(const string &extension, DBConfig &config);
-	static void ReplacementOpenPost(ClientContext &context, const string &extension, DatabaseInstance &instance,
-	                                ReplacementOpenData *open_data);
+	static void StorageInit(string &extension, DBConfig &config);
 
 	// Returns extension name, or empty string if not a replacement open path
 	static string ExtractExtensionPrefixFromPath(const string &path);
 
+	//! Apply any known extension aliases
+	static string ApplyExtensionAlias(string extension_name);
+
 private:
 	static const vector<string> PathComponents();
 	static ExtensionInitResult InitialLoad(DBConfig &context, FileOpener *opener, const string &extension);
@@ -68,8 +70,6 @@ private:
 	//! Version tags occur with and without 'v', tag in extension path is always with 'v'
 	static const string NormalizeVersionTag(const string &version_tag);
 	static bool IsRelease(const string &version_tag);
-	//! Apply any known extension aliases
-	static string ApplyExtensionAlias(string extension_name);
 	static bool CreateSuggestions(const string &extension_name, string &message);
 
 private:

package/src/duckdb/src/include/duckdb/main/materialized_query_result.hpp

@@ -33,6 +33,7 @@ public:
 	DUCKDB_API unique_ptr<DataChunk> FetchRaw() override;
 	//! Converts the QueryResult to a string
 	DUCKDB_API string ToString() override;
+	DUCKDB_API string ToBox(ClientContext &context, const BoxRendererConfig &config) override;
 
 	//! Gets the (index) value of the (column index) column.
 	//! Note: this is very slow. Scanning over the underlying collection is much faster.

package/src/duckdb/src/include/duckdb/main/prepared_statement.hpp

@@ -60,6 +60,8 @@ public:
 	DUCKDB_API const vector<LogicalType> &GetTypes();
 	//! Returns the result names of the prepared statement
 	DUCKDB_API const vector<string> &GetNames();
+	//! Returns the map of parameter index to the expected type of parameter
+	DUCKDB_API vector<LogicalType> GetExpectedParameterTypes() const;
 
 	//! Create a pending query result of the prepared statement with the given set of arguments
 	template <typename... Args>

package/src/duckdb/src/include/duckdb/main/query_result.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/common/preserved_error.hpp"
 
 namespace duckdb {
+struct BoxRendererConfig;
 
 enum class QueryResultType : uint8_t { MATERIALIZED_RESULT, STREAM_RESULT, PENDING_RESULT };
 
@@ -86,6 +87,8 @@ public:
 	DUCKDB_API virtual unique_ptr<DataChunk> FetchRaw() = 0;
 	//! Converts the QueryResult to a string
 	DUCKDB_API virtual string ToString() = 0;
+	//! Converts the QueryResult to a box-rendered string
+	DUCKDB_API virtual string ToBox(ClientContext &context, const BoxRendererConfig &config);
 	//! Prints the QueryResult to the console
 	DUCKDB_API void Print();
 	//! Returns true if the two results are identical; false otherwise. Note that this method is destructive; it calls

package/src/duckdb/src/include/duckdb/main/relation/read_csv_relation.hpp

@@ -8,26 +8,25 @@
 
 #pragma once
 
-#include "duckdb/main/relation.hpp"
+#include "duckdb/execution/operator/persistent/csv_reader_options.hpp"
+#include "duckdb/main/relation/table_function_relation.hpp"
 
 namespace duckdb {
 
-class ReadCSVRelation : public Relation {
+struct BufferedCSVReaderOptions;
+
+class ReadCSVRelation : public TableFunctionRelation {
 public:
-	ReadCSVRelation(const std::shared_ptr<ClientContext> &context, string csv_file, vector<ColumnDefinition> columns,
-	                bool auto_detect = false, string alias = string());
+	ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
+	                vector<ColumnDefinition> columns, string alias = string());
+	ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
+	                BufferedCSVReaderOptions options, string alias = string());
 
-	string csv_file;
-	bool auto_detect;
 	string alias;
-	vector<ColumnDefinition> columns;
+	bool auto_detect;
 
 public:
-	unique_ptr<QueryNode> GetQueryNode() override;
-	const vector<ColumnDefinition> &Columns() override;
-	string ToString(idx_t depth) override;
 	string GetAlias() override;
-	unique_ptr<TableRef> GetTableRef() override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/relation/read_json_relation.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "duckdb/main/relation/table_function_relation.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/common/named_parameter_map.hpp"
+#include "duckdb/parser/column_definition.hpp"
+#include "duckdb/common/string.hpp"
+#include "duckdb/common/vector.hpp"
+
+namespace duckdb {
+
+class ReadJSONRelation : public TableFunctionRelation {
+public:
+	ReadJSONRelation(const shared_ptr<ClientContext> &context, string json_file, named_parameter_map_t options,
+	                 bool auto_detect, string alias = "");
+	string json_file;
+	string alias;
+
+public:
+	string GetAlias() override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/main/relation/table_function_relation.hpp

@@ -15,10 +15,11 @@ namespace duckdb {
 class TableFunctionRelation : public Relation {
 public:
 	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);
+	                      named_parameter_map_t named_parameters, shared_ptr<Relation> input_relation_p = nullptr,
+	                      bool auto_init = true);
 
 	TableFunctionRelation(const std::shared_ptr<ClientContext> &context, string name, vector<Value> parameters,
-	                      shared_ptr<Relation> input_relation_p = nullptr);
+	                      shared_ptr<Relation> input_relation_p = nullptr, bool auto_init = true);
 
 	string name;
 	vector<Value> parameters;
@@ -33,6 +34,14 @@ public:
 	const vector<ColumnDefinition> &Columns() override;
 	string ToString(idx_t depth) override;
 	string GetAlias() override;
+	void AddNamedParameter(const string &name, Value argument);
+
+private:
+	void InitializeColumns();
+
+private:
+	//! Whether or not to auto initialize the columns on construction
+	bool auto_initialize;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/relation/write_csv_relation.hpp

@@ -14,11 +14,12 @@ namespace duckdb {
 
 class WriteCSVRelation : public Relation {
 public:
-	WriteCSVRelation(shared_ptr<Relation> child, string csv_file);
+	WriteCSVRelation(shared_ptr<Relation> child, string csv_file, case_insensitive_map_t<vector<Value>> options);
 
 	shared_ptr<Relation> child;
 	string csv_file;
 	vector<ColumnDefinition> columns;
+	case_insensitive_map_t<vector<Value>> options;
 
 public:
 	BoundStatement Bind(Binder &binder) override;

package/src/duckdb/src/include/duckdb/main/relation/write_parquet_relation.hpp

@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/relation/write_csv_relation.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/main/relation.hpp"
+
+namespace duckdb {
+
+class WriteParquetRelation : public Relation {
+public:
+	WriteParquetRelation(shared_ptr<Relation> child, string parquet_file,
+	                     case_insensitive_map_t<vector<Value>> options);
+
+	shared_ptr<Relation> child;
+	string parquet_file;
+	vector<ColumnDefinition> columns;
+	case_insensitive_map_t<vector<Value>> options;
+
+public:
+	BoundStatement Bind(Binder &binder) override;
+	const vector<ColumnDefinition> &Columns() override;
+	string ToString(idx_t depth) override;
+	bool IsReadOnly() override {
+		return false;
+	}
+};
+
+} // namespace duckdb