duckdb 0.6.2-dev772.0 → 0.6.2-dev889.0

package/src/duckdb/src/main/materialized_query_result.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 MaterializedQueryResult::MaterializedQueryResult(StatementType statement_type, StatementProperties properties,
                                                  vector<string> names_p, unique_ptr<ColumnDataCollection> collection_p,
                                                  ClientProperties client_properties)
-    : QueryResult(QueryResultType::MATERIALIZED_RESULT, statement_type, properties, collection_p->Types(),
+    : QueryResult(QueryResultType::MATERIALIZED_RESULT, statement_type, move(properties), collection_p->Types(),
                   move(names_p), move(client_properties)),
       collection(move(collection_p)), scan_initialized(false) {
 }

package/src/duckdb/src/main/prepared_statement_data.cpp

@@ -28,8 +28,7 @@ bool PreparedStatementData::RequireRebind(ClientContext &context, const vector<V
 		// parameters not yet bound: query always requires a rebind
 		return true;
 	}
-	auto &catalog = Catalog::GetCatalog(context);
-	if (catalog.GetCatalogVersion() != catalog_version) {
+	if (Catalog::GetSystemCatalog(context).GetCatalogVersion() != catalog_version) {
 		//! context is out of bounds
 		return true;
 	}

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

@@ -5,10 +5,10 @@
 
 namespace duckdb {
 
-BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type, StatementProperties properties,
+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(properties), types(move(types_p)), names(move(names_p)),
-      success(true) {
+    : type(type), statement_type(statement_type), properties(move(properties_p)), types(move(types_p)),
+      names(move(names_p)), success(true) {
 	D_ASSERT(types.size() == names.size());
 }
 
@@ -53,7 +53,7 @@ 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, properties, move(types_p), move(names_p)),
+    : BaseQueryResult(type, statement_type, move(properties), move(types_p), move(names_p)),
       client_properties(move(client_properties_p)) {
 }
 

package/src/duckdb/src/main/settings/settings.cpp

@@ -11,6 +11,8 @@
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/database.hpp"
 
 namespace duckdb {
@@ -532,7 +534,6 @@ Value ExternalThreadsSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // File Search Path
 //===--------------------------------------------------------------------===//
-
 void FileSearchPathSetting::ResetLocal(ClientContext &context) {
 	auto &client_data = ClientData::Get(context);
 	client_data.file_search_path.clear();
@@ -647,6 +648,22 @@ Value LogQueryPathSetting::GetSetting(ClientContext &context) {
 	return client_data.log_query_writer ? Value(client_data.log_query_writer->path) : Value();
 }
 
+//===--------------------------------------------------------------------===//
+// Immediate Transaction Mode
+//===--------------------------------------------------------------------===//
+void ImmediateTransactionModeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	config.options.immediate_transaction_mode = BooleanValue::Get(input);
+}
+
+void ImmediateTransactionModeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.immediate_transaction_mode = DBConfig().options.immediate_transaction_mode;
+}
+
+Value ImmediateTransactionModeSetting::GetSetting(ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+	return Value::BOOLEAN(config.options.immediate_transaction_mode);
+}
+
 //===--------------------------------------------------------------------===//
 // Maximum Expression Depth
 //===--------------------------------------------------------------------===//
@@ -845,7 +862,6 @@ Value ProgressBarTimeSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Schema
 //===--------------------------------------------------------------------===//
-
 void SchemaSetting::ResetLocal(ClientContext &context) {
 	// FIXME: catalog_search_path is controlled by both SchemaSetting and SearchPathSetting
 	auto &client_data = ClientData::Get(context);
@@ -855,7 +871,7 @@ void SchemaSetting::ResetLocal(ClientContext &context) {
 void SchemaSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = input.ToString();
 	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Set(parameter, true);
+	client_data.catalog_search_path->Set(CatalogSearchEntry::Parse(parameter), true);
 }
 
 Value SchemaSetting::GetSetting(ClientContext &context) {
@@ -865,7 +881,6 @@ Value SchemaSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Search Path
 //===--------------------------------------------------------------------===//
-
 void SearchPathSetting::ResetLocal(ClientContext &context) {
 	// FIXME: catalog_search_path is controlled by both SchemaSetting and SearchPathSetting
 	auto &client_data = ClientData::Get(context);
@@ -875,12 +890,13 @@ void SearchPathSetting::ResetLocal(ClientContext &context) {
 void SearchPathSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = input.ToString();
 	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Set(parameter, false);
+	client_data.catalog_search_path->Set(CatalogSearchEntry::ParseList(parameter), false);
 }
 
 Value SearchPathSetting::GetSetting(ClientContext &context) {
 	auto &client_data = ClientData::Get(context);
-	return Value(StringUtil::Join(client_data.catalog_search_path->GetSetPaths(), ","));
+	auto &set_paths = client_data.catalog_search_path->GetSetPaths();
+	return Value(CatalogSearchEntry::ListToString(set_paths));
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/main/stream_query_result.cpp

@@ -8,7 +8,7 @@ namespace duckdb {
 StreamQueryResult::StreamQueryResult(StatementType statement_type, StatementProperties properties,
                                      shared_ptr<ClientContext> context_p, vector<LogicalType> types,
                                      vector<string> names)
-    : QueryResult(QueryResultType::STREAM_RESULT, statement_type, properties, move(types), move(names),
+    : QueryResult(QueryResultType::STREAM_RESULT, statement_type, move(properties), move(types), move(names),
                   context_p->GetClientProperties()),
       context(move(context_p)) {
 	D_ASSERT(context);

package/src/duckdb/src/parser/expression/columnref_expression.cpp

@@ -29,13 +29,19 @@ bool ColumnRefExpression::IsQualified() const {
 }
 
 const string &ColumnRefExpression::GetColumnName() const {
-	D_ASSERT(column_names.size() <= 3);
+	D_ASSERT(column_names.size() <= 4);
 	return column_names.back();
 }
 
 const string &ColumnRefExpression::GetTableName() const {
-	D_ASSERT(column_names.size() >= 2 && column_names.size() <= 3);
-	return column_names.size() == 3 ? column_names[1] : column_names[0];
+	D_ASSERT(column_names.size() >= 2 && column_names.size() <= 4);
+	if (column_names.size() == 4) {
+		return column_names[2];
+	}
+	if (column_names.size() == 3) {
+		return column_names[1];
+	}
+	return column_names[0];
 }
 
 string ColumnRefExpression::GetName() const {

package/src/duckdb/src/parser/expression/function_expression.cpp

@@ -8,13 +8,14 @@
 
 namespace duckdb {
 
-FunctionExpression::FunctionExpression(string schema, const string &function_name,
+FunctionExpression::FunctionExpression(string catalog, string schema, const string &function_name,
                                        vector<unique_ptr<ParsedExpression>> children_p,
                                        unique_ptr<ParsedExpression> filter, unique_ptr<OrderModifier> order_bys_p,
                                        bool distinct, bool is_operator, bool export_state_p)
-    : ParsedExpression(ExpressionType::FUNCTION, ExpressionClass::FUNCTION), schema(std::move(schema)),
-      function_name(StringUtil::Lower(function_name)), is_operator(is_operator), children(move(children_p)),
-      distinct(distinct), filter(move(filter)), order_bys(move(order_bys_p)), export_state(export_state_p) {
+    : ParsedExpression(ExpressionType::FUNCTION, ExpressionClass::FUNCTION), catalog(move(catalog)),
+      schema(std::move(schema)), function_name(StringUtil::Lower(function_name)), is_operator(is_operator),
+      children(move(children_p)), distinct(distinct), filter(move(filter)), order_bys(move(order_bys_p)),
+      export_state(export_state_p) {
 	D_ASSERT(!function_name.empty());
 	if (!order_bys) {
 		order_bys = make_unique<OrderModifier>();
@@ -24,8 +25,8 @@ FunctionExpression::FunctionExpression(string schema, const string &function_nam
 FunctionExpression::FunctionExpression(const string &function_name, vector<unique_ptr<ParsedExpression>> children_p,
                                        unique_ptr<ParsedExpression> filter, unique_ptr<OrderModifier> order_bys,
                                        bool distinct, bool is_operator, bool export_state_p)
-    : FunctionExpression(INVALID_SCHEMA, function_name, move(children_p), move(filter), move(order_bys), distinct,
-                         is_operator, export_state_p) {
+    : FunctionExpression(INVALID_CATALOG, INVALID_SCHEMA, function_name, move(children_p), move(filter),
+                         move(order_bys), distinct, is_operator, export_state_p) {
 }
 
 string FunctionExpression::ToString() const {
@@ -34,7 +35,8 @@ string FunctionExpression::ToString() const {
 }
 
 bool FunctionExpression::Equals(const FunctionExpression *a, const FunctionExpression *b) {
-	if (a->schema != b->schema || a->function_name != b->function_name || b->distinct != a->distinct) {
+	if (a->catalog != b->catalog || a->schema != b->schema || a->function_name != b->function_name ||
+	    b->distinct != a->distinct) {
 		return false;
 	}
 	if (b->children.size() != a->children.size()) {
@@ -80,9 +82,8 @@ unique_ptr<ParsedExpression> FunctionExpression::Copy() const {
 		order_copy.reset(static_cast<OrderModifier *>(order_bys->Copy().release()));
 	}
 
-	auto copy = make_unique<FunctionExpression>(function_name, move(copy_children), move(filter_copy), move(order_copy),
-	                                            distinct, is_operator, export_state);
-	copy->schema = schema;
+	auto copy = make_unique<FunctionExpression>(catalog, schema, function_name, move(copy_children), move(filter_copy),
+	                                            move(order_copy), distinct, is_operator, export_state);
 	copy->CopyProperties(*this);
 	return move(copy);
 }
@@ -96,6 +97,7 @@ void FunctionExpression::Serialize(FieldWriter &writer) const {
 	writer.WriteField<bool>(distinct);
 	writer.WriteField<bool>(is_operator);
 	writer.WriteField<bool>(export_state);
+	writer.WriteString(catalog);
 }
 
 unique_ptr<ParsedExpression> FunctionExpression::Deserialize(ExpressionType type, FieldReader &reader) {
@@ -107,11 +109,11 @@ unique_ptr<ParsedExpression> FunctionExpression::Deserialize(ExpressionType type
 	auto distinct = reader.ReadRequired<bool>();
 	auto is_operator = reader.ReadRequired<bool>();
 	auto export_state = reader.ReadField<bool>(false);
+	auto catalog = reader.ReadField<string>(INVALID_CATALOG);
 
 	unique_ptr<FunctionExpression> function;
-	function = make_unique<FunctionExpression>(function_name, move(children), move(filter), move(order_bys), distinct,
-	                                           is_operator, export_state);
-	function->schema = schema;
+	function = make_unique<FunctionExpression>(catalog, schema, function_name, move(children), move(filter),
+	                                           move(order_bys), distinct, is_operator, export_state);
 	return move(function);
 }
 

package/src/duckdb/src/parser/expression/window_expression.cpp

@@ -6,8 +6,8 @@
 
 namespace duckdb {
 
-WindowExpression::WindowExpression(ExpressionType type, string schema, const string &function_name)
-    : ParsedExpression(type, ExpressionClass::WINDOW), schema(move(schema)),
+WindowExpression::WindowExpression(ExpressionType type, string catalog_name, string schema, const string &function_name)
+    : ParsedExpression(type, ExpressionClass::WINDOW), catalog(move(catalog_name)), schema(move(schema)),
       function_name(StringUtil::Lower(function_name)), ignore_nulls(false) {
 	switch (type) {
 	case ExpressionType::WINDOW_AGGREGATE:
@@ -86,7 +86,7 @@ bool WindowExpression::Equals(const WindowExpression *a, const WindowExpression
 }
 
 unique_ptr<ParsedExpression> WindowExpression::Copy() const {
-	auto new_window = make_unique<WindowExpression>(type, schema, function_name);
+	auto new_window = make_unique<WindowExpression>(type, catalog, schema, function_name);
 	new_window->CopyProperties(*this);
 
 	for (auto &child : children) {
@@ -136,12 +136,13 @@ void WindowExpression::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(default_expr);
 	writer.WriteField<bool>(ignore_nulls);
 	writer.WriteOptional(filter_expr);
+	writer.WriteString(catalog);
 }
 
 unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto function_name = reader.ReadRequired<string>();
 	auto schema = reader.ReadRequired<string>();
-	auto expr = make_unique<WindowExpression>(type, schema, function_name);
+	auto expr = make_unique<WindowExpression>(type, INVALID_CATALOG, move(schema), function_name);
 	expr->children = reader.ReadRequiredSerializableList<ParsedExpression>();
 	expr->partitions = reader.ReadRequiredSerializableList<ParsedExpression>();
 
@@ -159,6 +160,7 @@ unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type,
 	expr->default_expr = reader.ReadOptional<ParsedExpression>(nullptr);
 	expr->ignore_nulls = reader.ReadRequired<bool>();
 	expr->filter_expr = reader.ReadOptional<ParsedExpression>(nullptr);
+	expr->catalog = reader.ReadField<string>(INVALID_CATALOG);
 	return move(expr);
 }
 

package/src/duckdb/src/parser/parsed_data/alter_function_info.cpp

@@ -8,8 +8,9 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // AlterFunctionInfo
 //===--------------------------------------------------------------------===//
-AlterFunctionInfo::AlterFunctionInfo(AlterFunctionType type, string schema_p, string table_p, bool if_exists)
-    : AlterInfo(AlterType::ALTER_FUNCTION, move(move(schema_p)), move(table_p), if_exists), alter_function_type(type) {
+AlterFunctionInfo::AlterFunctionInfo(AlterFunctionType type, AlterEntryData data)
+    : AlterInfo(AlterType::ALTER_FUNCTION, move(data.catalog), move(data.schema), move(data.name), data.if_exists),
+      alter_function_type(type) {
 }
 AlterFunctionInfo::~AlterFunctionInfo() {
 }
@@ -20,6 +21,7 @@ CatalogType AlterFunctionInfo::GetCatalogType() const {
 
 void AlterFunctionInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteField<AlterFunctionType>(alter_function_type);
+	writer.WriteString(catalog);
 	writer.WriteString(schema);
 	writer.WriteString(name);
 	writer.WriteField(if_exists);
@@ -37,17 +39,15 @@ unique_ptr<AlterInfo> AlterFunctionInfo::Deserialize(FieldReader &reader) {
 //===--------------------------------------------------------------------===//
 // AddFunctionOverloadInfo
 //===--------------------------------------------------------------------===//
-AddFunctionOverloadInfo::AddFunctionOverloadInfo(string schema_p, string name_p, bool if_exists_p,
-                                                 ScalarFunctionSet new_overloads_p)
-    : AlterFunctionInfo(AlterFunctionType::ADD_FUNCTION_OVERLOADS, move(schema_p), move(name_p), if_exists_p),
-      new_overloads(move(new_overloads_p)) {
+AddFunctionOverloadInfo::AddFunctionOverloadInfo(AlterEntryData data, ScalarFunctionSet new_overloads_p)
+    : AlterFunctionInfo(AlterFunctionType::ADD_FUNCTION_OVERLOADS, move(data)), new_overloads(move(new_overloads_p)) {
 	this->allow_internal = true;
 }
 AddFunctionOverloadInfo::~AddFunctionOverloadInfo() {
 }
 
 unique_ptr<AlterInfo> AddFunctionOverloadInfo::Copy() const {
-	return make_unique_base<AlterInfo, AddFunctionOverloadInfo>(schema, name, if_exists, new_overloads);
+	return make_unique_base<AlterInfo, AddFunctionOverloadInfo>(GetAlterEntryData(), new_overloads);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/alter_info.cpp

@@ -6,8 +6,9 @@
 
 namespace duckdb {
 
-AlterInfo::AlterInfo(AlterType type, string schema_p, string name_p, bool if_exists)
-    : type(type), if_exists(if_exists), schema(move(schema_p)), name(move(name_p)), allow_internal(false) {
+AlterInfo::AlterInfo(AlterType type, string catalog_p, string schema_p, string name_p, bool if_exists)
+    : type(type), if_exists(if_exists), catalog(move(catalog_p)), schema(move(schema_p)), name(move(name_p)),
+      allow_internal(false) {
 }
 
 AlterInfo::~AlterInfo() {
@@ -43,4 +44,13 @@ unique_ptr<AlterInfo> AlterInfo::Deserialize(Deserializer &source) {
 	return result;
 }
 
+AlterEntryData AlterInfo::GetAlterEntryData() const {
+	AlterEntryData data;
+	data.catalog = catalog;
+	data.schema = schema;
+	data.name = name;
+	data.if_exists = if_exists;
+	return data;
+}
+
 } // namespace duckdb