duckdb 0.2.10-dev451.0 → 0.2.10-dev468.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.2.10-dev451.0",
+  "version": "0.2.10-dev468.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -1760,7 +1760,7 @@ public:
 namespace duckdb {
 
 struct CreateMacroInfo : public CreateFunctionInfo {
-	CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY) {
+	CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
 	}
 
 	unique_ptr<MacroFunction> function;
@@ -2025,8 +2025,8 @@ namespace duckdb {
 
 struct CreateSequenceInfo : public CreateInfo {
 	CreateSequenceInfo()
-	    : CreateInfo(CatalogType::SEQUENCE_ENTRY), name(string()), usage_count(0), increment(1), min_value(1),
-	      max_value(NumericLimits<int64_t>::Maximum()), start_value(1), cycle(false) {
+	    : CreateInfo(CatalogType::SEQUENCE_ENTRY, INVALID_SCHEMA), name(string()), usage_count(0), increment(1),
+	      min_value(1), max_value(NumericLimits<int64_t>::Maximum()), start_value(1), cycle(false) {
 	}
 
 	//! Sequence name to create
@@ -2049,6 +2049,7 @@ public:
 		auto result = make_unique<CreateSequenceInfo>();
 		CopyProperties(*result);
 		result->name = name;
+		result->schema = schema;
 		result->usage_count = usage_count;
 		result->increment = increment;
 		result->min_value = min_value;
@@ -2290,6 +2291,44 @@ private:
 } // namespace duckdb
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_search_path.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include <functional>
+
+
+
+
+
+namespace duckdb {
+
+class ClientContext;
+
+//! The schema search path, in order by which entries are searched if no schema entry is provided
+class CatalogSearchPath {
+public:
+	explicit CatalogSearchPath(ClientContext &client_p);
+	CatalogSearchPath(const CatalogSearchPath &other) = delete;
+
+	const vector<string> &Get();
+	const string &GetDefault();
+
+private:
+	static vector<string> ParsePaths(const string &value);
+	ClientContext &context;
+	string last_value;
+	vector<string> paths;
+};
+
+} // namespace duckdb
+
 
 
 //===----------------------------------------------------------------------===//
@@ -2678,7 +2717,7 @@ public:
 namespace duckdb {
 
 struct CreateViewInfo : public CreateInfo {
-	CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY) {
+	CreateViewInfo() : CreateInfo(CatalogType::VIEW_ENTRY, INVALID_SCHEMA) {
 	}
 	CreateViewInfo(string schema, string view_name)
 	    : CreateInfo(CatalogType::VIEW_ENTRY, schema), view_name(view_name) {
@@ -4606,6 +4645,12 @@ public:
 
 namespace duckdb {
 
+string SimilarCatalogEntry::GetQualifiedName() const {
+	D_ASSERT(Found());
+
+	return name + "." + schema->name;
+}
+
 Catalog::Catalog(DatabaseInstance &db)
     : db(db), schemas(make_unique<CatalogSet>(*this, make_unique<DefaultSchemaGenerator>(*this))),
       dependency_manager(make_unique<DependencyManager>(*this)) {
@@ -4728,23 +4773,25 @@ void Catalog::DropEntry(ClientContext &context, DropInfo *info) {
 	if (info->type == CatalogType::SCHEMA_ENTRY) {
 		// DROP SCHEMA
 		DropSchema(context, info);
-	} else {
-		if (info->schema.empty()) {
-			info->schema = DEFAULT_SCHEMA;
-		}
-		auto schema = GetSchema(context, info->schema);
-		schema->DropEntry(context, info);
+		return;
+	}
+
+	auto lookup = LookupEntry(context, info->type, info->schema, info->name, info->if_exists);
+	if (!lookup.Found()) {
+		return;
 	}
+
+	lookup.schema->DropEntry(context, info);
 }
 
-SchemaCatalogEntry *Catalog::GetSchema(ClientContext &context, const string &schema_name,
+SchemaCatalogEntry *Catalog::GetSchema(ClientContext &context, const string &schema_name, bool if_exists,
                                        QueryErrorContext error_context) {
 	D_ASSERT(!schema_name.empty());
 	if (schema_name == TEMP_SCHEMA) {
 		return context.temporary_objects.get();
 	}
 	auto entry = schemas->GetEntry(context, schema_name);
-	if (!entry) {
+	if (!entry && !if_exists) {
 		throw CatalogException(error_context.FormatError("Schema with name %s does not exist!", schema_name));
 	}
 	return (SchemaCatalogEntry *)entry;
@@ -4755,29 +4802,99 @@ void Catalog::ScanSchemas(ClientContext &context, std::function<void(CatalogEntr
 	schemas->Scan(context, [&](CatalogEntry *entry) { callback(entry); });
 }
 
-CatalogEntry *Catalog::GetEntry(ClientContext &context, CatalogType type, string schema_name, const string &name,
-                                bool if_exists, QueryErrorContext error_context) {
-	if (schema_name.empty()) {
-		// no schema provided: check the catalog search path in order
-		if (context.catalog_search_path.empty()) {
-			throw InternalException("Empty catalog search path");
+SimilarCatalogEntry Catalog::SimilarEntryInSchemas(ClientContext &context, const string &entry_name, CatalogType type,
+                                                   const vector<SchemaCatalogEntry *> &schemas) {
+
+	vector<CatalogSet *> sets;
+	std::transform(schemas.begin(), schemas.end(), std::back_inserter(sets),
+	               [type](SchemaCatalogEntry *s) -> CatalogSet * { return &s->GetCatalogSet(type); });
+	pair<string, idx_t> most_similar {"", (idx_t)-1};
+	SchemaCatalogEntry *schema_of_most_similar = nullptr;
+	for (auto schema : schemas) {
+		auto entry = schema->GetCatalogSet(type).SimilarEntry(context, entry_name);
+		if (!entry.first.empty() && (most_similar.first.empty() || most_similar.second > entry.second)) {
+			most_similar = entry;
+			schema_of_most_similar = schema;
 		}
-		schema_name = DEFAULT_SCHEMA;
-		for (idx_t i = 0; i < context.catalog_search_path.size(); i++) {
-			auto entry = GetEntry(context, type, context.catalog_search_path[i], name, true);
-			if (entry) {
-				return entry;
+	}
+
+	return {most_similar.first, most_similar.second, schema_of_most_similar};
+}
+
+CatalogException Catalog::CreateMissingEntryException(ClientContext &context, const string &entry_name,
+                                                      CatalogType type, const vector<SchemaCatalogEntry *> &schemas,
+                                                      QueryErrorContext error_context) {
+	auto entry = SimilarEntryInSchemas(context, entry_name, type, schemas);
+
+	vector<SchemaCatalogEntry *> unseen_schemas;
+	this->schemas->Scan([&schemas, &unseen_schemas](CatalogEntry *entry) {
+		auto schema_entry = (SchemaCatalogEntry *)entry;
+		if (std::find(schemas.begin(), schemas.end(), schema_entry) == schemas.end()) {
+			unseen_schemas.emplace_back(schema_entry);
+		}
+	});
+	auto unseen_entry = SimilarEntryInSchemas(context, entry_name, type, unseen_schemas);
+
+	string did_you_mean;
+	if (unseen_entry.Found() && unseen_entry.distance < entry.distance) {
+		did_you_mean = "\nDid you mean \"" + unseen_entry.GetQualifiedName() + "\"?";
+	} else if (entry.Found()) {
+		did_you_mean = "\nDid you mean \"" + entry.name + "\"?";
+	}
+
+	return CatalogException(error_context.FormatError("%s with name %s does not exist!%s", CatalogTypeToString(type),
+	                                                  entry_name, did_you_mean));
+}
+
+CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type, const string &schema_name,
+                                        const string &name, bool if_exists, QueryErrorContext error_context) {
+	if (!schema_name.empty()) {
+		auto schema = GetSchema(context, schema_name, if_exists, error_context);
+		if (!schema) {
+			D_ASSERT(if_exists);
+			return {nullptr, nullptr};
+		}
+
+		auto entry = schema->GetCatalogSet(type).GetEntry(context, name);
+		if (!entry && !if_exists) {
+			throw CreateMissingEntryException(context, name, type, {schema}, error_context);
+		}
+
+		return {schema, entry};
+	}
+
+	const auto &paths = context.catalog_search_path->Get();
+	for (const auto &path : paths) {
+		auto lookup = LookupEntry(context, type, path, name, true, error_context);
+		if (lookup.Found()) {
+			return lookup;
+		}
+	}
+
+	if (!if_exists) {
+		vector<SchemaCatalogEntry *> schemas;
+		for (const auto &path : paths) {
+			auto schema = GetSchema(context, path, true);
+			if (schema) {
+				schemas.emplace_back(schema);
 			}
 		}
+
+		throw CreateMissingEntryException(context, name, type, schemas, error_context);
 	}
-	auto schema = GetSchema(context, schema_name, error_context);
-	return schema->GetEntry(context, type, name, if_exists, error_context);
+
+	return {nullptr, nullptr};
+}
+
+CatalogEntry *Catalog::GetEntry(ClientContext &context, CatalogType type, const string &schema_name, const string &name,
+                                bool if_exists, QueryErrorContext error_context) {
+	return LookupEntry(context, type, schema_name, name, if_exists, error_context).entry;
 }
 
 template <>
-TableCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name, bool if_exists,
-                                     QueryErrorContext error_context) {
-	auto entry = GetEntry(context, CatalogType::TABLE_ENTRY, move(schema_name), name, if_exists);
+TableCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
+                                     bool if_exists, QueryErrorContext error_context) {
+	auto entry = GetEntry(context, CatalogType::TABLE_ENTRY, schema_name, name, if_exists);
 	if (!entry) {
 		return nullptr;
 	}
@@ -4788,38 +4905,37 @@ TableCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name,
 }
 
 template <>
-SequenceCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name, bool if_exists,
-                                        QueryErrorContext error_context) {
-	return (SequenceCatalogEntry *)GetEntry(context, CatalogType::SEQUENCE_ENTRY, move(schema_name), name, if_exists,
+SequenceCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
+                                        bool if_exists, QueryErrorContext error_context) {
+	return (SequenceCatalogEntry *)GetEntry(context, CatalogType::SEQUENCE_ENTRY, schema_name, name, if_exists,
 	                                        error_context);
 }
 
 template <>
-TableFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name,
+TableFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
                                              bool if_exists, QueryErrorContext error_context) {
-	return (TableFunctionCatalogEntry *)GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, move(schema_name), name,
+	return (TableFunctionCatalogEntry *)GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, schema_name, name,
 	                                             if_exists, error_context);
 }
 
 template <>
-CopyFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name,
+CopyFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
                                             bool if_exists, QueryErrorContext error_context) {
-	return (CopyFunctionCatalogEntry *)GetEntry(context, CatalogType::COPY_FUNCTION_ENTRY, move(schema_name), name,
-	                                            if_exists, error_context);
+	return (CopyFunctionCatalogEntry *)GetEntry(context, CatalogType::COPY_FUNCTION_ENTRY, schema_name, name, if_exists,
+	                                            error_context);
 }
 
 template <>
-PragmaFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name,
+PragmaFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
                                               bool if_exists, QueryErrorContext error_context) {
-	return (PragmaFunctionCatalogEntry *)GetEntry(context, CatalogType::PRAGMA_FUNCTION_ENTRY, move(schema_name), name,
+	return (PragmaFunctionCatalogEntry *)GetEntry(context, CatalogType::PRAGMA_FUNCTION_ENTRY, schema_name, name,
 	                                              if_exists, error_context);
 }
 
 template <>
-AggregateFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name,
+AggregateFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
                                                  bool if_exists, QueryErrorContext error_context) {
-	auto entry =
-	    GetEntry(context, CatalogType::AGGREGATE_FUNCTION_ENTRY, move(schema_name), name, if_exists, error_context);
+	auto entry = GetEntry(context, CatalogType::AGGREGATE_FUNCTION_ENTRY, schema_name, name, if_exists, error_context);
 	if (entry->type != CatalogType::AGGREGATE_FUNCTION_ENTRY) {
 		throw CatalogException(error_context.FormatError("%s is not an aggregate function", name));
 	}
@@ -4827,29 +4943,17 @@ AggregateFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, string
 }
 
 template <>
-CollateCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name, bool if_exists,
-                                       QueryErrorContext error_context) {
-	return (CollateCatalogEntry *)GetEntry(context, CatalogType::COLLATION_ENTRY, move(schema_name), name, if_exists,
+CollateCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
+                                       bool if_exists, QueryErrorContext error_context) {
+	return (CollateCatalogEntry *)GetEntry(context, CatalogType::COLLATION_ENTRY, schema_name, name, if_exists,
 	                                       error_context);
 }
 
 void Catalog::Alter(ClientContext &context, AlterInfo *info) {
 	ModifyCatalog();
-	if (info->schema.empty()) {
-		auto catalog_type = info->GetCatalogType();
-		// invalid schema: search the catalog search path
-		info->schema = DEFAULT_SCHEMA;
-		for (idx_t i = 0; i < context.catalog_search_path.size(); i++) {
-			auto entry = GetEntry(context, catalog_type, context.catalog_search_path[i], info->name, true);
-			if (entry) {
-				// entry exists in this schema: alter there
-				info->schema = context.catalog_search_path[i];
-				break;
-			}
-		}
-	}
-	auto schema = GetSchema(context, info->schema);
-	return schema->Alter(context, info);
+	auto lookup = LookupEntry(context, info->GetCatalogType(), info->schema, info->name);
+	D_ASSERT(lookup.Found()); // It must have thrown otherwise.
+	return lookup.schema->Alter(context, info);
 }
 
 idx_t Catalog::GetCatalogVersion() {
@@ -6622,26 +6726,6 @@ void SchemaCatalogEntry::Alter(ClientContext &context, AlterInfo *info) {
 	}
 }
 
-CatalogEntry *SchemaCatalogEntry::GetEntry(ClientContext &context, CatalogType type, const string &entry_name,
-                                           bool if_exists, QueryErrorContext error_context) {
-	auto &set = GetCatalogSet(type);
-
-	auto entry = set.GetEntry(context, entry_name);
-	if (!entry) {
-		if (!if_exists) {
-			auto entry = set.SimilarEntry(context, entry_name);
-			string did_you_mean;
-			if (!entry.empty()) {
-				did_you_mean = "\nDid you mean \"" + entry + "\"?";
-			}
-			throw CatalogException(error_context.FormatError("%s with name %s does not exist!%s",
-			                                                 CatalogTypeToString(type), entry_name, did_you_mean));
-		}
-		return nullptr;
-	}
-	return entry;
-}
-
 void SchemaCatalogEntry::Scan(ClientContext &context, CatalogType type,
                               const std::function<void(CatalogEntry *)> &callback) {
 	auto &set = GetCatalogSet(type);
@@ -8518,6 +8602,51 @@ string CatalogEntry::ToSQL() {
 
 
 
+
+
+
+namespace duckdb {
+
+CatalogSearchPath::CatalogSearchPath(ClientContext &context_p) : context(context_p), paths(ParsePaths("")) {
+}
+
+const vector<string> &CatalogSearchPath::Get() {
+	Value value;
+	context.TryGetCurrentSetting("search_path", value);
+	if (value.str_value != last_value) {
+		paths = ParsePaths(value.str_value);
+		last_value = value.str_value;
+	}
+
+	return paths;
+}
+
+const string &CatalogSearchPath::GetDefault() {
+	const auto &paths = Get();
+	D_ASSERT(paths.size() >= 2);
+	D_ASSERT(paths[0] == TEMP_SCHEMA);
+	return paths[1];
+}
+
+vector<string> CatalogSearchPath::ParsePaths(const string &value) {
+	vector<string> paths;
+	paths.emplace_back(TEMP_SCHEMA);
+
+	auto given_paths = StringUtil::SplitWithQuote(value);
+	for (const auto &p : given_paths) {
+		paths.emplace_back(StringUtil::Lower(p));
+	}
+
+	paths.emplace_back(DEFAULT_SCHEMA);
+	paths.emplace_back("pg_catalog");
+	return paths;
+}
+
+} // namespace duckdb
+
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -8919,7 +9048,7 @@ CatalogEntry *CatalogSet::GetCommittedEntry(CatalogEntry *current) {
 	return current;
 }
 
-string CatalogSet::SimilarEntry(ClientContext &context, const string &name) {
+pair<string, idx_t> CatalogSet::SimilarEntry(ClientContext &context, const string &name) {
 	lock_guard<mutex> lock(catalog_lock);
 
 	string result;
@@ -8934,7 +9063,7 @@ string CatalogSet::SimilarEntry(ClientContext &context, const string &name) {
 			}
 		}
 	}
-	return result;
+	return {result, current_score};
 }
 
 CatalogEntry *CatalogSet::CreateEntryInternal(ClientContext &context, unique_ptr<CatalogEntry> entry) {
@@ -9272,8 +9401,10 @@ static DefaultMacro internal_macros[] = {
 	{"pg_catalog", "pg_ts_template_is_visible", {"template_oid", nullptr}, "true"},
 	{"pg_catalog", "pg_type_is_visible", {"type_oid", nullptr}, "true"},
 
+	{DEFAULT_SCHEMA, "round_even", {"x", "n", nullptr}, "CASE ((abs(x) * power(10, n+1)) % 10) WHEN 5 THEN round(x/2, n) * 2 ELSE round(x, n) END"},
+	{DEFAULT_SCHEMA, "roundbankers", {"x", "n", nullptr}, "round_even(x, n)"},
 	{DEFAULT_SCHEMA, "nullif", {"a", "b", nullptr}, "CASE WHEN a=b THEN NULL ELSE a END"},
-                                         {nullptr, nullptr, {nullptr}, nullptr}};
+    {nullptr, nullptr, {nullptr}, nullptr}};
 
 static unique_ptr<CreateFunctionInfo> GetDefaultFunction(const string &schema, const string &name) {
 	for (idx_t index = 0; internal_macros[index].name != nullptr; index++) {
@@ -31142,6 +31273,7 @@ void SortedDataScanner::Scan(DataChunk &chunk) {
 
 
 
+
 #include <algorithm>
 #include <cctype>
 #include <iomanip>
@@ -31207,6 +31339,65 @@ vector<string> StringUtil::Split(const string &str, char delimiter) {
 	return (lines);
 }
 
+namespace string_util_internal {
+
+inline void SkipSpaces(const string &str, idx_t &index) {
+	while (index < str.size() && std::isspace(str[index])) {
+		index++;
+	}
+}
+
+inline void ConsumeLetter(const string &str, idx_t &index, char expected) {
+	if (index >= str.size() || str[index] != expected) {
+		throw ParserException("Invalid quoted list: %s", str);
+	}
+
+	index++;
+}
+
+template <typename F>
+inline void TakeWhile(const string &str, idx_t &index, const F &cond, string &taker) {
+	while (index < str.size() && cond(str[index])) {
+		taker.push_back(str[index]);
+		index++;
+	}
+}
+
+inline string TakePossiblyQuotedItem(const string &str, idx_t &index, char delimiter, char quote) {
+	string entry;
+
+	if (str[index] == quote) {
+		index++;
+		TakeWhile(
+		    str, index, [quote](char c) { return c != quote; }, entry);
+		ConsumeLetter(str, index, quote);
+	} else {
+		TakeWhile(
+		    str, index, [delimiter, quote](char c) { return c != delimiter && c != quote && !std::isspace(c); }, entry);
+	}
+
+	return entry;
+}
+
+} // namespace string_util_internal
+
+vector<string> StringUtil::SplitWithQuote(const string &str, char delimiter, char quote) {
+	vector<string> entries;
+	idx_t i = 0;
+
+	string_util_internal::SkipSpaces(str, i);
+	while (i < str.size()) {
+		if (!entries.empty()) {
+			string_util_internal::ConsumeLetter(str, i, delimiter);
+		}
+
+		entries.emplace_back(string_util_internal::TakePossiblyQuotedItem(str, i, delimiter, quote));
+		string_util_internal::SkipSpaces(str, i);
+	}
+
+	return entries;
+}
+
 string StringUtil::Join(const vector<string> &input, const string &separator) {
 	return StringUtil::Join(input, input.size(), separator, [](const string &s) { return s; });
 }
@@ -55315,7 +55506,7 @@ namespace duckdb {
 //! PhysicalSet represents a SET operation (e.g. SET a = 42)
 class PhysicalSet : public PhysicalOperator {
 public:
-	PhysicalSet(std::string name_p, Value value_p, SetScope scope_p, idx_t estimated_cardinality)
+	PhysicalSet(const std::string &name_p, Value value_p, SetScope scope_p, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::SET, {LogicalType::BOOLEAN}, estimated_cardinality), name(name_p),
 	      value(value_p), scope(scope_p) {
 	}
@@ -55324,9 +55515,13 @@ public:
 	void GetChunkInternal(ExecutionContext &context, DataChunk &chunk, PhysicalOperatorState *state) const override;
 
 public:
-	std::string name;
-	Value value;
-	SetScope scope;
+	const std::string name;
+	const Value value;
+	const SetScope scope;
+
+private:
+	//! Returns the normalized key name.
+	string ValidateInput(ExecutionContext &context) const;
 };
 
 } // namespace duckdb
@@ -55334,20 +55529,47 @@ public:
 
 
 
+
+
 namespace duckdb {
 
 void PhysicalSet::GetChunkInternal(ExecutionContext &context, DataChunk &chunk, PhysicalOperatorState *state) const {
 	D_ASSERT(scope == SetScope::GLOBAL || scope == SetScope::SESSION);
 
+	auto normalized_name = ValidateInput(context);
 	if (scope == SetScope::GLOBAL) {
-		context.client.db->config.set_variables[name] = value;
+		context.client.db->config.set_variables[normalized_name] = value;
 	} else {
-		context.client.set_variables[name] = value;
+		context.client.set_variables[normalized_name] = value;
 	}
 
 	state->finished = true;
 }
 
+string PhysicalSet::ValidateInput(ExecutionContext &context) const {
+	CaseInsensitiveStringEquality case_insensitive_streq;
+	if (case_insensitive_streq(name, "search_path") || case_insensitive_streq(name, "schema")) {
+		auto paths = StringUtil::SplitWithQuote(value.str_value, ',');
+
+		// The PG doc says:
+		// >  SET SCHEMA 'value' is an alias for SET search_path TO value.
+		// >  Only one schema can be specified using this syntax.
+		if (case_insensitive_streq(name, "schema") && paths.size() > 1) {
+			throw CatalogException("SET schema can set only 1 schema. This has %d", paths.size());
+		}
+
+		for (const auto &path : paths) {
+			if (!context.client.db->GetCatalog().GetSchema(context.client, StringUtil::Lower(path), true)) {
+				throw CatalogException("SET %s: No schema named %s found.", name, path);
+			}
+		}
+
+		return "search_path";
+	}
+
+	return name;
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -80241,6 +80463,7 @@ bool ConstantOrNull::IsConstantOrNull(BoundFunctionExpression &expr, const Value
 
 
 
+
 namespace duckdb {
 
 struct CurrentSettingBindData : public FunctionData {
@@ -80261,6 +80484,16 @@ static void CurrentSettingFunction(DataChunk &args, ExpressionState &state, Vect
 	result.Reference(info.value);
 }
 
+static string NormalizeSettingName(const string &name) {
+	if (CaseInsensitiveStringEquality()(name, "schema")) {
+		// The PG doc says:
+		// >  SET SCHEMA 'value' is an alias for SET search_path TO value.
+		return "search_path";
+	}
+
+	return name;
+}
+
 unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFunction &bound_function,
                                             vector<unique_ptr<Expression>> &arguments) {
 
@@ -80276,7 +80509,7 @@ unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFuncti
 		throw ParserException("Key name for struct_extract needs to be neither NULL nor empty");
 	}
 
-	const auto &key = key_val.str_value;
+	const auto &key = NormalizeSettingName(key_val.str_value);
 	Value val;
 	if (!context.TryGetCurrentSetting(key, val)) {
 		throw InvalidInputException("Variable '%s' was not SET in this context", key);
@@ -97139,6 +97372,7 @@ private:
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -97581,6 +97815,7 @@ ClientContext::ClientContext(shared_ptr<DatabaseInstance> database)
     : profiler(make_unique<QueryProfiler>()), query_profiler_history(make_unique<QueryProfilerHistory>()),
       db(move(database)), transaction(db->GetTransactionManager(), *this), interrupted(false), executor(*this),
       temporary_objects(make_unique<SchemaCatalogEntry>(&db->GetCatalog(), TEMP_SCHEMA, true)),
+      catalog_search_path(make_unique<CatalogSearchPath>(*this)),
       file_opener(make_unique<ClientContextFileOpener>(*this)), open_result(nullptr) {
 	std::random_device rd;
 	random_engine.seed(rd());
@@ -129739,6 +129974,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSele
 
 
 
+
 namespace duckdb {
 
 namespace {
@@ -133930,6 +134166,7 @@ BoundStatement Binder::Bind(CopyStatement &stmt) {
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -134030,7 +134267,7 @@ namespace duckdb {
 
 SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
 	if (info.schema.empty()) {
-		info.schema = info.temporary ? TEMP_SCHEMA : DEFAULT_SCHEMA;
+		info.schema = info.temporary ? TEMP_SCHEMA : context.catalog_search_path->GetDefault();
 	}
 
 	if (!info.temporary) {

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "0edad5d3d"
-#define DUCKDB_VERSION "0.2.10-dev451"
+#define DUCKDB_SOURCE_ID "20ddfa846"
+#define DUCKDB_VERSION "0.2.10-dev468"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1770,7 +1770,7 @@ class FileFlags {
 public:
 	//! Open file with read access
 	static constexpr uint8_t FILE_FLAGS_READ = 1 << 0;
-	//! Open file with read/write access
+	//! Open file with write access
 	static constexpr uint8_t FILE_FLAGS_WRITE = 1 << 1;
 	//! Use direct IO when reading/writing to the file
 	static constexpr uint8_t FILE_FLAGS_DIRECT_IO = 1 << 2;
@@ -7313,6 +7313,32 @@ class CatalogSet;
 class DatabaseInstance;
 class DependencyManager;
 
+//! Return value of Catalog::LookupEntry
+struct CatalogEntryLookup {
+	SchemaCatalogEntry *schema;
+	CatalogEntry *entry;
+
+	bool Found() const {
+		return entry;
+	}
+};
+
+//! Return value of SimilarEntryInSchemas
+struct SimilarCatalogEntry {
+	//! The entry name. Empty if absent
+	string name;
+	//! The distance to the given name.
+	idx_t distance;
+	//! The schema of the entry.
+	SchemaCatalogEntry *schema;
+
+	bool Found() const {
+		return !name.empty();
+	}
+
+	string GetQualifiedName() const;
+};
+
 //! The Catalog object represents the catalog of the database.
 class Catalog {
 public:
@@ -7384,17 +7410,17 @@ public:
 	void DropEntry(ClientContext &context, DropInfo *info);
 
 	//! Returns the schema object with the specified name, or throws an exception if it does not exist
-	SchemaCatalogEntry *GetSchema(ClientContext &context, const string &name = DEFAULT_SCHEMA,
+	SchemaCatalogEntry *GetSchema(ClientContext &context, const string &name = DEFAULT_SCHEMA, bool if_exists = false,
 	                              QueryErrorContext error_context = QueryErrorContext());
 	//! Scans all the schemas in the system one-by-one, invoking the callback for each entry
 	void ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback);
 	//! Gets the "schema.name" entry of the specified type, if if_exists=true returns nullptr if entry does not exist,
 	//! otherwise an exception is thrown
-	CatalogEntry *GetEntry(ClientContext &context, CatalogType type, string schema, const string &name,
+	CatalogEntry *GetEntry(ClientContext &context, CatalogType type, const string &schema, const string &name,
 	                       bool if_exists = false, QueryErrorContext error_context = QueryErrorContext());
 
 	template <class T>
-	T *GetEntry(ClientContext &context, string schema_name, const string &name, bool if_exists = false,
+	T *GetEntry(ClientContext &context, const string &schema_name, const string &name, bool if_exists = false,
 	            QueryErrorContext error_context = QueryErrorContext());
 
 	//! Alter an existing entry in the catalog.
@@ -7405,30 +7431,43 @@ private:
 	atomic<idx_t> catalog_version;
 
 private:
+	//! A variation of GetEntry that returns an associated schema as well.
+	CatalogEntryLookup LookupEntry(ClientContext &context, CatalogType type, const string &schema, const string &name,
+	                               bool if_exists = false, QueryErrorContext error_context = QueryErrorContext());
+
+	//! Return an exception with did-you-mean suggestion.
+	CatalogException CreateMissingEntryException(ClientContext &context, const string &entry_name, CatalogType type,
+	                                             const vector<SchemaCatalogEntry *> &schemas,
+	                                             QueryErrorContext error_context);
+
+	//! Return the close entry name, the distance and the belonging schema.
+	SimilarCatalogEntry SimilarEntryInSchemas(ClientContext &context, const string &entry_name, CatalogType type,
+	                                          const vector<SchemaCatalogEntry *> &schemas);
+
 	void DropSchema(ClientContext &context, DropInfo *info);
 };
 
 template <>
-TableCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name, bool if_exists,
-                                     QueryErrorContext error_context);
+TableCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
+                                     bool if_exists, QueryErrorContext error_context);
 template <>
-SequenceCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name, bool if_exists,
-                                        QueryErrorContext error_context);
+SequenceCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
+                                        bool if_exists, QueryErrorContext error_context);
 template <>
-TableFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name,
+TableFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
                                              bool if_exists, QueryErrorContext error_context);
 template <>
-CopyFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name,
+CopyFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
                                             bool if_exists, QueryErrorContext error_context);
 template <>
-PragmaFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name,
+PragmaFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
                                               bool if_exists, QueryErrorContext error_context);
 template <>
-AggregateFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name,
+AggregateFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
                                                  bool if_exists, QueryErrorContext error_context);
 template <>
-CollateCatalogEntry *Catalog::GetEntry(ClientContext &context, string schema_name, const string &name, bool if_exists,
-                                       QueryErrorContext error_context);
+CollateCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
+                                       bool if_exists, QueryErrorContext error_context);
 
 } // namespace duckdb
 
@@ -9654,6 +9693,166 @@ private:
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/case_insensitive_map.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/string_util.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+/**
+ * String Utility Functions
+ * Note that these are not the most efficient implementations (i.e., they copy
+ * memory) and therefore they should only be used for debug messages and other
+ * such things.
+ */
+class StringUtil {
+public:
+	static bool CharacterIsSpace(char c) {
+		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+	}
+	static bool CharacterIsNewline(char c) {
+		return c == '\n' || c == '\r';
+	}
+	static bool CharacterIsDigit(char c) {
+		return c >= '0' && c <= '9';
+	}
+	static char CharacterToLower(char c) {
+		if (c >= 'A' && c <= 'Z') {
+			return c - ('A' - 'a');
+		}
+		return c;
+	}
+
+	//! Returns true if the needle string exists in the haystack
+	static bool Contains(const string &haystack, const string &needle);
+
+	//! Returns true if the target string starts with the given prefix
+	static bool StartsWith(string str, string prefix);
+
+	//! Returns true if the target string <b>ends</b> with the given suffix.
+	static bool EndsWith(const string &str, const string &suffix);
+
+	//! Repeat a string multiple times
+	static string Repeat(const string &str, const idx_t n);
+
+	//! Split the input string based on newline char
+	static vector<string> Split(const string &str, char delimiter);
+
+	//! Split the input string allong a quote. Note that any escaping is NOT supported.
+	static vector<string> SplitWithQuote(const string &str, char delimiter = ',', char quote = '"');
+
+	//! Join multiple strings into one string. Components are concatenated by the given separator
+	static string Join(const vector<string> &input, const string &separator);
+
+	//! Join multiple items of container with given size, transformed to string
+	//! using function, into one string using the given separator
+	template <typename C, typename S, typename Func>
+	static string Join(const C &input, S count, const string &separator, Func f) {
+		// The result
+		std::string result;
+
+		// If the input isn't empty, append the first element. We do this so we
+		// don't need to introduce an if into the loop.
+		if (count > 0) {
+			result += f(input[0]);
+		}
+
+		// Append the remaining input components, after the first
+		for (size_t i = 1; i < count; i++) {
+			result += separator + f(input[i]);
+		}
+
+		return result;
+	}
+
+	//! Return a string that formats the give number of bytes
+	static string BytesToHumanReadableString(idx_t bytes);
+
+	//! Convert a string to uppercase
+	static string Upper(const string &str);
+
+	//! Convert a string to lowercase
+	static string Lower(const string &str);
+
+	//! Format a string using printf semantics
+	template <typename... Args>
+	static string Format(const string fmt_str, Args... params) {
+		return Exception::ConstructMessage(fmt_str, params...);
+	}
+
+	//! Split the input string into a vector of strings based on the split string
+	static vector<string> Split(const string &input, const string &split);
+
+	//! Remove the whitespace char in the left end of the string
+	static void LTrim(string &str);
+	//! Remove the whitespace char in the right end of the string
+	static void RTrim(string &str);
+	//! Remove the whitespace char in the left and right end of the string
+	static void Trim(string &str);
+
+	static string Replace(string source, const string &from, const string &to);
+
+	//! Get the levenshtein distance from two strings
+	static idx_t LevenshteinDistance(const string &s1, const string &s2);
+
+	//! Get the top-n strings (sorted by the given score distance) from a set of scores.
+	//! At least one entry is returned (if there is one).
+	//! Strings are only returned if they have a score less than the threshold.
+	static vector<string> TopNStrings(vector<std::pair<string, idx_t>> scores, idx_t n = 5, idx_t threshold = 5);
+	//! Computes the levenshtein distance of each string in strings, and compares it to target, then returns TopNStrings
+	//! with the given params.
+	static vector<string> TopNLevenshtein(const vector<string> &strings, const string &target, idx_t n = 5,
+	                                      idx_t threshold = 5);
+	static string CandidatesMessage(const vector<string> &candidates, const string &candidate = "Candidate bindings");
+};
+} // namespace duckdb
+
+
+namespace duckdb {
+
+struct CaseInsensitiveStringHashFunction {
+	uint64_t operator()(const string &str) const {
+		std::hash<string> hasher;
+		return hasher(StringUtil::Lower(str));
+	}
+};
+
+struct CaseInsensitiveStringEquality {
+	bool operator()(const string &a, const string &b) const {
+		return StringUtil::Lower(a) == StringUtil::Lower(b);
+	}
+};
+
+template <typename T>
+using case_insensitive_map_t =
+    unordered_map<string, T, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
+
+using case_insensitive_set_t = unordered_set<string, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
+
+} // namespace duckdb
+
 
 
 
@@ -9846,7 +10045,7 @@ public:
 	//! Whether or not object cache is used
 	bool object_cache_enable = false;
 	//! Database configuration variables as controlled by SET
-	unordered_map<std::string, Value> set_variables;
+	case_insensitive_map_t<Value> set_variables;
 	//! Force checkpoint when CHECKPOINT is called or on shutdown, even if no changes have been made
 	bool force_checkpoint = false;
 	//! Run a checkpoint on successful shutdown and delete the WAL, to leave only a single database file behind
@@ -11747,161 +11946,22 @@ public:
 } // namespace duckdb
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/case_insensitive_map.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/string_util.hpp
+// duckdb/common/pair.hpp
 //
 //
 //===----------------------------------------------------------------------===//
 
 
 
-
-
-
-
-namespace duckdb {
-/**
- * String Utility Functions
- * Note that these are not the most efficient implementations (i.e., they copy
- * memory) and therefore they should only be used for debug messages and other
- * such things.
- */
-class StringUtil {
-public:
-	static bool CharacterIsSpace(char c) {
-		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
-	}
-	static bool CharacterIsNewline(char c) {
-		return c == '\n' || c == '\r';
-	}
-	static bool CharacterIsDigit(char c) {
-		return c >= '0' && c <= '9';
-	}
-	static char CharacterToLower(char c) {
-		if (c >= 'A' && c <= 'Z') {
-			return c - ('A' - 'a');
-		}
-		return c;
-	}
-
-	//! Returns true if the needle string exists in the haystack
-	static bool Contains(const string &haystack, const string &needle);
-
-	//! Returns true if the target string starts with the given prefix
-	static bool StartsWith(string str, string prefix);
-
-	//! Returns true if the target string <b>ends</b> with the given suffix.
-	static bool EndsWith(const string &str, const string &suffix);
-
-	//! Repeat a string multiple times
-	static string Repeat(const string &str, const idx_t n);
-
-	//! Split the input string based on newline char
-	static vector<string> Split(const string &str, char delimiter);
-
-	//! Join multiple strings into one string. Components are concatenated by the given separator
-	static string Join(const vector<string> &input, const string &separator);
-
-	//! Join multiple items of container with given size, transformed to string
-	//! using function, into one string using the given separator
-	template <typename C, typename S, typename Func>
-	static string Join(const C &input, S count, const string &separator, Func f) {
-		// The result
-		std::string result;
-
-		// If the input isn't empty, append the first element. We do this so we
-		// don't need to introduce an if into the loop.
-		if (count > 0) {
-			result += f(input[0]);
-		}
-
-		// Append the remaining input components, after the first
-		for (size_t i = 1; i < count; i++) {
-			result += separator + f(input[i]);
-		}
-
-		return result;
-	}
-
-	//! Return a string that formats the give number of bytes
-	static string BytesToHumanReadableString(idx_t bytes);
-
-	//! Convert a string to uppercase
-	static string Upper(const string &str);
-
-	//! Convert a string to lowercase
-	static string Lower(const string &str);
-
-	//! Format a string using printf semantics
-	template <typename... Args>
-	static string Format(const string fmt_str, Args... params) {
-		return Exception::ConstructMessage(fmt_str, params...);
-	}
-
-	//! Split the input string into a vector of strings based on the split string
-	static vector<string> Split(const string &input, const string &split);
-
-	//! Remove the whitespace char in the left end of the string
-	static void LTrim(string &str);
-	//! Remove the whitespace char in the right end of the string
-	static void RTrim(string &str);
-	//! Remove the whitespace char in the left and right end of the string
-	static void Trim(string &str);
-
-	static string Replace(string source, const string &from, const string &to);
-
-	//! Get the levenshtein distance from two strings
-	static idx_t LevenshteinDistance(const string &s1, const string &s2);
-
-	//! Get the top-n strings (sorted by the given score distance) from a set of scores.
-	//! At least one entry is returned (if there is one).
-	//! Strings are only returned if they have a score less than the threshold.
-	static vector<string> TopNStrings(vector<std::pair<string, idx_t>> scores, idx_t n = 5, idx_t threshold = 5);
-	//! Computes the levenshtein distance of each string in strings, and compares it to target, then returns TopNStrings
-	//! with the given params.
-	static vector<string> TopNLevenshtein(const vector<string> &strings, const string &target, idx_t n = 5,
-	                                      idx_t threshold = 5);
-	static string CandidatesMessage(const vector<string> &candidates, const string &candidate = "Candidate bindings");
-};
-} // namespace duckdb
-
+#include <utility>
 
 namespace duckdb {
-
-struct CaseInsensitiveStringHashFunction {
-	uint64_t operator()(const string &str) const {
-		std::hash<string> hasher;
-		return hasher(StringUtil::Lower(str));
-	}
-};
-
-struct CaseInsensitiveStringEquality {
-	bool operator()(const string &a, const string &b) const {
-		return StringUtil::Lower(a) == StringUtil::Lower(b);
-	}
-};
-
-template <typename T>
-using case_insensitive_map_t =
-    unordered_map<string, T, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
-
-using case_insensitive_set_t = unordered_set<string, CaseInsensitiveStringHashFunction, CaseInsensitiveStringEquality>;
-
+using std::make_pair;
+using std::pair;
 } // namespace duckdb
 
 
@@ -11950,8 +12010,8 @@ public:
 	CatalogEntry *GetEntry(ClientContext &context, const string &name);
 
 	//! Gets the entry that is most similar to the given name (i.e. smallest levenshtein distance), or empty string if
-	//! none is found
-	string SimilarEntry(ClientContext &context, const string &name);
+	//! none is found. The returned pair consists of the entry name and the distance (smaller means closer).
+	pair<string, idx_t> SimilarEntry(ClientContext &context, const string &name);
 
 	//! Rollback <entry> to be the currently valid entry for a certain catalog
 	//! entry
@@ -12059,10 +12119,6 @@ private:
 	CatalogSet collations;
 
 public:
-	//! Gets a catalog entry from the given catalog set matching the given name
-	CatalogEntry *GetEntry(ClientContext &context, CatalogType type, const string &name, bool if_exists,
-	                       QueryErrorContext error_context = QueryErrorContext());
-
 	//! Scan the specified catalog set, invoking the callback method for every entry
 	void Scan(ClientContext &context, CatalogType type, const std::function<void(CatalogEntry *)> &callback);
 	//! Scan the specified catalog set, invoking the callback method for every committed entry
@@ -12114,6 +12170,7 @@ private:
 } // namespace duckdb
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -12147,22 +12204,6 @@ enum class ExplainOutputType : uint8_t { ALL = 0, OPTIMIZED_ONLY = 1, PHYSICAL_O
 
 } // namespace duckdb
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/pair.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-#include <utility>
-
-namespace duckdb {
-using std::make_pair;
-using std::pair;
-} // namespace duckdb
 
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -13083,6 +13124,7 @@ private:
 namespace duckdb {
 class Appender;
 class Catalog;
+class CatalogSearchPath;
 class ChunkCollection;
 class DatabaseInstance;
 class FileOpener;
@@ -13132,7 +13174,7 @@ public:
 	unique_ptr<SchemaCatalogEntry> temporary_objects;
 	unordered_map<string, shared_ptr<PreparedStatementData>> prepared_statements;
 
-	unordered_map<string, Value> set_variables;
+	case_insensitive_map_t<Value> set_variables;
 
 	// Whether or not aggressive query verification is enabled
 	bool query_verification_enabled = false;
@@ -13154,8 +13196,7 @@ public:
 	//! The random generator used by random(). Its seed value can be set by setseed().
 	std::mt19937 random_engine;
 
-	//! The schema search path, in order by which entries are searched if no schema entry is provided
-	vector<string> catalog_search_path = {TEMP_SCHEMA, DEFAULT_SCHEMA, "pg_catalog"};
+	const unique_ptr<CatalogSearchPath> catalog_search_path;
 
 	unique_ptr<FileOpener> file_opener;
 
@@ -13381,7 +13422,7 @@ public:
 namespace duckdb {
 
 struct CreateFunctionInfo : public CreateInfo {
-	explicit CreateFunctionInfo(CatalogType type) : CreateInfo(type) {
+	explicit CreateFunctionInfo(CatalogType type, string schema = DEFAULT_SCHEMA) : CreateInfo(type, schema) {
 		D_ASSERT(type == CatalogType::SCALAR_FUNCTION_ENTRY || type == CatalogType::AGGREGATE_FUNCTION_ENTRY ||
 		         type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY ||
 		         type == CatalogType::MACRO_ENTRY);