duckdb 0.3.5-dev167.0 → 0.3.5-dev184.0

package/src/duckdb.cpp

@@ -1237,8 +1237,8 @@ namespace duckdb {
 class TableMacroFunction : public MacroFunction {
 public:
 	TableMacroFunction(unique_ptr<QueryNode> query_node);
-
 	TableMacroFunction(void);
+
 	//! The main query node
 	unique_ptr<QueryNode> query_node;
 
@@ -1427,10 +1427,15 @@ public:
 	SchemaCatalogEntry *schema;
 
 	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalMacroInfo(DefaultMacro &default_macro);
+	DUCKDB_API static unique_ptr<CreateMacroInfo> CreateInternalTableMacroInfo(DefaultMacro &default_macro);
 
 public:
 	unique_ptr<CatalogEntry> CreateDefaultEntry(ClientContext &context, const string &entry_name) override;
 	vector<string> GetDefaultEntries() override;
+
+private:
+	static unique_ptr<CreateMacroInfo> CreateInternalTableMacroInfo(DefaultMacro &default_macro,
+	                                                                unique_ptr<MacroFunction> function);
 };
 
 } // namespace duckdb
@@ -4610,6 +4615,7 @@ void CatalogSet::Scan(const std::function<void(CatalogEntry *)> &callback) {
 
 
 
+
 namespace duckdb {
 
 static DefaultMacro internal_macros[] = {
@@ -4735,14 +4741,9 @@ static DefaultMacro internal_macros[] = {
 	{nullptr, nullptr, {nullptr}, nullptr}
 	};
 
-unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(DefaultMacro &default_macro) {
-	// parse the expression
-	auto expressions = Parser::ParseExpressionList(default_macro.macro);
-	D_ASSERT(expressions.size() == 1);
-
-	auto result = make_unique<ScalarMacroFunction>(move(expressions[0]));
+unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroInfo(DefaultMacro &default_macro, unique_ptr<MacroFunction> function) {
 	for (idx_t param_idx = 0; default_macro.parameters[param_idx] != nullptr; param_idx++) {
-		result->parameters.push_back(
+		function->parameters.push_back(
 		    make_unique<ColumnRefExpression>(default_macro.parameters[param_idx]));
 	}
 
@@ -4751,8 +4752,30 @@ unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(De
 	bind_info->name = default_macro.name;
 	bind_info->temporary = true;
 	bind_info->internal = true;
-	bind_info->function = move(result);
+	bind_info->type = function->type == MacroType::TABLE_MACRO ? CatalogType::TABLE_MACRO_ENTRY : CatalogType::MACRO_ENTRY;
+	bind_info->function = move(function);
 	return bind_info;
+
+}
+
+unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(DefaultMacro &default_macro) {
+	// parse the expression
+	auto expressions = Parser::ParseExpressionList(default_macro.macro);
+	D_ASSERT(expressions.size() == 1);
+
+	auto result = make_unique<ScalarMacroFunction>(move(expressions[0]));
+	return CreateInternalTableMacroInfo(default_macro, move(result));
+}
+
+unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroInfo(DefaultMacro &default_macro) {
+	Parser parser;
+	parser.ParseQuery(default_macro.macro);
+	D_ASSERT(parser.statements.size() == 1);
+	D_ASSERT(parser.statements[0]->type == StatementType::SELECT_STATEMENT);
+
+	auto &select = (SelectStatement &) *parser.statements[0];
+	auto result = make_unique<TableMacroFunction>(move(select.node));
+	return CreateInternalTableMacroInfo(default_macro, move(result));
 }
 
 static unique_ptr<CreateFunctionInfo> GetDefaultFunction(const string &input_schema, const string &input_name) {
@@ -63446,6 +63469,108 @@ string PhysicalTopN::ParamsToString() const {
 
 namespace duckdb {
 
+static bool ParseBoolean(const Value &value, const string &loption);
+
+static bool ParseBoolean(const vector<Value> &set, const string &loption) {
+	if (set.empty()) {
+		// no option specified: default to true
+		return true;
+	}
+	if (set.size() > 1) {
+		throw BinderException("\"%s\" expects a single argument as a boolean value (e.g. TRUE or 1)", loption);
+	}
+	return ParseBoolean(set[0], loption);
+}
+
+static bool ParseBoolean(const Value &value, const string &loption) {
+
+	if (value.type().id() == LogicalTypeId::LIST) {
+		auto &children = ListValue::GetChildren(value);
+		return ParseBoolean(children, loption);
+	}
+	if (value.type() == LogicalType::FLOAT || value.type() == LogicalType::DOUBLE ||
+	    value.type().id() == LogicalTypeId::DECIMAL) {
+		throw BinderException("\"%s\" expects a boolean value (e.g. TRUE or 1)", loption);
+	}
+	return BooleanValue::Get(value.CastAs(LogicalType::BOOLEAN));
+}
+
+static string ParseString(const Value &value, const string &loption) {
+	if (value.type().id() == LogicalTypeId::LIST) {
+		auto &children = ListValue::GetChildren(value);
+		if (children.size() != 1) {
+			throw BinderException("\"%s\" expects a single argument as a string value", loption);
+		}
+		return ParseString(children[0], loption);
+	}
+	if (value.type().id() != LogicalTypeId::VARCHAR) {
+		throw BinderException("\"%s\" expects a string argument!", loption);
+	}
+	return value.GetValue<string>();
+}
+
+static int64_t ParseInteger(const Value &value, const string &loption) {
+	if (value.type().id() == LogicalTypeId::LIST) {
+		auto &children = ListValue::GetChildren(value);
+		if (children.size() != 1) {
+			// no option specified or multiple options specified
+			throw BinderException("\"%s\" expects a single argument as an integer value", loption);
+		}
+		return ParseInteger(children[0], loption);
+	}
+	return value.GetValue<int64_t>();
+}
+
+static vector<bool> ParseColumnList(const vector<Value> &set, vector<string> &names, const string &loption) {
+	vector<bool> result;
+
+	if (set.empty()) {
+		throw BinderException("\"%s\" expects a column list or * as parameter", loption);
+	}
+	// list of options: parse the list
+	unordered_map<string, bool> option_map;
+	for (idx_t i = 0; i < set.size(); i++) {
+		option_map[set[i].ToString()] = false;
+	}
+	result.resize(names.size(), false);
+	for (idx_t i = 0; i < names.size(); i++) {
+		auto entry = option_map.find(names[i]);
+		if (entry != option_map.end()) {
+			result[i] = true;
+			entry->second = true;
+		}
+	}
+	for (auto &entry : option_map) {
+		if (!entry.second) {
+			throw BinderException("\"%s\" expected to find %s, but it was not found in the table", loption,
+			                      entry.first.c_str());
+		}
+	}
+	return result;
+}
+
+static vector<bool> ParseColumnList(const Value &value, vector<string> &names, const string &loption) {
+	vector<bool> result;
+
+	// Only accept a list of arguments
+	if (value.type().id() != LogicalTypeId::LIST) {
+		// Support a single argument if it's '*'
+		if (value.type().id() == LogicalTypeId::VARCHAR && value.GetValue<string>() == "*") {
+			result.resize(names.size(), true);
+			return result;
+		}
+		throw BinderException("\"%s\" expects a column list or * as parameter", loption);
+	}
+	auto &children = ListValue::GetChildren(value);
+	// accept '*' as single argument
+	if (children.size() == 1 && children[0].type().id() == LogicalTypeId::VARCHAR &&
+	    children[0].GetValue<string>() == "*") {
+		result.resize(names.size(), true);
+		return result;
+	}
+	return ParseColumnList(children, names, loption);
+}
+
 struct CSVFileHandle {
 public:
 	explicit CSVFileHandle(unique_ptr<FileHandle> file_handle_p) : file_handle(move(file_handle_p)) {
@@ -63569,10 +63694,123 @@ void BufferedCSVReaderOptions::SetDelimiter(const string &input) {
 	this->delimiter = StringUtil::Replace(input, "\\t", "\t");
 	this->has_delimiter = true;
 	if (input.empty()) {
-		throw BinderException("DELIM or SEP must not be empty");
+		this->delimiter = string("\0", 1);
 	}
 }
 
+void BufferedCSVReaderOptions::SetReadOption(const string &loption, const Value &value,
+                                             vector<string> &expected_names) {
+	if (SetBaseOption(loption, value)) {
+		return;
+	}
+	if (loption == "auto_detect") {
+		auto_detect = ParseBoolean(value, loption);
+	} else if (loption == "sample_size") {
+		int64_t sample_size = ParseInteger(value, loption);
+		if (sample_size < 1 && sample_size != -1) {
+			throw BinderException("Unsupported parameter for SAMPLE_SIZE: cannot be smaller than 1");
+		}
+		if (sample_size == -1) {
+			sample_chunks = std::numeric_limits<uint64_t>::max();
+			sample_chunk_size = STANDARD_VECTOR_SIZE;
+		} else if (sample_size <= STANDARD_VECTOR_SIZE) {
+			sample_chunk_size = sample_size;
+			sample_chunks = 1;
+		} else {
+			sample_chunk_size = STANDARD_VECTOR_SIZE;
+			sample_chunks = sample_size / STANDARD_VECTOR_SIZE;
+		}
+	} else if (loption == "skip") {
+		skip_rows = ParseInteger(value, loption);
+	} else if (loption == "max_line_size" || loption == "maximum_line_size") {
+		maximum_line_size = ParseInteger(value, loption);
+	} else if (loption == "sample_chunk_size") {
+		sample_chunk_size = ParseInteger(value, loption);
+		if (sample_chunk_size > STANDARD_VECTOR_SIZE) {
+			throw BinderException(
+			    "Unsupported parameter for SAMPLE_CHUNK_SIZE: cannot be bigger than STANDARD_VECTOR_SIZE %d",
+			    STANDARD_VECTOR_SIZE);
+		} else if (sample_chunk_size < 1) {
+			throw BinderException("Unsupported parameter for SAMPLE_CHUNK_SIZE: cannot be smaller than 1");
+		}
+	} else if (loption == "sample_chunks") {
+		sample_chunks = ParseInteger(value, loption);
+		if (sample_chunks < 1) {
+			throw BinderException("Unsupported parameter for SAMPLE_CHUNKS: cannot be smaller than 1");
+		}
+	} else if (loption == "force_not_null") {
+		force_not_null = ParseColumnList(value, expected_names, loption);
+	} else if (loption == "date_format" || loption == "dateformat") {
+		string format = ParseString(value, loption);
+		auto &date_format = this->date_format[LogicalTypeId::DATE];
+		string error = StrTimeFormat::ParseFormatSpecifier(format, date_format);
+		date_format.format_specifier = format;
+		if (!error.empty()) {
+			throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
+		}
+		has_format[LogicalTypeId::DATE] = true;
+	} else if (loption == "timestamp_format" || loption == "timestampformat") {
+		string format = ParseString(value, loption);
+		auto &timestamp_format = date_format[LogicalTypeId::TIMESTAMP];
+		string error = StrTimeFormat::ParseFormatSpecifier(format, timestamp_format);
+		timestamp_format.format_specifier = format;
+		if (!error.empty()) {
+			throw InvalidInputException("Could not parse TIMESTAMPFORMAT: %s", error.c_str());
+		}
+		has_format[LogicalTypeId::TIMESTAMP] = true;
+	} else if (loption == "escape") {
+		escape = ParseString(value, loption);
+		has_escape = true;
+	} else if (loption == "ignore_errors") {
+		ignore_errors = ParseBoolean(value, loption);
+	} else {
+		throw BinderException("Unrecognized option for CSV reader \"%s\"", loption);
+	}
+}
+
+void BufferedCSVReaderOptions::SetWriteOption(const string &loption, const Value &value) {
+	if (SetBaseOption(loption, value)) {
+		return;
+	}
+
+	if (loption == "force_quote") {
+		force_quote = ParseColumnList(value, names, loption);
+	} else {
+		throw BinderException("Unrecognized option CSV writer \"%s\"", loption);
+	}
+}
+
+bool BufferedCSVReaderOptions::SetBaseOption(const string &loption, const Value &value) {
+	// Make sure this function was only called after the option was turned into lowercase
+	D_ASSERT(!std::any_of(loption.begin(), loption.end(), ::isupper));
+
+	if (StringUtil::StartsWith(loption, "delim") || StringUtil::StartsWith(loption, "sep")) {
+		SetDelimiter(ParseString(value, loption));
+	} else if (loption == "quote") {
+		quote = ParseString(value, loption);
+		has_quote = true;
+	} else if (loption == "escape") {
+		escape = ParseString(value, loption);
+		has_escape = true;
+	} else if (loption == "header") {
+		header = ParseBoolean(value, loption);
+		has_header = true;
+	} else if (loption == "null" || loption == "nullstr") {
+		null_str = ParseString(value, loption);
+	} else if (loption == "encoding") {
+		auto encoding = StringUtil::Lower(ParseString(value, loption));
+		if (encoding != "utf8" && encoding != "utf-8") {
+			throw BinderException("Copy is only supported for UTF-8 encoded files, ENCODING 'UTF-8'");
+		}
+	} else if (loption == "compression") {
+		compression = FileCompressionTypeFromString(ParseString(value, loption));
+	} else {
+		// unrecognized option in base CSV
+		return false;
+	}
+	return true;
+}
+
 std::string BufferedCSVReaderOptions::ToString() const {
 	return "DELIMITER='" + delimiter + (has_delimiter ? "'" : (auto_detect ? "' (auto detected)" : "' (default)")) +
 	       ", QUOTE='" + quote + (has_quote ? "'" : (auto_detect ? "' (auto detected)" : "' (default)")) +
@@ -98924,17 +99162,13 @@ struct BaseCSVData : public TableFunctionData {
 };
 
 struct WriteCSVData : public BaseCSVData {
-	WriteCSVData(string file_path, vector<LogicalType> sql_types, vector<string> names)
-	    : sql_types(move(sql_types)), names(move(names)) {
+	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);
 	}
 
 	//! The SQL types to write
 	vector<LogicalType> sql_types;
-	//! The column names of the columns to write
-	vector<string> names;
-	//! True, if column with that index must be quoted
-	vector<bool> force_quote;
 	//! The newline string to write
 	string newline = "\n";
 	//! Whether or not we are writing a simple CSV (delimiter, quote and escape are all 1 byte in length)
@@ -98946,8 +99180,6 @@ struct WriteCSVData : public BaseCSVData {
 struct ReadCSVData : public BaseCSVData {
 	//! The expected SQL types to read
 	vector<LogicalType> sql_types;
-	//! Whether or not to include a file name column
-	bool include_file_name = false;
 	//! The initial reader (if any): this is used when automatic detection is used during binding.
 	//! In this case, the CSV reader is already created and might as well be re-used.
 	unique_ptr<BufferedCSVReader> initial_reader;
@@ -98990,76 +99222,9 @@ void SubstringDetection(string &str_1, string &str_2, const string &name_str_1,
 	}
 }
 
-static bool ParseBoolean(vector<Value> &set) {
-	if (set.empty()) {
-		// no option specified: default to true
-		return true;
-	}
-	if (set.size() > 1) {
-		throw BinderException("Expected a single argument as a boolean value (e.g. TRUE or 1)");
-	}
-	if (set[0].type() == LogicalType::FLOAT || set[0].type() == LogicalType::DOUBLE ||
-	    set[0].type().id() == LogicalTypeId::DECIMAL) {
-		throw BinderException("Expected a boolean value (e.g. TRUE or 1)");
-	}
-	return BooleanValue::Get(set[0].CastAs(LogicalType::BOOLEAN));
-}
-
-static string ParseString(vector<Value> &set) {
-	if (set.size() != 1) {
-		// no option specified or multiple options specified
-		throw BinderException("Expected a single argument as a string value");
-	}
-	if (set[0].type().id() != LogicalTypeId::VARCHAR) {
-		throw BinderException("Expected a string argument!");
-	}
-	return set[0].GetValue<string>();
-}
-
-static int64_t ParseInteger(vector<Value> &set) {
-	if (set.size() != 1) {
-		// no option specified or multiple options specified
-		throw BinderException("Expected a single argument as a integer value");
-	}
-	return set[0].GetValue<int64_t>();
-}
-
 //===--------------------------------------------------------------------===//
 // Bind
 //===--------------------------------------------------------------------===//
-static bool ParseBaseOption(BufferedCSVReaderOptions &options, string &loption, vector<Value> &set) {
-	if (StringUtil::StartsWith(loption, "delim") || StringUtil::StartsWith(loption, "sep")) {
-		options.SetDelimiter(ParseString(set));
-	} else if (loption == "quote") {
-		options.quote = ParseString(set);
-		options.has_quote = true;
-	} else if (loption == "escape") {
-		options.escape = ParseString(set);
-		options.has_escape = true;
-	} else if (loption == "header") {
-		options.header = ParseBoolean(set);
-		options.has_header = true;
-	} else if (loption == "null") {
-		options.null_str = ParseString(set);
-	} else if (loption == "encoding") {
-		auto encoding = StringUtil::Lower(ParseString(set));
-		if (encoding != "utf8" && encoding != "utf-8") {
-			throw BinderException("Copy is only supported for UTF-8 encoded files, ENCODING 'UTF-8'");
-		}
-	} else if (loption == "compression") {
-		options.compression = FileCompressionTypeFromString(ParseString(set));
-	} else if (loption == "skip") {
-		options.skip_rows = ParseInteger(set);
-	} else if (loption == "max_line_size" || loption == "maximum_line_size") {
-		options.maximum_line_size = ParseInteger(set);
-	} else if (loption == "ignore_errors") {
-		options.ignore_errors = ParseBoolean(set);
-	} else {
-		// unrecognized option in base CSV
-		return false;
-	}
-	return true;
-}
 
 void BaseCSVData::Finalize() {
 	// verify that the options are correct in the final pass
@@ -99093,35 +99258,11 @@ void BaseCSVData::Finalize() {
 	}
 }
 
-static vector<bool> ParseColumnList(vector<Value> &set, vector<string> &names) {
-	vector<bool> result;
+static Value ConvertVectorToValue(vector<Value> set) {
 	if (set.empty()) {
-		throw BinderException("Expected a column list or * as parameter");
+		return Value::EMPTYLIST(LogicalType::BOOLEAN);
 	}
-	if (set.size() == 1 && set[0].type().id() == LogicalTypeId::VARCHAR && set[0].GetValue<string>() == "*") {
-		// *, force_not_null on all columns
-		result.resize(names.size(), true);
-	} else {
-		// list of options: parse the list
-		unordered_map<string, bool> option_map;
-		for (idx_t i = 0; i < set.size(); i++) {
-			option_map[set[i].ToString()] = false;
-		}
-		result.resize(names.size(), false);
-		for (idx_t i = 0; i < names.size(); i++) {
-			auto entry = option_map.find(names[i]);
-			if (entry != option_map.end()) {
-				result[i] = true;
-				entry->second = true;
-			}
-		}
-		for (auto &entry : option_map) {
-			if (!entry.second) {
-				throw BinderException("Column %s not found in table", entry.first.c_str());
-			}
-		}
-	}
-	return result;
+	return Value::LIST(move(set));
 }
 
 static unique_ptr<FunctionData> WriteCSVBind(ClientContext &context, CopyInfo &info, vector<string> &names,
@@ -99132,19 +99273,12 @@ static unique_ptr<FunctionData> WriteCSVBind(ClientContext &context, CopyInfo &i
 	for (auto &option : info.options) {
 		auto loption = StringUtil::Lower(option.first);
 		auto &set = option.second;
-		if (ParseBaseOption(bind_data->options, loption, set)) {
-			// parsed option in base CSV options: continue
-			continue;
-		} else if (loption == "force_quote") {
-			bind_data->force_quote = ParseColumnList(set, names);
-		} else {
-			throw NotImplementedException("Unrecognized option for CSV: %s", option.first.c_str());
-		}
+		bind_data->options.SetWriteOption(loption, ConvertVectorToValue(move(set)));
 	}
 	// verify the parsed options
-	if (bind_data->force_quote.empty()) {
+	if (bind_data->options.force_quote.empty()) {
 		// no FORCE_QUOTE specified: initialize to false
-		bind_data->force_quote.resize(names.size(), false);
+		bind_data->options.force_quote.resize(names.size(), false);
 	}
 	bind_data->Finalize();
 	bind_data->is_simple = bind_data->options.delimiter.size() == 1 && bind_data->options.escape.size() == 1 &&
@@ -99171,63 +99305,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, CopyInfo &in
 	for (auto &option : info.options) {
 		auto loption = StringUtil::Lower(option.first);
 		auto &set = option.second;
-		if (loption == "auto_detect") {
-			options.auto_detect = ParseBoolean(set);
-		} else if (ParseBaseOption(options, loption, set)) {
-			// parsed option in base CSV options: continue
-			continue;
-		} else if (loption == "sample_size") {
-			int64_t sample_size = ParseInteger(set);
-			if (sample_size < 1 && sample_size != -1) {
-				throw BinderException("Unsupported parameter for SAMPLE_SIZE: cannot be smaller than 1");
-			}
-			if (sample_size == -1) {
-				options.sample_chunks = std::numeric_limits<uint64_t>::max();
-				options.sample_chunk_size = STANDARD_VECTOR_SIZE;
-			} else if (sample_size <= STANDARD_VECTOR_SIZE) {
-				options.sample_chunk_size = sample_size;
-				options.sample_chunks = 1;
-			} else {
-				options.sample_chunk_size = STANDARD_VECTOR_SIZE;
-				options.sample_chunks = sample_size / STANDARD_VECTOR_SIZE;
-			}
-		} else if (loption == "sample_chunk_size") {
-			options.sample_chunk_size = ParseInteger(set);
-			if (options.sample_chunk_size > STANDARD_VECTOR_SIZE) {
-				throw BinderException(
-				    "Unsupported parameter for SAMPLE_CHUNK_SIZE: cannot be bigger than STANDARD_VECTOR_SIZE %d",
-				    STANDARD_VECTOR_SIZE);
-			} else if (options.sample_chunk_size < 1) {
-				throw BinderException("Unsupported parameter for SAMPLE_CHUNK_SIZE: cannot be smaller than 1");
-			}
-		} else if (loption == "sample_chunks") {
-			options.sample_chunks = ParseInteger(set);
-			if (options.sample_chunks < 1) {
-				throw BinderException("Unsupported parameter for SAMPLE_CHUNKS: cannot be smaller than 1");
-			}
-		} else if (loption == "force_not_null") {
-			options.force_not_null = ParseColumnList(set, expected_names);
-		} else if (loption == "date_format" || loption == "dateformat") {
-			string format = ParseString(set);
-			auto &date_format = options.date_format[LogicalTypeId::DATE];
-			string error = StrTimeFormat::ParseFormatSpecifier(format, date_format);
-			date_format.format_specifier = format;
-			if (!error.empty()) {
-				throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
-			}
-			options.has_format[LogicalTypeId::DATE] = true;
-		} else if (loption == "timestamp_format" || loption == "timestampformat") {
-			string format = ParseString(set);
-			auto &timestamp_format = options.date_format[LogicalTypeId::TIMESTAMP];
-			string error = StrTimeFormat::ParseFormatSpecifier(format, timestamp_format);
-			timestamp_format.format_specifier = format;
-			if (!error.empty()) {
-				throw InvalidInputException("Could not parse TIMESTAMPFORMAT: %s", error.c_str());
-			}
-			options.has_format[LogicalTypeId::TIMESTAMP] = true;
-		} else {
-			throw NotImplementedException("Unrecognized option for CSV: %s", option.first.c_str());
-		}
+		options.SetReadOption(loption, ConvertVectorToValue(move(set)), expected_names);
 	}
 	// verify the parsed options
 	if (options.force_not_null.empty()) {
@@ -99391,7 +99469,7 @@ static unique_ptr<LocalFunctionData> WriteCSVInitializeLocal(ClientContext &cont
 
 	// create the chunk with VARCHAR types
 	vector<LogicalType> types;
-	types.resize(csv_data.names.size(), LogicalType::VARCHAR);
+	types.resize(csv_data.options.names.size(), LogicalType::VARCHAR);
 
 	local_data->cast_chunk.Initialize(types);
 	return move(local_data);
@@ -99407,11 +99485,12 @@ static unique_ptr<GlobalFunctionData> WriteCSVInitializeGlobal(ClientContext &co
 	if (options.header) {
 		BufferedSerializer serializer;
 		// write the header line to the file
-		for (idx_t i = 0; i < csv_data.names.size(); i++) {
+		for (idx_t i = 0; i < csv_data.options.names.size(); i++) {
 			if (i != 0) {
 				serializer.WriteBufferData(options.delimiter);
 			}
-			WriteQuotedString(serializer, csv_data, csv_data.names[i].c_str(), csv_data.names[i].size(), false);
+			WriteQuotedString(serializer, csv_data, csv_data.options.names[i].c_str(), csv_data.options.names[i].size(),
+			                  false);
 		}
 		serializer.WriteBufferData(csv_data.newline);
 
@@ -99464,7 +99543,7 @@ static void WriteCSVSink(ClientContext &context, FunctionData &bind_data, Global
 			// (e.g. integers only require quotes if the delimiter is a number, decimals only require quotes if the
 			// delimiter is a number or "." character)
 			WriteQuotedString(writer, csv_data, str_value.GetDataUnsafe(), str_value.GetSize(),
-			                  csv_data.force_quote[col_idx]);
+			                  csv_data.options.force_quote[col_idx]);
 		}
 		writer.WriteBufferData(csv_data.newline);
 	}
@@ -100273,74 +100352,10 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 
 	for (auto &kv : input.named_parameters) {
 		auto loption = StringUtil::Lower(kv.first);
-		if (loption == "auto_detect") {
-			options.auto_detect = BooleanValue::Get(kv.second);
-		} else if (loption == "sep" || loption == "delim") {
-			options.SetDelimiter(StringValue::Get(kv.second));
-		} else if (loption == "header") {
-			options.header = BooleanValue::Get(kv.second);
-			options.has_header = true;
-		} else if (loption == "quote") {
-			options.quote = StringValue::Get(kv.second);
-			options.has_quote = true;
-		} else if (loption == "escape") {
-			options.escape = StringValue::Get(kv.second);
-			options.has_escape = true;
-		} else if (loption == "nullstr") {
-			options.null_str = StringValue::Get(kv.second);
-		} else if (loption == "sample_size") {
-			int64_t sample_size = kv.second.GetValue<int64_t>();
-			if (sample_size < 1 && sample_size != -1) {
-				throw BinderException("Unsupported parameter for SAMPLE_SIZE: cannot be smaller than 1");
-			}
-			if (sample_size == -1) {
-				options.sample_chunks = std::numeric_limits<uint64_t>::max();
-				options.sample_chunk_size = STANDARD_VECTOR_SIZE;
-			} else if (sample_size <= STANDARD_VECTOR_SIZE) {
-				options.sample_chunk_size = sample_size;
-				options.sample_chunks = 1;
-			} else {
-				options.sample_chunk_size = STANDARD_VECTOR_SIZE;
-				options.sample_chunks = sample_size / STANDARD_VECTOR_SIZE;
-			}
-		} else if (loption == "sample_chunk_size") {
-			options.sample_chunk_size = kv.second.GetValue<int64_t>();
-			if (options.sample_chunk_size > STANDARD_VECTOR_SIZE) {
-				throw BinderException(
-				    "Unsupported parameter for SAMPLE_CHUNK_SIZE: cannot be bigger than STANDARD_VECTOR_SIZE %d",
-				    STANDARD_VECTOR_SIZE);
-			} else if (options.sample_chunk_size < 1) {
-				throw BinderException("Unsupported parameter for SAMPLE_CHUNK_SIZE: cannot be smaller than 1");
-			}
-		} else if (loption == "sample_chunks") {
-			options.sample_chunks = kv.second.GetValue<int64_t>();
-			if (options.sample_chunks < 1) {
-				throw BinderException("Unsupported parameter for SAMPLE_CHUNKS: cannot be smaller than 1");
-			}
-		} else if (loption == "all_varchar") {
-			options.all_varchar = BooleanValue::Get(kv.second);
-		} else if (loption == "dateformat") {
-			options.has_format[LogicalTypeId::DATE] = true;
-			auto &date_format = options.date_format[LogicalTypeId::DATE];
-			date_format.format_specifier = StringValue::Get(kv.second);
-			string error = StrTimeFormat::ParseFormatSpecifier(date_format.format_specifier, date_format);
-			if (!error.empty()) {
-				throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
-			}
-		} else if (loption == "timestampformat") {
-			options.has_format[LogicalTypeId::TIMESTAMP] = true;
-			auto &timestamp_format = options.date_format[LogicalTypeId::TIMESTAMP];
-			timestamp_format.format_specifier = StringValue::Get(kv.second);
-			string error = StrTimeFormat::ParseFormatSpecifier(timestamp_format.format_specifier, timestamp_format);
-			if (!error.empty()) {
-				throw InvalidInputException("Could not parse TIMESTAMPFORMAT: %s", error.c_str());
-			}
-		} else if (loption == "normalize_names") {
-			options.normalize_names = BooleanValue::Get(kv.second);
-		} else if (loption == "columns") {
+		if (loption == "columns") {
 			auto &child_type = kv.second.type();
 			if (child_type.id() != LogicalTypeId::STRUCT) {
-				throw BinderException("read_csv columns requires a a struct as input");
+				throw BinderException("read_csv columns requires a struct as input");
 			}
 			auto &struct_children = StructValue::GetChildren(kv.second);
 			D_ASSERT(StructType::GetChildCount(child_type) == struct_children.size());
@@ -100356,16 +100371,14 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 			if (names.empty()) {
 				throw BinderException("read_csv requires at least a single column as input!");
 			}
-		} else if (loption == "compression") {
-			options.compression = FileCompressionTypeFromString(StringValue::Get(kv.second));
+		} else if (loption == "all_varchar") {
+			options.all_varchar = BooleanValue::Get(kv.second);
+		} else if (loption == "normalize_names") {
+			options.normalize_names = BooleanValue::Get(kv.second);
 		} else if (loption == "filename") {
-			result->include_file_name = BooleanValue::Get(kv.second);
-		} else if (loption == "skip") {
-			options.skip_rows = kv.second.GetValue<int64_t>();
-		} else if (loption == "max_line_size" || loption == "maximum_line_size") {
-			options.maximum_line_size = kv.second.GetValue<int64_t>();
+			options.include_file_name = BooleanValue::Get(kv.second);
 		} else {
-			throw InternalException("Unrecognized parameter %s", kv.first);
+			options.SetReadOption(loption, kv.second, names);
 		}
 	}
 	if (!options.auto_detect && return_types.empty()) {
@@ -100387,7 +100400,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 		result->sql_types = return_types;
 		D_ASSERT(return_types.size() == names.size());
 	}
-	if (result->include_file_name) {
+	if (result->options.include_file_name) {
 		return_types.emplace_back(LogicalType::VARCHAR);
 		names.emplace_back("filename");
 	}
@@ -100441,7 +100454,7 @@ static void ReadCSVFunction(ClientContext &context, const FunctionData *bind_dat
 			break;
 		}
 	} while (true);
-	if (bind_data.include_file_name) {
+	if (bind_data.options.include_file_name) {
 		auto &col = output.data.back();
 		col.SetValue(0, Value(data.csv_reader->options.file_path));
 		col.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -147892,6 +147905,9 @@ unique_ptr<TableRef> SubqueryRef::Deserialize(FieldReader &reader) {
 
 namespace duckdb {
 
+TableFunctionRef::TableFunctionRef() : TableRef(TableReferenceType::TABLE_FUNCTION) {
+}
+
 string TableFunctionRef::ToString() const {
 	return BaseToString(function->ToString(), column_name_alias);
 }
@@ -159599,9 +159615,7 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 
 	if (func_catalog->type == CatalogType::TABLE_FUNCTION_ENTRY) {
 		function = (TableFunctionCatalogEntry *)func_catalog;
-
 	} else if (func_catalog->type == CatalogType::TABLE_MACRO_ENTRY) {
-
 		auto macro_func = (TableMacroCatalogEntry *)func_catalog;
 		auto query_node = BindTableMacro(*fexpr, macro_func, 0);
 		D_ASSERT(query_node);
@@ -172990,15 +173004,27 @@ static void UpdateChunk(Vector &data, Vector &updates, Vector &row_ids, idx_t co
 	case PhysicalType::INT8:
 		TemplatedUpdateLoop<int8_t>(data, updates, row_ids, count, base_index);
 		break;
+	case PhysicalType::UINT8:
+		TemplatedUpdateLoop<uint8_t>(data, updates, row_ids, count, base_index);
+		break;
 	case PhysicalType::INT16:
 		TemplatedUpdateLoop<int16_t>(data, updates, row_ids, count, base_index);
 		break;
+	case PhysicalType::UINT16:
+		TemplatedUpdateLoop<uint16_t>(data, updates, row_ids, count, base_index);
+		break;
 	case PhysicalType::INT32:
 		TemplatedUpdateLoop<int32_t>(data, updates, row_ids, count, base_index);
 		break;
+	case PhysicalType::UINT32:
+		TemplatedUpdateLoop<uint32_t>(data, updates, row_ids, count, base_index);
+		break;
 	case PhysicalType::INT64:
 		TemplatedUpdateLoop<int64_t>(data, updates, row_ids, count, base_index);
 		break;
+	case PhysicalType::UINT64:
+		TemplatedUpdateLoop<uint64_t>(data, updates, row_ids, count, base_index);
+		break;
 	case PhysicalType::FLOAT:
 		TemplatedUpdateLoop<float>(data, updates, row_ids, count, base_index);
 		break;