duckdb 0.6.2-dev781.0 → 0.6.2-dev889.0

package/src/duckdb/src/parser/transform/statement/transform_insert.cpp

@@ -54,6 +54,7 @@ unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGNo
 	auto qname = TransformQualifiedName(stmt->relation);
 	result->table = qname.name;
 	result->schema = qname.schema;
+	result->catalog = qname.catalog;
 	return result;
 }
 

package/src/duckdb/src/parser/transform/statement/transform_rename.cpp

@@ -10,60 +10,37 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 
 	unique_ptr<AlterInfo> info;
 
+	AlterEntryData data;
+	data.if_exists = stmt->missing_ok;
+	data.catalog = stmt->relation->catalogname ? stmt->relation->catalogname : INVALID_CATALOG;
+	data.schema = stmt->relation->schemaname ? stmt->relation->schemaname : INVALID_SCHEMA;
+	if (stmt->relation->relname) {
+		data.name = stmt->relation->relname;
+	}
+	if (stmt->relation->schemaname) {
+	}
 	// first we check the type of ALTER
 	switch (stmt->renameType) {
 	case duckdb_libpgquery::PG_OBJECT_COLUMN: {
 		// change column name
 
-		// get the table and schema
-		string schema = INVALID_SCHEMA;
-		string table;
-		D_ASSERT(stmt->relation->relname);
-		if (stmt->relation->relname) {
-			table = stmt->relation->relname;
-		}
-		if (stmt->relation->schemaname) {
-			schema = stmt->relation->schemaname;
-		}
 		// get the old name and the new name
 		string old_name = stmt->subname;
 		string new_name = stmt->newname;
-		info = make_unique<RenameColumnInfo>(schema, table, stmt->missing_ok, old_name, new_name);
+		info = make_unique<RenameColumnInfo>(move(data), old_name, new_name);
 		break;
 	}
 	case duckdb_libpgquery::PG_OBJECT_TABLE: {
 		// change table name
-
-		// get the table and schema
-		string schema = INVALID_SCHEMA;
-		string table;
-		D_ASSERT(stmt->relation->relname);
-		if (stmt->relation->relname) {
-			table = stmt->relation->relname;
-		}
-		if (stmt->relation->schemaname) {
-			schema = stmt->relation->schemaname;
-		}
 		string new_name = stmt->newname;
-		info = make_unique<RenameTableInfo>(schema, table, stmt->missing_ok, new_name);
+		info = make_unique<RenameTableInfo>(move(data), new_name);
 		break;
 	}
 
 	case duckdb_libpgquery::PG_OBJECT_VIEW: {
 		// change view name
-
-		// get the view and schema
-		string schema = INVALID_SCHEMA;
-		string view;
-		D_ASSERT(stmt->relation->relname);
-		if (stmt->relation->relname) {
-			view = stmt->relation->relname;
-		}
-		if (stmt->relation->schemaname) {
-			schema = stmt->relation->schemaname;
-		}
 		string new_name = stmt->newname;
-		info = make_unique<RenameViewInfo>(schema, view, stmt->missing_ok, new_name);
+		info = make_unique<RenameViewInfo>(move(data), new_name);
 		break;
 	}
 	case duckdb_libpgquery::PG_OBJECT_DATABASE:
@@ -71,7 +48,6 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 		throw NotImplementedException("Schema element not supported yet!");
 	}
 	D_ASSERT(info);
-	info->if_exists = stmt->missing_ok;
 
 	auto result = make_unique<AlterStatement>();
 	result->info = move(info);

package/src/duckdb/src/parser/transform/statement/transform_show.cpp

@@ -10,7 +10,9 @@ namespace duckdb {
 static void TransformShowName(unique_ptr<PragmaStatement> &result, const string &name) {
 	auto &info = *result->info;
 
-	if (name == "\"tables\"") {
+	if (StringUtil::Lower(name) == "\"databases\"") {
+		info.name = "show_databases";
+	} else if (name == "\"tables\"") {
 		// show all tables
 		info.name = "show_tables";
 	} else if (name == "__show_tables_expanded") {

package/src/duckdb/src/parser/transform/statement/transform_use.cpp

@@ -0,0 +1,21 @@
+#include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/statement/set_statement.hpp"
+
+namespace duckdb {
+
+unique_ptr<SetStatement> Transformer::TransformUse(duckdb_libpgquery::PGNode *node) {
+	auto stmt = reinterpret_cast<duckdb_libpgquery::PGUseStmt *>(node);
+	auto qualified_name = TransformQualifiedName(stmt->name);
+	if (!IsInvalidCatalog(qualified_name.catalog)) {
+		throw ParserException("Expected \"USE database\" or \"USE database.schema\"");
+	}
+	string name;
+	if (IsInvalidSchema(qualified_name.schema)) {
+		name = qualified_name.name;
+	} else {
+		name = qualified_name.schema + "." + qualified_name.name;
+	}
+	return make_unique<SetVariableStatement>("schema", move(name), SetScope::AUTOMATIC);
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/transform/tableref/transform_base_tableref.cpp

@@ -10,6 +10,9 @@ unique_ptr<TableRef> Transformer::TransformRangeVar(duckdb_libpgquery::PGRangeVa
 	if (root->relname) {
 		result->table_name = root->relname;
 	}
+	if (root->catalogname) {
+		result->catalog_name = root->catalogname;
+	}
 	if (root->schemaname) {
 		result->schema_name = root->schemaname;
 	}
@@ -22,16 +25,21 @@ unique_ptr<TableRef> Transformer::TransformRangeVar(duckdb_libpgquery::PGRangeVa
 
 QualifiedName Transformer::TransformQualifiedName(duckdb_libpgquery::PGRangeVar *root) {
 	QualifiedName qname;
-	if (root->relname) {
-		qname.name = root->relname;
+	if (root->catalogname) {
+		qname.catalog = root->catalogname;
 	} else {
-		qname.name = string();
+		qname.catalog = INVALID_CATALOG;
 	}
 	if (root->schemaname) {
 		qname.schema = root->schemaname;
 	} else {
 		qname.schema = INVALID_SCHEMA;
 	}
+	if (root->relname) {
+		qname.name = root->relname;
+	} else {
+		qname.name = string();
+	}
 	return qname;
 }
 

package/src/duckdb/src/parser/transformer.cpp

@@ -143,6 +143,10 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 		return TransformCreateType(stmt);
 	case duckdb_libpgquery::T_PGAlterSeqStmt:
 		return TransformAlterSequence(stmt);
+	case duckdb_libpgquery::T_PGAttachStmt:
+		return TransformAttach(stmt);
+	case duckdb_libpgquery::T_PGUseStmt:
+		return TransformUse(stmt);
 	default:
 		throw NotImplementedException(NodetypeToString(stmt->type));
 	}

package/src/duckdb/src/planner/bind_context.cpp

@@ -194,10 +194,13 @@ static bool ColumnIsGenerated(Binding *binding, column_t index) {
 	return table_entry->columns.GetColumn(LogicalIndex(index)).Generated();
 }
 
-unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &schema_name, const string &table_name,
-                                                                const string &column_name) {
+unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &catalog_name, const string &schema_name,
+                                                                const string &table_name, const string &column_name) {
 	string error_message;
 	vector<string> names;
+	if (!catalog_name.empty()) {
+		names.push_back(catalog_name);
+	}
 	if (!schema_name.empty()) {
 		names.push_back(schema_name);
 	}
@@ -220,6 +223,12 @@ unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &sc
 	return move(result);
 }
 
+unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &schema_name, const string &table_name,
+                                                                const string &column_name) {
+	string catalog_name;
+	return CreateColumnReference(catalog_name, schema_name, table_name, column_name);
+}
+
 Binding *BindContext::GetCTEBinding(const string &ctename) {
 	auto match = cte_bindings.find(ctename);
 	if (match == cte_bindings.end()) {

package/src/duckdb/src/planner/binder/expression/bind_cast_expression.cpp

@@ -14,7 +14,7 @@ BindResult ExpressionBinder::BindExpression(CastExpression &expr, idx_t depth) {
 	}
 	// FIXME: We can also implement 'hello'::schema.custom_type; and pass by the schema down here.
 	// Right now just considering its DEFAULT_SCHEMA always
-	Binder::BindLogicalType(context, expr.cast_type, DEFAULT_SCHEMA);
+	Binder::BindLogicalType(context, expr.cast_type, INVALID_CATALOG, INVALID_SCHEMA);
 	// the children have been successfully resolved
 	auto &child = (BoundExpression &)*expr.child;
 	if (expr.try_cast) {

package/src/duckdb/src/planner/binder/expression/bind_columnref_expression.cpp

@@ -142,23 +142,36 @@ unique_ptr<ParsedExpression> ExpressionBinder::CreateStructExtract(unique_ptr<Pa
 }
 
 unique_ptr<ParsedExpression> ExpressionBinder::CreateStructPack(ColumnRefExpression &colref) {
-	D_ASSERT(colref.column_names.size() <= 2);
+	D_ASSERT(colref.column_names.size() <= 3);
 	string error_message;
 	auto &table_name = colref.column_names.back();
 	auto binding = binder.bind_context.GetBinding(table_name, error_message);
 	if (!binding) {
 		return nullptr;
 	}
-	if (colref.column_names.size() == 2) {
+	if (colref.column_names.size() >= 2) {
 		// "schema_name.table_name"
 		auto catalog_entry = binding->GetStandardEntry();
 		if (!catalog_entry) {
 			return nullptr;
 		}
-		auto &schema_name = colref.column_names[0];
-		if (catalog_entry->schema->name != schema_name || catalog_entry->name != table_name) {
+		if (catalog_entry->name != table_name) {
 			return nullptr;
 		}
+		if (colref.column_names.size() == 2) {
+			auto &qualifier = colref.column_names[0];
+			if (catalog_entry->catalog->GetName() != qualifier && catalog_entry->schema->name != qualifier) {
+				return nullptr;
+			}
+		} else if (colref.column_names.size() == 3) {
+			auto &catalog_name = colref.column_names[0];
+			auto &schema_name = colref.column_names[1];
+			if (catalog_entry->catalog->GetName() != catalog_name || catalog_entry->schema->name != schema_name) {
+				return nullptr;
+			}
+		} else {
+			throw InternalException("Expected 2 or 3 column names for CreateStructPack");
+		}
 	}
 	// We found the table, now create the struct_pack expression
 	vector<unique_ptr<ParsedExpression>> child_exprs;
@@ -207,22 +220,39 @@ unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(ColumnRefExpres
 		}
 	} else {
 		// two or more dots (i.e. "part1.part2.part3.part4...")
+		// -> part1 is a catalog, part2 is a schema, part3 is a table, part4 is a column name, part 5 and beyond are
+		// struct fields
+		// -> part1 is a catalog, part2 is a table, part3 is a column name, part4 and beyond are struct fields
 		// -> part1 is a schema, part2 is a table, part3 is a column name, part4 and beyond are struct fields
 		// -> part1 is a table, part2 is a column name, part3 and beyond are struct fields
 		// -> part1 is a column, part2 and beyond are struct fields
 
 		// we always prefer the most top-level view
 		// i.e. in case of multiple resolution options, we resolve in order:
-		// -> 1. resolve "part1" as a schema
-		// -> 2. resolve "part1" as a table
-		// -> 3. resolve "part1" as a column
+		// -> 1. resolve "part1" as a catalog
+		// -> 2. resolve "part1" as a schema
+		// -> 3. resolve "part1" as a table
+		// -> 4. resolve "part1" as a column
 
 		unique_ptr<ParsedExpression> result_expr;
 		idx_t struct_extract_start;
-		// first check if part1 is a schema
-		if (binder.HasMatchingBinding(colref.column_names[0], colref.column_names[1], colref.column_names[2],
-		                              error_message)) {
-			// it is! the column reference is "schema.table.column"
+		// first check if part1 is a catalog
+		if (colref.column_names.size() > 3 &&
+		    binder.HasMatchingBinding(colref.column_names[0], colref.column_names[1], colref.column_names[2],
+		                              colref.column_names[3], error_message)) {
+			// part1 is a catalog - the column reference is "catalog.schema.table.column"
+			result_expr = binder.bind_context.CreateColumnReference(colref.column_names[0], colref.column_names[1],
+			                                                        colref.column_names[2], colref.column_names[3]);
+			struct_extract_start = 4;
+		} else if (binder.HasMatchingBinding(colref.column_names[0], INVALID_SCHEMA, colref.column_names[1],
+		                                     colref.column_names[2], error_message)) {
+			// part1 is a catalog - the column reference is "catalog.table.column"
+			result_expr = binder.bind_context.CreateColumnReference(colref.column_names[0], INVALID_SCHEMA,
+			                                                        colref.column_names[1], colref.column_names[2]);
+			struct_extract_start = 3;
+		} else if (binder.HasMatchingBinding(colref.column_names[0], colref.column_names[1], colref.column_names[2],
+		                                     error_message)) {
+			// part1 is a schema - the column reference is "schema.table.column"
 			// any additional fields are turned into struct_extract calls
 			result_expr = binder.bind_context.CreateColumnReference(colref.column_names[0], colref.column_names[1],
 			                                                        colref.column_names[2]);
@@ -238,8 +268,8 @@ unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(ColumnRefExpres
 			string col_error;
 			result_expr = QualifyColumnName(colref.column_names[0], col_error);
 			if (!result_expr) {
-				// it is not! return the error
-				return nullptr;
+				// it is not! Try creating an implicit struct_pack
+				return CreateStructPack(colref);
 			}
 			// it is! add the struct extract calls
 			struct_extract_start = 1;

package/src/duckdb/src/planner/binder/expression/bind_comparison_expression.cpp

@@ -33,7 +33,7 @@ unique_ptr<Expression> ExpressionBinder::PushCollation(ClientContext &context, u
 		// binary collation: just skip
 		return source;
 	}
-	auto &catalog = Catalog::GetCatalog(context);
+	auto &catalog = Catalog::GetSystemCatalog(context);
 	auto splits = StringUtil::Split(StringUtil::Lower(collation), ".");
 	vector<CollateCatalogEntry *> entries;
 	for (auto &collation_argument : splits) {

package/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp

@@ -24,9 +24,8 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 		// have unnest live in catalog, too
 		return BindUnnest(function, depth);
 	}
-	auto &catalog = Catalog::GetCatalog(context);
-	auto func = catalog.GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.schema, function.function_name,
-	                             false, error_context);
+	auto func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
+	                              function.function_name, false, error_context);
 
 	switch (func->type) {
 	case CatalogType::SCALAR_FUNCTION_ENTRY:

package/src/duckdb/src/planner/binder/expression/bind_window_expression.cpp

@@ -192,9 +192,8 @@ BindResult SelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	unique_ptr<FunctionData> bind_info;
 	if (window.type == ExpressionType::WINDOW_AGGREGATE) {
 		//  Look up the aggregate function in the catalog
-		auto func =
-		    (AggregateFunctionCatalogEntry *)Catalog::GetCatalog(context).GetEntry<AggregateFunctionCatalogEntry>(
-		        context, window.schema, window.function_name, false, error_context);
+		auto func = Catalog::GetEntry<AggregateFunctionCatalogEntry>(context, window.catalog, window.schema,
+		                                                             window.function_name, false, error_context);
 		D_ASSERT(func->type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
 
 		// bind the aggregate

package/src/duckdb/src/planner/binder/statement/bind_attach.cpp

@@ -0,0 +1,20 @@
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/statement/attach_statement.hpp"
+#include "duckdb/parser/tableref/table_function_ref.hpp"
+#include "duckdb/planner/tableref/bound_table_function.hpp"
+#include "duckdb/planner/operator/logical_simple.hpp"
+
+namespace duckdb {
+
+BoundStatement Binder::Bind(AttachStatement &stmt) {
+	BoundStatement result;
+	result.types = {LogicalType::BOOLEAN};
+	result.names = {"Success"};
+
+	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_ATTACH, move(stmt.info));
+	properties.allow_stream_result = false;
+	properties.return_type = StatementReturnType::NOTHING;
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/binder/statement/bind_copy.cpp

@@ -34,8 +34,8 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	auto select_node = Bind(*stmt.select_statement);
 
 	// lookup the format in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
-	auto copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
+	auto copy_function =
+	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->format);
 	if (!copy_function->function.copy_to_bind) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
@@ -94,6 +94,7 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	InsertStatement insert;
 	insert.table = stmt.info->table;
 	insert.schema = stmt.info->schema;
+	insert.catalog = stmt.info->catalog;
 	insert.columns = stmt.info->select_list;
 
 	// bind the insert statement to the base table
@@ -103,13 +104,14 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	auto &bound_insert = (LogicalInsert &)*insert_statement.plan;
 
 	// lookup the format in the catalog
-	auto &catalog = Catalog::GetCatalog(context);
+	auto &catalog = Catalog::GetSystemCatalog(context);
 	auto copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
 	if (!copy_function->function.copy_from_bind) {
 		throw NotImplementedException("COPY FROM is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 	// lookup the table to copy into
-	auto table = Catalog::GetCatalog(context).GetEntry<TableCatalogEntry>(context, stmt.info->schema, stmt.info->table);
+	BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
+	auto table = Catalog::GetEntry<TableCatalogEntry>(context, stmt.info->catalog, stmt.info->schema, stmt.info->table);
 	vector<string> expected_names;
 	if (!bound_insert.column_index_map.empty()) {
 		expected_names.resize(bound_insert.expected_types.size());
@@ -143,6 +145,7 @@ BoundStatement Binder::Bind(CopyStatement &stmt) {
 		// copy table into file without a query
 		// generate SELECT * FROM table;
 		auto ref = make_unique<BaseTableRef>();
+		ref->catalog_name = stmt.info->catalog;
 		ref->schema_name = stmt.info->schema;
 		ref->table_name = stmt.info->table;
 

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -31,32 +31,83 @@
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/parser/constraints/unique_constraint.hpp"
 #include "duckdb/parser/constraints/list.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
-SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
-	if (info.schema.empty()) {
-		info.schema = info.temporary ? TEMP_SCHEMA : ClientData::Get(context).catalog_search_path->GetDefault();
+void Binder::BindSchemaOrCatalog(ClientContext &context, string &catalog, string &schema) {
+	if (catalog.empty() && !schema.empty()) {
+		// schema is specified - but catalog is not
+		// try searching for the catalog instead
+		auto &db_manager = DatabaseManager::Get(context);
+		auto database = db_manager.GetDatabase(context, schema);
+		if (database) {
+			// we have a database with this name
+			// check if there is a schema
+			auto schema_obj = Catalog::GetSchema(context, INVALID_CATALOG, schema, true);
+			if (schema_obj) {
+				auto &attached = schema_obj->catalog->GetAttached();
+				throw BinderException(
+				    "Ambiguous reference to catalog or schema \"%s\" - use a fully qualified path like \"%s.%s\"",
+				    schema, attached.GetName(), schema);
+			}
+			catalog = schema;
+			schema = string();
+		}
 	}
+}
 
+void Binder::BindSchemaOrCatalog(string &catalog, string &schema) {
+	BindSchemaOrCatalog(context, catalog, schema);
+}
+
+SchemaCatalogEntry *Binder::BindSchema(CreateInfo &info) {
+	BindSchemaOrCatalog(info.catalog, info.schema);
+	if (IsInvalidCatalog(info.catalog) && info.temporary) {
+		info.catalog = TEMP_CATALOG;
+	}
+	auto &search_path = ClientData::Get(context).catalog_search_path;
+	if (IsInvalidCatalog(info.catalog) && IsInvalidSchema(info.schema)) {
+		auto &default_entry = search_path->GetDefault();
+		info.catalog = default_entry.catalog;
+		info.schema = default_entry.schema;
+	} else if (IsInvalidSchema(info.schema)) {
+		info.schema = search_path->GetDefaultSchema(info.catalog);
+	} else if (IsInvalidCatalog(info.catalog)) {
+		info.catalog = search_path->GetDefaultCatalog(info.schema);
+	}
+	if (IsInvalidCatalog(info.catalog)) {
+		info.catalog = DatabaseManager::GetDefaultDatabase(context);
+	}
 	if (!info.temporary) {
 		// non-temporary create: not read only
-		if (info.schema == TEMP_SCHEMA) {
-			throw ParserException("Only TEMPORARY table names can use the \"temp\" schema");
+		if (info.catalog == TEMP_CATALOG) {
+			throw ParserException("Only TEMPORARY table names can use the \"%s\" catalog", TEMP_CATALOG);
 		}
-		properties.read_only = false;
 	} else {
-		if (info.schema != TEMP_SCHEMA) {
-			throw ParserException("TEMPORARY table names can *only* use the \"%s\" schema", TEMP_SCHEMA);
+		if (info.catalog != TEMP_CATALOG) {
+			throw ParserException("TEMPORARY table names can *only* use the \"%s\" catalog", TEMP_CATALOG);
 		}
 	}
 	// fetch the schema in which we want to create the object
-	auto schema_obj = Catalog::GetCatalog(context).GetSchema(context, info.schema);
+	auto schema_obj = Catalog::GetSchema(context, info.catalog, info.schema);
 	D_ASSERT(schema_obj->type == CatalogType::SCHEMA_ENTRY);
 	info.schema = schema_obj->name;
+	if (!info.temporary) {
+		properties.modified_databases.insert(schema_obj->catalog->GetName());
+	}
 	return schema_obj;
 }
 
+SchemaCatalogEntry *Binder::BindCreateSchema(CreateInfo &info) {
+	auto schema = BindSchema(info);
+	if (schema->catalog->IsSystemCatalog()) {
+		throw BinderException("Cannot create entry in system catalog");
+	}
+	return schema;
+}
+
 void Binder::BindCreateViewInfo(CreateViewInfo &base) {
 	// bind the view as if it were a query so we can catch errors
 	// note that we bind the original, and replace the original with a copy
@@ -121,20 +172,20 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 		throw BinderException(error);
 	}
 
-	return BindSchema(info);
+	return BindCreateSchema(info);
 }
 
-void Binder::BindLogicalType(ClientContext &context, LogicalType &type, const string &schema) {
+void Binder::BindLogicalType(ClientContext &context, LogicalType &type, const string &catalog, const string &schema) {
 	if (type.id() == LogicalTypeId::LIST) {
 		auto child_type = ListType::GetChildType(type);
-		BindLogicalType(context, child_type, schema);
+		BindLogicalType(context, child_type, catalog, schema);
 		auto alias = type.GetAlias();
 		type = LogicalType::LIST(child_type);
 		type.SetAlias(alias);
 	} else if (type.id() == LogicalTypeId::STRUCT || type.id() == LogicalTypeId::MAP) {
 		auto child_types = StructType::GetChildTypes(type);
 		for (auto &child_type : child_types) {
-			BindLogicalType(context, child_type.second, schema);
+			BindLogicalType(context, child_type.second, catalog, schema);
 		}
 		// Generate new Struct/Map Type
 		auto alias = type.GetAlias();
@@ -147,19 +198,17 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, const st
 	} else if (type.id() == LogicalTypeId::UNION) {
 		auto member_types = UnionType::CopyMemberTypes(type);
 		for (auto &member_type : member_types) {
-			BindLogicalType(context, member_type.second, schema);
+			BindLogicalType(context, member_type.second, catalog, schema);
 		}
 		// Generate new Union Type
 		auto alias = type.GetAlias();
 		type = LogicalType::UNION(member_types);
 		type.SetAlias(alias);
 	} else if (type.id() == LogicalTypeId::USER) {
-		auto &catalog = Catalog::GetCatalog(context);
-		type = catalog.GetType(context, schema, UserType::GetTypeName(type));
+		type = Catalog::GetType(context, catalog, schema, UserType::GetTypeName(type));
 	} else if (type.id() == LogicalTypeId::ENUM) {
 		auto &enum_type_name = EnumType::GetTypeName(type);
-		auto enum_type_catalog = (TypeCatalogEntry *)context.db->GetCatalog().GetEntry(context, CatalogType::TYPE_ENTRY,
-		                                                                               schema, enum_type_name, true);
+		auto enum_type_catalog = Catalog::GetEntry<TypeCatalogEntry>(context, catalog, schema, enum_type_name, true);
 		LogicalType::SetCatalog(type, enum_type_catalog);
 	}
 }
@@ -344,18 +393,18 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	case CatalogType::VIEW_ENTRY: {
 		auto &base = (CreateViewInfo &)*stmt.info;
 		// bind the schema
-		auto schema = BindSchema(*stmt.info);
+		auto schema = BindCreateSchema(*stmt.info);
 		BindCreateViewInfo(base);
 		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_VIEW, move(stmt.info), schema);
 		break;
 	}
 	case CatalogType::SEQUENCE_ENTRY: {
-		auto schema = BindSchema(*stmt.info);
+		auto schema = BindCreateSchema(*stmt.info);
 		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SEQUENCE, move(stmt.info), schema);
 		break;
 	}
 	case CatalogType::TABLE_MACRO_ENTRY: {
-		auto schema = BindSchema(*stmt.info);
+		auto schema = BindCreateSchema(*stmt.info);
 		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, move(stmt.info), schema);
 		break;
 	}
@@ -393,6 +442,9 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 				throw BinderException("Cannot create an index on the rowid!");
 			}
 		}
+		if (table->temporary) {
+			stmt.info->temporary = true;
+		}
 
 		auto create_index_info = unique_ptr_cast<CreateInfo, CreateIndexInfo>(move(stmt.info));
 		for (auto &index : get.column_ids) {
@@ -409,7 +461,6 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	}
 	case CatalogType::TABLE_ENTRY: {
 		auto &create_info = (CreateTableInfo &)*stmt.info;
-		auto &catalog = Catalog::GetCatalog(context);
 		// If there is a foreign key constraint, resolve primary key column's index from primary key column's name
 		unordered_set<SchemaCatalogEntry *> fk_schemas;
 		for (idx_t i = 0; i < create_info.constraints.size(); i++) {
@@ -432,7 +483,8 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 				CheckForeignKeyTypes(create_info.columns, create_info.columns, fk);
 			} else {
 				// have to resolve referenced table
-				auto pk_table_entry_ptr = catalog.GetEntry<TableCatalogEntry>(context, fk.info.schema, fk.info.table);
+				auto pk_table_entry_ptr =
+				    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, fk.info.schema, fk.info.table);
 				fk_schemas.insert(pk_table_entry_ptr->schema);
 				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr->columns, pk_table_entry_ptr->constraints, fk);
 				FindForeignKeyIndexes(pk_table_entry_ptr->columns, fk.pk_columns, fk.info.pk_keys);
@@ -457,7 +509,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		auto root = move(bound_info->query);
 		for (auto &fk_schema : fk_schemas) {
 			if (fk_schema != bound_info->schema) {
-				throw BinderException("Creating foreign keys across different schemas is not supported");
+				throw BinderException("Creating foreign keys across different schemas or catalogs is not supported");
 			}
 		}
 
@@ -473,7 +525,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		break;
 	}
 	case CatalogType::TYPE_ENTRY: {
-		auto schema = BindSchema(*stmt.info);
+		auto schema = BindCreateSchema(*stmt.info);
 		auto &create_type_info = (CreateTypeInfo &)(*stmt.info);
 		result.plan = make_unique<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, move(stmt.info), schema);
 		if (create_type_info.query) {
@@ -518,8 +570,8 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			// 2: create a type alias with a custom type.
 			// eg. CREATE TYPE a AS INT; CREATE TYPE b AS a;
 			// We set b to be an alias for the underlying type of a
-			auto &catalog = Catalog::GetCatalog(context);
-			auto inner_type = catalog.GetType(context, "", UserType::GetTypeName(create_type_info.type));
+			auto inner_type = Catalog::GetType(context, schema->catalog->GetName(), schema->name,
+			                                   UserType::GetTypeName(create_type_info.type));
 			// clear to nullptr, we don't need this
 			LogicalType::SetCatalog(inner_type, nullptr);
 			inner_type.SetAlias(create_type_info.name);