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

package/src/duckdb/src/function/cast/vector_cast_helpers.cpp

@@ -2,6 +2,7 @@
 
 namespace duckdb {
 
+// ------- Helper functions for splitting string nested types  -------
 static bool IsNull(const char *buf, idx_t start_pos, Vector &child, idx_t row_idx) {
 	if (buf[start_pos] == 'N' && buf[start_pos + 1] == 'U' && buf[start_pos + 2] == 'L' && buf[start_pos + 3] == 'L') {
 		FlatVector::SetNull(child, row_idx, true);
@@ -16,46 +17,6 @@ inline static void SkipWhitespace(const char *buf, idx_t &pos, idx_t len) {
 	}
 }
 
-static idx_t StringTrim(const char *buf, idx_t &start_pos, idx_t pos) {
-	idx_t trailing_whitespace = 0;
-	while (StringUtil::CharacterIsSpace(buf[pos - trailing_whitespace - 1])) {
-		trailing_whitespace++;
-	}
-	if ((buf[start_pos] == '"' && buf[pos - trailing_whitespace - 1] == '"') ||
-	    (buf[start_pos] == '\'' && buf[pos - trailing_whitespace - 1] == '\'')) {
-		start_pos++;
-		trailing_whitespace++;
-	}
-	return (pos - trailing_whitespace);
-}
-
-struct CountPartOperation {
-	idx_t count = 0;
-
-	void HandleValue(const char *buf, idx_t start_pos, idx_t pos) {
-		count++;
-	}
-};
-
-struct SplitStringOperation {
-	SplitStringOperation(string_t *child_data, idx_t &child_start, Vector &child)
-	    : child_data(child_data), child_start(child_start), child(child) {
-	}
-
-	string_t *child_data;
-	idx_t &child_start;
-	Vector &child;
-
-	void HandleValue(const char *buf, idx_t start_pos, idx_t pos) {
-		if ((pos - start_pos) == 4 && IsNull(buf, start_pos, child, child_start)) {
-			child_start++;
-			return;
-		}
-		child_data[child_start] = StringVector::AddString(child, buf + start_pos, pos - start_pos);
-		child_start++;
-	}
-};
-
 static bool SkipToCloseQuotes(idx_t &pos, const char *buf, idx_t &len) {
 	char quote = buf[pos];
 	pos++;
@@ -97,8 +58,53 @@ static bool SkipToClose(idx_t &idx, const char *buf, idx_t &len, idx_t &lvl, cha
 	return false;
 }
 
+static idx_t StringTrim(const char *buf, idx_t &start_pos, idx_t pos) {
+	idx_t trailing_whitespace = 0;
+	while (StringUtil::CharacterIsSpace(buf[pos - trailing_whitespace - 1])) {
+		trailing_whitespace++;
+	}
+	if ((buf[start_pos] == '"' && buf[pos - trailing_whitespace - 1] == '"') ||
+	    (buf[start_pos] == '\'' && buf[pos - trailing_whitespace - 1] == '\'')) {
+		start_pos++;
+		trailing_whitespace++;
+	}
+	return (pos - trailing_whitespace);
+}
+
+struct CountPartOperation {
+	idx_t count = 0;
+
+	bool HandleKey(const char *buf, idx_t start_pos, idx_t pos) {
+		count++;
+		return true;
+	}
+	void HandleValue(const char *buf, idx_t start_pos, idx_t pos) {
+		count++;
+	}
+};
+
+// ------- LIST SPLIT -------
+struct SplitStringListOperation {
+	SplitStringListOperation(string_t *child_data, idx_t &child_start, Vector &child)
+	    : child_data(child_data), child_start(child_start), child(child) {
+	}
+
+	string_t *child_data;
+	idx_t &child_start;
+	Vector &child;
+
+	void HandleValue(const char *buf, idx_t start_pos, idx_t pos) {
+		if ((pos - start_pos) == 4 && IsNull(buf, start_pos, child, child_start)) {
+			child_start++;
+			return;
+		}
+		child_data[child_start] = StringVector::AddString(child, buf + start_pos, pos - start_pos);
+		child_start++;
+	}
+};
+
 template <class OP>
-static bool SplitStringifiedListInternal(const string_t &input, OP &state) {
+static bool SplitStringListInternal(const string_t &input, OP &state) {
 	const char *buf = input.GetDataUnsafe();
 	idx_t len = input.GetSize();
 	idx_t lvl = 1;
@@ -116,7 +122,7 @@ static bool SplitStringifiedListInternal(const string_t &input, OP &state) {
 			if (!SkipToClose(pos, buf, len, ++lvl, ']')) {
 				return false;
 			}
-		} else if (buf[pos] == '"' || buf[pos] == '\'') {
+		} else if ((buf[pos] == '"' || buf[pos] == '\'') && pos == start_pos) {
 			SkipToCloseQuotes(pos, buf, len);
 		} else if (buf[pos] == '{') {
 			idx_t struct_lvl = 0;
@@ -143,19 +149,121 @@ static bool SplitStringifiedListInternal(const string_t &input, OP &state) {
 	return (pos == len && lvl == 0);
 }
 
-bool VectorStringToList::SplitStringifiedList(const string_t &input, string_t *child_data, idx_t &child_start,
-                                              Vector &child) {
-	SplitStringOperation state(child_data, child_start, child);
-	return SplitStringifiedListInternal<SplitStringOperation>(input, state);
+bool VectorStringToList::SplitStringList(const string_t &input, string_t *child_data, idx_t &child_start,
+                                         Vector &child) {
+	SplitStringListOperation state(child_data, child_start, child);
+	return SplitStringListInternal<SplitStringListOperation>(input, state);
+}
+
+idx_t VectorStringToList::CountPartsList(const string_t &input) {
+	CountPartOperation state;
+	SplitStringListInternal<CountPartOperation>(input, state);
+	return state.count;
+}
+
+// ------- MAP SPLIT -------
+struct SplitStringMapOperation {
+	SplitStringMapOperation(string_t *child_key_data, string_t *child_val_data, idx_t &child_start, Vector &varchar_key,
+	                        Vector &varchar_val)
+	    : child_key_data(child_key_data), child_val_data(child_val_data), child_start(child_start),
+	      varchar_key(varchar_key), varchar_val(varchar_val) {
+	}
+
+	string_t *child_key_data;
+	string_t *child_val_data;
+	idx_t &child_start;
+	Vector &varchar_key;
+	Vector &varchar_val;
+
+	bool HandleKey(const char *buf, idx_t start_pos, idx_t pos) {
+		if ((pos - start_pos) == 4 && IsNull(buf, start_pos, varchar_key, child_start)) {
+			FlatVector::SetNull(varchar_val, child_start, true);
+			child_start++;
+			return false;
+		}
+		child_key_data[child_start] = StringVector::AddString(varchar_key, buf + start_pos, pos - start_pos);
+		return true;
+	}
+
+	void HandleValue(const char *buf, idx_t start_pos, idx_t pos) {
+		if ((pos - start_pos) == 4 && IsNull(buf, start_pos, varchar_val, child_start)) {
+			child_start++;
+			return;
+		}
+		child_val_data[child_start] = StringVector::AddString(varchar_val, buf + start_pos, pos - start_pos);
+		child_start++;
+	}
+};
+
+template <class OP>
+static bool FindKeyOrValueMap(const char *buf, idx_t len, idx_t &pos, OP &state, bool key) {
+	auto start_pos = pos;
+	idx_t lvl = 0;
+	while (pos < len) {
+		if (buf[pos] == '"' || buf[pos] == '\'') {
+			SkipToCloseQuotes(pos, buf, len);
+		} else if (buf[pos] == '{') {
+			SkipToClose(pos, buf, len, lvl, '}');
+		} else if (buf[pos] == '[') {
+			SkipToClose(pos, buf, len, lvl, ']');
+		} else if (key && buf[pos] == '=') {
+			idx_t end_pos = StringTrim(buf, start_pos, pos);
+			return state.HandleKey(buf, start_pos, end_pos); // put string in KEY_child_vector
+		} else if (!key && (buf[pos] == ',' || buf[pos] == '}')) {
+			idx_t end_pos = StringTrim(buf, start_pos, pos);
+			state.HandleValue(buf, start_pos, end_pos); // put string in VALUE_child_vector
+			return true;
+		}
+		pos++;
+	}
+	return false;
+}
+
+template <class OP>
+static bool SplitStringMapInternal(const string_t &input, OP &state) {
+	const char *buf = input.GetDataUnsafe();
+	idx_t len = input.GetSize();
+	idx_t pos = 0;
+
+	SkipWhitespace(buf, pos, len);
+	if (pos == len || buf[pos] != '{') {
+		return false;
+	}
+	SkipWhitespace(buf, ++pos, len);
+	if (pos == len) {
+		return false;
+	}
+	if (buf[pos] == '}') {
+		SkipWhitespace(buf, ++pos, len);
+		return (pos == len);
+	}
+	while (pos < len) {
+		if (!FindKeyOrValueMap(buf, len, pos, state, true)) {
+			return false;
+		}
+		SkipWhitespace(buf, ++pos, len);
+		if (!FindKeyOrValueMap(buf, len, pos, state, false)) {
+			return false;
+		}
+		SkipWhitespace(buf, ++pos, len);
+	}
+	return true;
+}
+
+bool VectorStringToMap::SplitStringMap(const string_t &input, string_t *child_key_data, string_t *child_val_data,
+                                       idx_t &child_start, Vector &varchar_key, Vector &varchar_val) {
+	SplitStringMapOperation state(child_key_data, child_val_data, child_start, varchar_key, varchar_val);
+	return SplitStringMapInternal<SplitStringMapOperation>(input, state);
 }
 
-idx_t VectorStringToList::CountParts(const string_t &input) {
+idx_t VectorStringToMap::CountPartsMap(const string_t &input) {
 	CountPartOperation state;
-	SplitStringifiedListInternal<CountPartOperation>(input, state);
+	SplitStringMapInternal<CountPartOperation>(input, state);
 	return state.count;
 }
 
-static bool FindKey(const char *buf, idx_t len, idx_t &pos) {
+// ------- STRUCT SPLIT -------
+static bool FindKeyStruct(const char *buf, idx_t len, idx_t &pos) {
 	while (pos < len) {
 		if (buf[pos] == ':') {
 			return true;
@@ -165,8 +273,8 @@ static bool FindKey(const char *buf, idx_t len, idx_t &pos) {
 	return false;
 }
 
-static bool FindValue(const char *buf, idx_t len, idx_t &pos, Vector &varchar_child, idx_t &row_idx,
-                      ValidityMask *child_mask) {
+static bool FindValueStruct(const char *buf, idx_t len, idx_t &pos, Vector &varchar_child, idx_t &row_idx,
+                            ValidityMask *child_mask) {
 	auto start_pos = pos;
 	idx_t lvl = 0;
 	while (pos < len) {
@@ -209,7 +317,7 @@ bool VectorStringToStruct::SplitStruct(string_t &input, std::vector<std::unique_
 	} else {
 		while (pos < len) {
 			auto key_start = pos;
-			if (!FindKey(buf, len, pos)) {
+			if (!FindKeyStruct(buf, len, pos)) {
 				return false;
 			}
 			auto key_end = StringTrim(buf, key_start, pos);
@@ -221,7 +329,7 @@ bool VectorStringToStruct::SplitStruct(string_t &input, std::vector<std::unique_
 			}
 			child_idx = it->second;
 			SkipWhitespace(buf, ++pos, len);
-			if (!FindValue(buf, len, pos, *varchar_vectors[child_idx], row_idx, child_masks[child_idx])) {
+			if (!FindValueStruct(buf, len, pos, *varchar_vectors[child_idx], row_idx, child_masks[child_idx])) {
 				return false;
 			}
 			SkipWhitespace(buf, ++pos, len);

package/src/duckdb/src/function/cast_rules.cpp

@@ -215,13 +215,8 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 		// Implicit cast not allowed from BLOB to VARCHAR
 		return -1;
 	}
-	if ((from.id() == LogicalTypeId::VARCHAR && to.id() == LogicalTypeId::JSON) ||
-	    (from.id() == LogicalTypeId::JSON && to.id() == LogicalTypeId::VARCHAR)) {
-		// Virtually no cost, just a different tag
-		return 1;
-	}
-	if (to.id() == LogicalTypeId::VARCHAR || to.id() == LogicalTypeId::JSON) {
-		// everything can be cast to VARCHAR/JSON, but this cast has a high cost
+	if (to.id() == LogicalTypeId::VARCHAR) {
+		// everything can be cast to VARCHAR, but this cast has a high cost
 		return TargetTypeCost(to);
 	}
 	if (from.id() == LogicalTypeId::LIST && to.id() == LogicalTypeId::LIST) {

package/src/duckdb/src/function/function.cpp

@@ -34,13 +34,13 @@ bool TableFunctionData::Equals(const FunctionData &other) const {
 	return false;
 }
 
-Function::Function(string name_p) : name(move(name_p)) {
+Function::Function(string name_p) : name(std::move(name_p)) {
 }
 Function::~Function() {
 }
 
 SimpleFunction::SimpleFunction(string name_p, vector<LogicalType> arguments_p, LogicalType varargs_p)
-    : Function(move(name_p)), arguments(move(arguments_p)), varargs(move(varargs_p)) {
+    : Function(std::move(name_p)), arguments(std::move(arguments_p)), varargs(std::move(varargs_p)) {
 }
 
 SimpleFunction::~SimpleFunction() {
@@ -56,7 +56,7 @@ bool SimpleFunction::HasVarArgs() const {
 
 SimpleNamedParameterFunction::SimpleNamedParameterFunction(string name_p, vector<LogicalType> arguments_p,
                                                            LogicalType varargs_p)
-    : SimpleFunction(move(name_p), move(arguments_p), move(varargs_p)) {
+    : SimpleFunction(std::move(name_p), std::move(arguments_p), std::move(varargs_p)) {
 }
 
 SimpleNamedParameterFunction::~SimpleNamedParameterFunction() {
@@ -73,8 +73,8 @@ bool SimpleNamedParameterFunction::HasNamedParameters() {
 BaseScalarFunction::BaseScalarFunction(string name_p, vector<LogicalType> arguments_p, LogicalType return_type_p,
                                        FunctionSideEffects side_effects, LogicalType varargs_p,
                                        FunctionNullHandling null_handling)
-    : SimpleFunction(move(name_p), move(arguments_p), move(varargs_p)), return_type(move(return_type_p)),
-      side_effects(side_effects), null_handling(null_handling) {
+    : SimpleFunction(std::move(name_p), std::move(arguments_p), std::move(varargs_p)),
+      return_type(std::move(return_type_p)), side_effects(side_effects), null_handling(null_handling) {
 }
 
 BaseScalarFunction::~BaseScalarFunction() {

package/src/duckdb/src/function/function_binder.cpp

@@ -238,7 +238,7 @@ void FunctionBinder::CastToFunctionArguments(SimpleFunction &function, vector<un
 		// except for one special case: if the function accepts ANY argument
 		// in that case we don't add a cast
 		if (cast_result == LogicalTypeComparisonResult::DIFFERENT_TYPES) {
-			children[i] = BoundCastExpression::AddCastToType(context, move(children[i]), target_type);
+			children[i] = BoundCastExpression::AddCastToType(context, std::move(children[i]), target_type);
 		}
 	}
 }
@@ -250,7 +250,7 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(const string &schema,
 	auto function =
 	    Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, schema, name);
 	D_ASSERT(function && function->type == CatalogType::SCALAR_FUNCTION_ENTRY);
-	return BindScalarFunction((ScalarFunctionCatalogEntry &)*function, move(children), error, is_operator, binder);
+	return BindScalarFunction((ScalarFunctionCatalogEntry &)*function, std::move(children), error, is_operator, binder);
 }
 
 unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogEntry &func,
@@ -272,7 +272,7 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogE
 			}
 		}
 	}
-	return BindScalarFunction(bound_function, move(children), is_operator);
+	return BindScalarFunction(bound_function, std::move(children), is_operator);
 }
 
 unique_ptr<BoundFunctionExpression> FunctionBinder::BindScalarFunction(ScalarFunction bound_function,
@@ -287,8 +287,8 @@ unique_ptr<BoundFunctionExpression> FunctionBinder::BindScalarFunction(ScalarFun
 
 	// now create the function
 	auto return_type = bound_function.return_type;
-	return make_unique<BoundFunctionExpression>(move(return_type), move(bound_function), move(children),
-	                                            move(bind_info), is_operator);
+	return make_unique<BoundFunctionExpression>(std::move(return_type), std::move(bound_function), std::move(children),
+	                                            std::move(bind_info), is_operator);
 }
 
 unique_ptr<BoundAggregateExpression> FunctionBinder::BindAggregateFunction(AggregateFunction bound_function,
@@ -309,11 +309,11 @@ unique_ptr<BoundAggregateExpression> FunctionBinder::BindAggregateFunction(Aggre
 	// Special case: for ORDER BY aggregates, we wrap the aggregate function in a SortedAggregateFunction
 	// The children are the sort clauses and the binding contains the ordering data.
 	if (order_bys && !order_bys->orders.empty()) {
-		bind_info = BindSortedAggregate(bound_function, children, move(bind_info), move(order_bys));
+		bind_info = BindSortedAggregate(bound_function, children, std::move(bind_info), std::move(order_bys));
 	}
 
-	return make_unique<BoundAggregateExpression>(move(bound_function), move(children), move(filter), move(bind_info),
-	                                             aggr_type);
+	return make_unique<BoundAggregateExpression>(std::move(bound_function), std::move(children), std::move(filter),
+	                                             std::move(bind_info), aggr_type);
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/function_set.cpp

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-ScalarFunctionSet::ScalarFunctionSet(string name) : FunctionSet(move(name)) {
+ScalarFunctionSet::ScalarFunctionSet(string name) : FunctionSet(std::move(name)) {
 }
 
 ScalarFunction ScalarFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {
@@ -17,7 +17,7 @@ ScalarFunction ScalarFunctionSet::GetFunctionByArguments(ClientContext &context,
 	return GetFunctionByOffset(index);
 }
 
-AggregateFunctionSet::AggregateFunctionSet(string name) : FunctionSet(move(name)) {
+AggregateFunctionSet::AggregateFunctionSet(string name) : FunctionSet(std::move(name)) {
 }
 
 AggregateFunction AggregateFunctionSet::GetFunctionByArguments(ClientContext &context,
@@ -50,7 +50,7 @@ AggregateFunction AggregateFunctionSet::GetFunctionByArguments(ClientContext &co
 	return GetFunctionByOffset(index);
 }
 
-TableFunctionSet::TableFunctionSet(string name) : FunctionSet(move(name)) {
+TableFunctionSet::TableFunctionSet(string name) : FunctionSet(std::move(name)) {
 }
 
 TableFunction TableFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {

package/src/duckdb/src/function/macro_function.cpp

@@ -11,7 +11,7 @@
 
 namespace duckdb {
 
-// MacroFunction::MacroFunction(unique_ptr<ParsedExpression> expression) : expression(move(expression)) {}
+// MacroFunction::MacroFunction(unique_ptr<ParsedExpression> expression) : expression(std::move(expression)) {}
 
 MacroFunction::MacroFunction(MacroType type) : type(type) {
 }
@@ -22,20 +22,19 @@ string MacroFunction::ValidateArguments(MacroFunction &macro_def, const string &
 
 	// separate positional and default arguments
 	for (auto &arg : function_expr.children) {
-		if ((arg->type == ExpressionType::VALUE_CONSTANT || arg->type == ExpressionType::VALUE_PARAMETER) &&
-		    !arg->alias.empty()) {
+		if (!arg->alias.empty()) {
 			// default argument
-			if (macro_def.default_parameters.find(arg->alias) == macro_def.default_parameters.end()) {
+			if (!macro_def.default_parameters.count(arg->alias)) {
 				return StringUtil::Format("Macro %s does not have default parameter %s!", name, arg->alias);
-			} else if (defaults.find(arg->alias) != defaults.end()) {
+			} else if (defaults.count(arg->alias)) {
 				return StringUtil::Format("Duplicate default parameters %s!", arg->alias);
 			}
-			defaults[arg->alias] = move(arg);
+			defaults[arg->alias] = std::move(arg);
 		} else if (!defaults.empty()) {
 			return "Positional parameters cannot come after parameters with a default value!";
 		} else {
 			// positional argument
-			positionals.push_back(move(arg));
+			positionals.push_back(std::move(arg));
 		}
 	}
 
@@ -57,10 +56,13 @@ string MacroFunction::ValidateArguments(MacroFunction &macro_def, const string &
 		return error;
 	}
 
-	// fill in default value where this was not supplied
+	// Add the default values for parameters that have defaults, that were not explicitly assigned to
 	for (auto it = macro_def.default_parameters.begin(); it != macro_def.default_parameters.end(); it++) {
-		if (defaults.find(it->first) == defaults.end()) {
-			defaults[it->first] = it->second->Copy();
+		auto &parameter_name = it->first;
+		auto &parameter_default = it->second;
+		if (!defaults.count(parameter_name)) {
+			// This parameter was not set yet, set it with the default value
+			defaults[parameter_name] = parameter_default->Copy();
 		}
 	}
 

package/src/duckdb/src/function/pragma/pragma_functions.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/function/function_set.hpp"
 
 #include <cctype>
 

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -1,6 +1,9 @@
 #include "duckdb/function/pragma/pragma_functions.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/file_system.hpp"
+#include "duckdb/parser/statement/export_statement.hpp"
+#include "duckdb/parser/statement/copy_statement.hpp"
+#include "duckdb/parser/parser.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
@@ -29,7 +32,7 @@ string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters
 }
 
 string PragmaShowDatabases(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT name FROM pragma_database_list() ORDER BY name;";
+	return "SELECT database_name FROM duckdb_databases() WHERE NOT internal ORDER BY database_name;";
 }
 
 string PragmaAllProfiling(ClientContext &context, const FunctionParameters &parameters) {
@@ -38,7 +41,7 @@ string PragmaAllProfiling(ClientContext &context, const FunctionParameters &para
 }
 
 string PragmaDatabaseList(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT * FROM pragma_database_list() ORDER BY 1;";
+	return "SELECT * FROM pragma_database_list;";
 }
 
 string PragmaCollations(ClientContext &context, const FunctionParameters &parameters) {
@@ -73,7 +76,7 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 	auto &fs = FileSystem::GetFileSystem(context);
 	auto *opener = FileSystem::GetFileOpener(context);
 
-	string query;
+	string final_query;
 	// read the "shema.sql" and "load.sql" files
 	vector<string> files = {"schema.sql", "load.sql"};
 	for (auto &file : files) {
@@ -83,10 +86,25 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 		auto fsize = fs.GetFileSize(*handle);
 		auto buffer = unique_ptr<char[]>(new char[fsize]);
 		fs.Read(*handle, buffer.get(), fsize);
-
-		query += string(buffer.get(), fsize);
+		auto query = string(buffer.get(), fsize);
+		// Replace the placeholder with the path provided to IMPORT
+		if (file == "load.sql") {
+			Parser parser;
+			parser.ParseQuery(query);
+			auto copy_statements = std::move(parser.statements);
+			query.clear();
+			for (auto &statement_p : copy_statements) {
+				D_ASSERT(statement_p->type == StatementType::COPY_STATEMENT);
+				auto &statement = (CopyStatement &)*statement_p;
+				auto &info = *statement.info;
+				auto file_name = fs.ExtractName(info.file_path);
+				info.file_path = fs.JoinPath(parameters.values[0].ToString(), file_name);
+				query += statement.ToString() + ";";
+			}
+		}
+		final_query += query;
 	}
-	return query;
+	return final_query;
 }
 
 string PragmaDatabaseSize(ClientContext &context, const FunctionParameters &parameters) {

package/src/duckdb/src/function/pragma_function.cpp

@@ -5,28 +5,29 @@ namespace duckdb {
 
 PragmaFunction::PragmaFunction(string name, PragmaType pragma_type, pragma_query_t query, pragma_function_t function,
                                vector<LogicalType> arguments, LogicalType varargs)
-    : SimpleNamedParameterFunction(move(name), move(arguments), move(varargs)), type(pragma_type), query(query),
-      function(function) {
+    : SimpleNamedParameterFunction(std::move(name), std::move(arguments), std::move(varargs)), type(pragma_type),
+      query(query), function(function) {
 }
 
 PragmaFunction PragmaFunction::PragmaCall(const string &name, pragma_query_t query, vector<LogicalType> arguments,
                                           LogicalType varargs) {
-	return PragmaFunction(name, PragmaType::PRAGMA_CALL, query, nullptr, move(arguments), move(varargs));
+	return PragmaFunction(name, PragmaType::PRAGMA_CALL, query, nullptr, std::move(arguments), std::move(varargs));
 }
 
 PragmaFunction PragmaFunction::PragmaCall(const string &name, pragma_function_t function, vector<LogicalType> arguments,
                                           LogicalType varargs) {
-	return PragmaFunction(name, PragmaType::PRAGMA_CALL, nullptr, function, move(arguments), move(varargs));
+	return PragmaFunction(name, PragmaType::PRAGMA_CALL, nullptr, function, std::move(arguments), std::move(varargs));
 }
 
 PragmaFunction PragmaFunction::PragmaStatement(const string &name, pragma_query_t query) {
 	vector<LogicalType> types;
-	return PragmaFunction(name, PragmaType::PRAGMA_STATEMENT, query, nullptr, move(types), LogicalType::INVALID);
+	return PragmaFunction(name, PragmaType::PRAGMA_STATEMENT, query, nullptr, std::move(types), LogicalType::INVALID);
 }
 
 PragmaFunction PragmaFunction::PragmaStatement(const string &name, pragma_function_t function) {
 	vector<LogicalType> types;
-	return PragmaFunction(name, PragmaType::PRAGMA_STATEMENT, nullptr, function, move(types), LogicalType::INVALID);
+	return PragmaFunction(name, PragmaType::PRAGMA_STATEMENT, nullptr, function, std::move(types),
+	                      LogicalType::INVALID);
 }
 
 string PragmaFunction::ToString() {

package/src/duckdb/src/function/scalar/date/date_part.cpp

@@ -172,7 +172,7 @@ static unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<uniqu
 	} else if (child_stats[0]->validity_stats) {
 		result->validity_stats = child_stats[0]->validity_stats->Copy();
 	}
-	return move(result);
+	return std::move(result);
 }
 
 struct DatePart {
@@ -203,7 +203,7 @@ struct DatePart {
 		if (child_stats[0]->validity_stats) {
 			result->validity_stats = child_stats[0]->validity_stats->Copy();
 		}
-		return move(result);
+		return std::move(result);
 	}
 
 	template <typename OP>
@@ -1217,10 +1217,10 @@ void AddGenericDatePartOperator(BuiltinFunctions &set, const string &name, scala
                                 function_statistics_t date_stats, function_statistics_t ts_stats) {
 	ScalarFunctionSet operator_set(name);
 	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, move(date_func), nullptr, nullptr, date_stats));
+	    ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, std::move(date_func), nullptr, nullptr, date_stats));
 	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, move(ts_func), nullptr, nullptr, ts_stats));
-	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, move(interval_func)));
+	    ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr, nullptr, ts_stats));
+	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func)));
 	set.AddFunction(operator_set);
 }
 
@@ -1238,12 +1238,12 @@ void AddGenericTimePartOperator(BuiltinFunctions &set, const string &name, scala
                                 function_statistics_t time_stats) {
 	ScalarFunctionSet operator_set(name);
 	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, move(date_func), nullptr, nullptr, date_stats));
+	    ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, std::move(date_func), nullptr, nullptr, date_stats));
 	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, move(ts_func), nullptr, nullptr, ts_stats));
-	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, move(interval_func)));
+	    ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr, nullptr, ts_stats));
+	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func)));
 	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIME}, LogicalType::BIGINT, move(time_func), nullptr, nullptr, time_stats));
+	    ScalarFunction({LogicalType::TIME}, LogicalType::BIGINT, std::move(time_func), nullptr, nullptr, time_stats));
 	set.AddFunction(operator_set);
 }
 
@@ -1340,7 +1340,7 @@ struct StructDatePart {
 		}
 
 		Function::EraseArgument(bound_function, arguments, 0);
-		bound_function.return_type = LogicalType::STRUCT(move(struct_children));
+		bound_function.return_type = LogicalType::STRUCT(std::move(struct_children));
 		return make_unique<BindData>(bound_function.return_type, part_codes);
 	}
 
@@ -1464,7 +1464,7 @@ struct StructDatePart {
 	                                                    ScalarFunction &bound_function) {
 		auto stype = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 		auto part_codes = reader.ReadRequiredList<DatePartSpecifier>();
-		return make_unique<BindData>(move(stype), move(part_codes));
+		return make_unique<BindData>(std::move(stype), std::move(part_codes));
 	}
 
 	template <typename INPUT_TYPE>

package/src/duckdb/src/function/scalar/date/date_trunc.cpp

@@ -614,7 +614,7 @@ static unique_ptr<BaseStatistics> DateTruncStatistics(vector<unique_ptr<BaseStat
 	if (child_stats[0]->validity_stats) {
 		result->validity_stats = child_stats[1]->validity_stats->Copy();
 	}
-	return move(result);
+	return std::move(result);
 }
 
 template <class TA, class TR, class OP>