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

package/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp

@@ -5,7 +5,8 @@ namespace duckdb {
 
 TableFunctionCatalogEntry::TableFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema,
                                                      CreateTableFunctionInfo *info)
-    : StandardEntry(CatalogType::TABLE_FUNCTION_ENTRY, schema, catalog, info->name), functions(move(info->functions)) {
+    : StandardEntry(CatalogType::TABLE_FUNCTION_ENTRY, schema, catalog, info->name),
+      functions(std::move(info->functions)) {
 	D_ASSERT(this->functions.Size() > 0);
 }
 

package/src/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp

@@ -12,7 +12,7 @@
 namespace duckdb {
 
 void ViewCatalogEntry::Initialize(CreateViewInfo *info) {
-	query = move(info->query);
+	query = std::move(info->query);
 	this->aliases = info->aliases;
 	this->types = info->types;
 	this->temporary = info->temporary;

package/src/duckdb/src/catalog/catalog_entry.cpp

@@ -5,8 +5,8 @@
 namespace duckdb {
 
 CatalogEntry::CatalogEntry(CatalogType type, Catalog *catalog_p, string name_p)
-    : oid(catalog_p ? catalog_p->ModifyCatalog() : 0), type(type), catalog(catalog_p), set(nullptr), name(move(name_p)),
-      deleted(false), temporary(false), internal(false), parent(nullptr) {
+    : oid(catalog_p ? catalog_p->ModifyCatalog() : 0), type(type), catalog(catalog_p), set(nullptr),
+      name(std::move(name_p)), deleted(false), temporary(false), internal(false), parent(nullptr) {
 }
 
 CatalogEntry::~CatalogEntry() {

package/src/duckdb/src/catalog/catalog_search_path.cpp

@@ -9,7 +9,7 @@
 namespace duckdb {
 
 CatalogSearchEntry::CatalogSearchEntry(string catalog_p, string schema_p)
-    : catalog(move(catalog_p)), schema(move(schema_p)) {
+    : catalog(std::move(catalog_p)), schema(std::move(schema_p)) {
 }
 
 string CatalogSearchEntry::ToString() const {
@@ -77,11 +77,11 @@ separator:
 	}
 	if (schema.empty()) {
 		// if we parse one entry it is the schema
-		schema = move(entry);
+		schema = std::move(entry);
 	} else if (catalog.empty()) {
 		// if we parse two entries it is [catalog.schema]
-		catalog = move(schema);
-		schema = move(entry);
+		catalog = std::move(schema);
+		schema = std::move(entry);
 	} else {
 		throw ParserException("Too many dots - expected [schema] or [catalog.schema] for CatalogSearchEntry");
 	}
@@ -95,7 +95,7 @@ final:
 	if (schema.empty()) {
 		throw ParserException("Unexpected end of entry - empty CatalogSearchEntry");
 	}
-	return CatalogSearchEntry(move(catalog), move(schema));
+	return CatalogSearchEntry(std::move(catalog), std::move(schema));
 }
 
 CatalogSearchEntry CatalogSearchEntry::Parse(const string &input) {
@@ -136,7 +136,7 @@ void CatalogSearchPath::Set(vector<CatalogSearchEntry> new_paths, bool is_set_sc
 				// only schema supplied - check if this is a database instead
 				auto schema = Catalog::GetSchema(context, path.schema, DEFAULT_SCHEMA, true);
 				if (schema) {
-					path.catalog = move(path.schema);
+					path.catalog = std::move(path.schema);
 					path.schema = schema->name;
 					continue;
 				}
@@ -145,13 +145,13 @@ void CatalogSearchPath::Set(vector<CatalogSearchEntry> new_paths, bool is_set_sc
 			                       is_set_schema ? "schema" : "search_path", path.ToString());
 		}
 	}
-	this->set_paths = move(new_paths);
+	this->set_paths = std::move(new_paths);
 	SetPaths(set_paths);
 }
 
 void CatalogSearchPath::Set(CatalogSearchEntry new_value, bool is_set_schema) {
-	vector<CatalogSearchEntry> new_paths {move(new_value)};
-	Set(move(new_paths), is_set_schema);
+	vector<CatalogSearchEntry> new_paths {std::move(new_value)};
+	Set(std::move(new_paths), is_set_schema);
 }
 
 const vector<CatalogSearchEntry> &CatalogSearchPath::Get() {
@@ -213,7 +213,7 @@ void CatalogSearchPath::SetPaths(vector<CatalogSearchEntry> new_paths) {
 	paths.reserve(new_paths.size() + 3);
 	paths.emplace_back(TEMP_CATALOG, DEFAULT_SCHEMA);
 	for (auto &path : new_paths) {
-		paths.push_back(move(path));
+		paths.push_back(std::move(path));
 	}
 	paths.emplace_back(INVALID_CATALOG, DEFAULT_SCHEMA);
 	paths.emplace_back(SYSTEM_CATALOG, DEFAULT_SCHEMA);

package/src/duckdb/src/catalog/catalog_set.cpp

@@ -1,9 +1,9 @@
 #include "duckdb/catalog/catalog_set.hpp"
 
-#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/transaction/transaction.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/common/serializer/buffered_serializer.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
 #include "duckdb/catalog/dependency_manager.hpp"
@@ -11,6 +11,7 @@
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/catalog/mapping_value.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 
@@ -39,8 +40,9 @@ private:
 	EntryIndex &entry_index;
 };
 
-CatalogSet::CatalogSet(Catalog &catalog, unique_ptr<DefaultGenerator> defaults)
-    : catalog(catalog), defaults(move(defaults)) {
+CatalogSet::CatalogSet(Catalog &catalog_p, unique_ptr<DefaultGenerator> defaults)
+    : catalog((DuckCatalog &)catalog_p), defaults(std::move(defaults)) {
+	D_ASSERT(catalog_p.IsDuckCatalog());
 }
 CatalogSet::~CatalogSet() {
 }
@@ -49,7 +51,7 @@ EntryIndex CatalogSet::PutEntry(idx_t entry_index, unique_ptr<CatalogEntry> entr
 	if (entries.find(entry_index) != entries.end()) {
 		throw InternalException("Entry with entry index \"%llu\" already exists", entry_index);
 	}
-	entries.insert(make_pair(entry_index, EntryValue(move(entry))));
+	entries.insert(make_pair(entry_index, EntryValue(std::move(entry))));
 	return EntryIndex(*this, entry_index);
 }
 
@@ -58,9 +60,9 @@ void CatalogSet::PutEntry(EntryIndex index, unique_ptr<CatalogEntry> catalog_ent
 	if (entry == entries.end()) {
 		throw InternalException("Entry with entry index \"%llu\" does not exist", index.GetIndex());
 	}
-	catalog_entry->child = move(entry->second.entry);
+	catalog_entry->child = std::move(entry->second.entry);
 	catalog_entry->child->parent = catalog_entry.get();
-	entry->second.entry = move(catalog_entry);
+	entry->second.entry = std::move(catalog_entry);
 }
 
 bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
@@ -85,7 +87,7 @@ bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name,
 		}
 	}
 	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.write_lock);
+	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 	// lock this catalog set to disallow reading
 	unique_lock<mutex> read_lock(catalog_lock);
 
@@ -109,9 +111,9 @@ bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name,
 		dummy_node->deleted = true;
 		dummy_node->set = this;
 
-		auto entry_index = PutEntry(current_entry++, move(dummy_node));
+		auto entry_index = PutEntry(current_entry++, std::move(dummy_node));
 		index = entry_index.GetIndex();
-		PutMapping(transaction, name, move(entry_index));
+		PutMapping(transaction, name, std::move(entry_index));
 	} else {
 		index = mapping_value->index.GetIndex();
 		auto &current = *mapping_value->index.GetEntry();
@@ -134,21 +136,22 @@ bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name,
 	value->set = this;
 
 	// now add the dependency set of this object to the dependency manager
-	catalog.dependency_manager->AddObject(transaction, value.get(), dependencies);
+	catalog.GetDependencyManager().AddObject(transaction, value.get(), dependencies);
 
 	auto value_ptr = value.get();
 	EntryIndex entry_index(*this, index);
-	PutEntry(move(entry_index), move(value));
+	PutEntry(std::move(entry_index), std::move(value));
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
-		transaction.transaction->PushCatalogEntry(value_ptr->child.get());
+		auto &dtransaction = (DuckTransaction &)*transaction.transaction;
+		dtransaction.PushCatalogEntry(value_ptr->child.get());
 	}
 	return true;
 }
 
 bool CatalogSet::CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
                              DependencyList &dependencies) {
-	return CreateEntry(catalog.GetCatalogTransaction(context), name, move(value), dependencies);
+	return CreateEntry(catalog.GetCatalogTransaction(context), name, std::move(value), dependencies);
 }
 
 bool CatalogSet::GetEntryInternal(CatalogTransaction transaction, EntryIndex &entry_index,
@@ -193,14 +196,14 @@ bool CatalogSet::AlterOwnership(CatalogTransaction transaction, ChangeOwnershipI
 		return false;
 	}
 
-	catalog.dependency_manager->AddOwnership(transaction, owner_entry, entry);
+	catalog.GetDependencyManager().AddOwnership(transaction, owner_entry, entry);
 
 	return true;
 }
 
 bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name, AlterInfo *alter_info) {
 	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.write_lock);
+	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 
 	// first check if the entry exists in the unordered set
 	EntryIndex entry_index;
@@ -251,7 +254,7 @@ bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name,
 	value->timestamp = transaction.transaction_id;
 	value->set = this;
 	auto new_entry = value.get();
-	PutEntry(move(entry_index), move(value));
+	PutEntry(std::move(entry_index), std::move(value));
 
 	// serialize the AlterInfo into a temporary buffer
 	BufferedSerializer serializer;
@@ -260,15 +263,15 @@ bool CatalogSet::AlterEntry(CatalogTransaction transaction, const string &name,
 
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
-		transaction.transaction->PushCatalogEntry(new_entry->child.get(), serialized_alter.data.get(),
-		                                          serialized_alter.size);
+		auto &dtransaction = (DuckTransaction &)*transaction.transaction;
+		dtransaction.PushCatalogEntry(new_entry->child.get(), serialized_alter.data.get(), serialized_alter.size);
 	}
 
 	// Check the dependency manager to verify that there are no conflicting dependencies with this alter
 	// Note that we do this AFTER the new entry has been entirely set up in the catalog set
 	// that is because in case the alter fails because of a dependency conflict, we need to be able to cleanly roll back
 	// to the old entry.
-	catalog.dependency_manager->AlterObject(transaction, entry, new_entry);
+	catalog.GetDependencyManager().AlterObject(transaction, entry, new_entry);
 
 	return true;
 }
@@ -282,7 +285,8 @@ void CatalogSet::DropEntryDependencies(CatalogTransaction transaction, EntryInde
 	entry_index.GetEntry()->deleted = true;
 
 	// check any dependencies of this object
-	entry.catalog->dependency_manager->DropObject(transaction, &entry, cascade);
+	D_ASSERT(entry.catalog->IsDuckCatalog());
+	((DuckCatalog &)*entry.catalog).GetDependencyManager().DropObject(transaction, &entry, cascade);
 
 	// dropper destructor is called here
 	// the destructor makes sure to return the value to the previous state
@@ -301,17 +305,18 @@ void CatalogSet::DropEntryInternal(CatalogTransaction transaction, EntryIndex en
 	value->set = this;
 	value->deleted = true;
 	auto value_ptr = value.get();
-	PutEntry(move(entry_index), move(value));
+	PutEntry(std::move(entry_index), std::move(value));
 
 	// push the old entry in the undo buffer for this transaction
 	if (transaction.transaction) {
-		transaction.transaction->PushCatalogEntry(value_ptr->child.get());
+		auto &dtransaction = (DuckTransaction &)*transaction.transaction;
+		dtransaction.PushCatalogEntry(value_ptr->child.get());
 	}
 }
 
 bool CatalogSet::DropEntry(CatalogTransaction transaction, const string &name, bool cascade, bool allow_drop_internal) {
 	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.write_lock);
+	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 	// we can only delete an entry that exists
 	EntryIndex entry_index;
 	CatalogEntry *entry;
@@ -323,7 +328,7 @@ bool CatalogSet::DropEntry(CatalogTransaction transaction, const string &name, b
 	}
 
 	lock_guard<mutex> read_lock(catalog_lock);
-	DropEntryInternal(transaction, move(entry_index), *entry, cascade);
+	DropEntryInternal(transaction, std::move(entry_index), *entry, cascade);
 	return true;
 }
 
@@ -331,7 +336,7 @@ bool CatalogSet::DropEntry(ClientContext &context, const string &name, bool casc
 	return DropEntry(catalog.GetCatalogTransaction(context), name, cascade, allow_drop_internal);
 }
 
-Catalog &CatalogSet::GetCatalog() {
+DuckCatalog &CatalogSet::GetCatalog() {
 	return catalog;
 }
 
@@ -339,14 +344,15 @@ void CatalogSet::CleanupEntry(CatalogEntry *catalog_entry) {
 	// destroy the backed up entry: it is no longer required
 	D_ASSERT(catalog_entry->parent);
 	if (catalog_entry->parent->type != CatalogType::UPDATED_ENTRY) {
-		lock_guard<mutex> write_lock(catalog.write_lock);
+		lock_guard<mutex> write_lock(catalog.GetWriteLock());
 		lock_guard<mutex> lock(catalog_lock);
 		if (!catalog_entry->deleted) {
 			// delete the entry from the dependency manager, if it is not deleted yet
-			catalog_entry->catalog->dependency_manager->EraseObject(catalog_entry);
+			D_ASSERT(catalog_entry->catalog->IsDuckCatalog());
+			((DuckCatalog &)*catalog_entry->catalog).GetDependencyManager().EraseObject(catalog_entry);
 		}
 		auto parent = catalog_entry->parent;
-		parent->child = move(catalog_entry->child);
+		parent->child = std::move(catalog_entry->child);
 		if (parent->deleted && !parent->child && !parent->parent) {
 			auto mapping_entry = mapping.find(parent->name);
 			D_ASSERT(mapping_entry != mapping.end());
@@ -388,16 +394,16 @@ MappingValue *CatalogSet::GetMapping(CatalogTransaction transaction, const strin
 
 void CatalogSet::PutMapping(CatalogTransaction transaction, const string &name, EntryIndex entry_index) {
 	auto entry = mapping.find(name);
-	auto new_value = make_unique<MappingValue>(move(entry_index));
+	auto new_value = make_unique<MappingValue>(std::move(entry_index));
 	new_value->timestamp = transaction.transaction_id;
 	if (entry != mapping.end()) {
 		if (HasConflict(transaction, entry->second->timestamp)) {
 			throw TransactionException("Catalog write-write conflict on name \"%s\"", name);
 		}
-		new_value->child = move(entry->second);
+		new_value->child = std::move(entry->second);
 		new_value->child->parent = new_value.get();
 	}
-	mapping[name] = move(new_value);
+	mapping[name] = std::move(new_value);
 }
 
 void CatalogSet::DeleteMapping(CatalogTransaction transaction, const string &name) {
@@ -406,9 +412,9 @@ void CatalogSet::DeleteMapping(CatalogTransaction transaction, const string &nam
 	auto delete_marker = make_unique<MappingValue>(entry->second->index.Copy());
 	delete_marker->deleted = true;
 	delete_marker->timestamp = transaction.transaction_id;
-	delete_marker->child = move(entry->second);
+	delete_marker->child = std::move(entry->second);
 	delete_marker->child->parent = delete_marker.get();
-	mapping[name] = move(delete_marker);
+	mapping[name] = std::move(delete_marker);
 }
 
 bool CatalogSet::UseTimestamp(CatalogTransaction transaction, transaction_t timestamp) {
@@ -446,23 +452,22 @@ CatalogEntry *CatalogSet::GetCommittedEntry(CatalogEntry *current) {
 	return current;
 }
 
-pair<string, idx_t> CatalogSet::SimilarEntry(CatalogTransaction transaction, const string &name) {
+SimilarCatalogEntry CatalogSet::SimilarEntry(CatalogTransaction transaction, const string &name) {
 	unique_lock<mutex> lock(catalog_lock);
 	CreateDefaultEntries(transaction, lock);
 
-	string result;
-	idx_t current_score = (idx_t)-1;
+	SimilarCatalogEntry result;
 	for (auto &kv : mapping) {
 		auto mapping_value = GetMapping(transaction, kv.first);
 		if (mapping_value && !mapping_value->deleted) {
 			auto ldist = StringUtil::LevenshteinDistance(kv.first, name);
-			if (ldist < current_score) {
-				current_score = ldist;
-				result = kv.first;
+			if (ldist < result.distance) {
+				result.distance = ldist;
+				result.name = kv.first;
 			}
 		}
 	}
-	return {result, current_score};
+	return result;
 }
 
 CatalogEntry *CatalogSet::CreateEntryInternal(CatalogTransaction transaction, unique_ptr<CatalogEntry> entry) {
@@ -475,8 +480,8 @@ CatalogEntry *CatalogSet::CreateEntryInternal(CatalogTransaction transaction, un
 	entry->set = this;
 	entry->timestamp = 0;
 
-	auto entry_index = PutEntry(current_entry++, move(entry));
-	PutMapping(transaction, name, move(entry_index));
+	auto entry_index = PutEntry(current_entry++, std::move(entry));
+	PutMapping(transaction, name, std::move(entry_index));
 	mapping[name]->timestamp = 0;
 	return catalog_entry;
 }
@@ -503,7 +508,7 @@ CatalogEntry *CatalogSet::CreateDefaultEntry(CatalogTransaction transaction, con
 		return nullptr;
 	}
 	// there is a default entry! create it
-	auto result = CreateEntryInternal(transaction, move(entry));
+	auto result = CreateEntryInternal(transaction, std::move(entry));
 	if (result) {
 		return result;
 	}
@@ -543,12 +548,13 @@ void CatalogSet::UpdateTimestamp(CatalogEntry *entry, transaction_t timestamp) {
 void CatalogSet::AdjustUserDependency(CatalogEntry *entry, ColumnDefinition &column, bool remove) {
 	CatalogEntry *user_type_catalog = (CatalogEntry *)LogicalType::GetCatalog(column.Type());
 	if (user_type_catalog) {
+		auto &dependency_manager = catalog.GetDependencyManager();
 		if (remove) {
-			catalog.dependency_manager->dependents_map[user_type_catalog].erase(entry->parent);
-			catalog.dependency_manager->dependencies_map[entry->parent].erase(user_type_catalog);
+			dependency_manager.dependents_map[user_type_catalog].erase(entry->parent);
+			dependency_manager.dependencies_map[entry->parent].erase(user_type_catalog);
 		} else {
-			catalog.dependency_manager->dependents_map[user_type_catalog].insert(entry);
-			catalog.dependency_manager->dependencies_map[entry].insert(user_type_catalog);
+			dependency_manager.dependents_map[user_type_catalog].insert(entry);
+			dependency_manager.dependencies_map[entry].insert(user_type_catalog);
 		}
 	}
 }
@@ -557,7 +563,7 @@ void CatalogSet::AdjustDependency(CatalogEntry *entry, TableCatalogEntry *table,
                                   bool remove) {
 	bool found = false;
 	if (column.Type().id() == LogicalTypeId::ENUM) {
-		for (auto &old_column : table->columns.Logical()) {
+		for (auto &old_column : table->GetColumns().Logical()) {
 			if (old_column.Name() == column.Name() && old_column.Type().id() != LogicalTypeId::ENUM) {
 				AdjustUserDependency(entry, column, remove);
 				found = true;
@@ -568,7 +574,7 @@ void CatalogSet::AdjustDependency(CatalogEntry *entry, TableCatalogEntry *table,
 		}
 	} else if (!(column.Type().GetAlias().empty())) {
 		auto alias = column.Type().GetAlias();
-		for (auto &old_column : table->columns.Logical()) {
+		for (auto &old_column : table->GetColumns().Logical()) {
 			auto old_alias = old_column.Type().GetAlias();
 			if (old_column.Name() == column.Name() && old_alias != alias) {
 				AdjustUserDependency(entry, column, remove);
@@ -587,20 +593,19 @@ void CatalogSet::AdjustTableDependencies(CatalogEntry *entry) {
 		auto old_table = (TableCatalogEntry *)entry->parent;
 		auto new_table = (TableCatalogEntry *)entry;
 
-		for (idx_t i = 0; i < new_table->columns.LogicalColumnCount(); i++) {
-			auto &new_column = new_table->columns.GetColumnMutable(LogicalIndex(i));
+		for (idx_t i = 0; i < new_table->GetColumns().LogicalColumnCount(); i++) {
+			auto &new_column = new_table->GetColumnsMutable().GetColumnMutable(LogicalIndex(i));
 			AdjustDependency(entry, old_table, new_column, false);
 		}
-		for (idx_t i = 0; i < old_table->columns.LogicalColumnCount(); i++) {
-			auto &old_column = old_table->columns.GetColumnMutable(LogicalIndex(i));
+		for (idx_t i = 0; i < old_table->GetColumns().LogicalColumnCount(); i++) {
+			auto &old_column = old_table->GetColumnsMutable().GetColumnMutable(LogicalIndex(i));
 			AdjustDependency(entry, new_table, old_column, true);
 		}
 	}
 }
 
 void CatalogSet::Undo(CatalogEntry *entry) {
-	lock_guard<mutex> write_lock(catalog.write_lock);
-
+	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 	lock_guard<mutex> lock(catalog_lock);
 
 	// entry has to be restored
@@ -613,14 +618,15 @@ void CatalogSet::Undo(CatalogEntry *entry) {
 
 	if (!to_be_removed_node->deleted) {
 		// delete the entry from the dependency manager as well
-		catalog.dependency_manager->EraseObject(to_be_removed_node);
+		auto &dependency_manager = catalog.GetDependencyManager();
+		dependency_manager.EraseObject(to_be_removed_node);
 	}
 	if (entry->name != to_be_removed_node->name) {
 		// rename: clean up the new name when the rename is rolled back
 		auto removed_entry = mapping.find(to_be_removed_node->name);
 		if (removed_entry->second->child) {
 			removed_entry->second->child->parent = nullptr;
-			mapping[to_be_removed_node->name] = move(removed_entry->second->child);
+			mapping[to_be_removed_node->name] = std::move(removed_entry->second->child);
 		} else {
 			mapping.erase(removed_entry);
 		}
@@ -628,13 +634,13 @@ void CatalogSet::Undo(CatalogEntry *entry) {
 	if (to_be_removed_node->parent) {
 		// if the to be removed node has a parent, set the child pointer to the
 		// to be restored node
-		to_be_removed_node->parent->child = move(to_be_removed_node->child);
+		to_be_removed_node->parent->child = std::move(to_be_removed_node->child);
 		entry->parent = to_be_removed_node->parent;
 	} else {
 		// otherwise we need to update the base entry tables
 		auto &name = entry->name;
 		to_be_removed_node->child->SetAsRoot();
-		mapping[name]->index.GetEntry() = move(to_be_removed_node->child);
+		mapping[name]->index.GetEntry() = std::move(to_be_removed_node->child);
 		entry->parent = nullptr;
 	}
 
@@ -643,7 +649,7 @@ void CatalogSet::Undo(CatalogEntry *entry) {
 	if (restored_entry->second->deleted || entry->type == CatalogType::INVALID) {
 		if (restored_entry->second->child) {
 			restored_entry->second->child->parent = nullptr;
-			mapping[entry->name] = move(restored_entry->second->child);
+			mapping[entry->name] = std::move(restored_entry->second->child);
 		} else {
 			mapping.erase(restored_entry);
 		}
@@ -670,7 +676,7 @@ void CatalogSet::CreateDefaultEntries(CatalogTransaction transaction, unique_loc
 			}
 
 			lock.lock();
-			CreateEntryInternal(transaction, move(entry));
+			CreateEntryInternal(transaction, std::move(entry));
 		}
 	}
 	defaults->created_all_entries = true;

package/src/duckdb/src/catalog/catalog_transaction.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/catalog/catalog_transaction.hpp"
 #include "duckdb/catalog/catalog.hpp"
-#include "duckdb/transaction/transaction.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/main/database.hpp"
 
 namespace duckdb {
@@ -8,8 +8,14 @@ namespace duckdb {
 CatalogTransaction::CatalogTransaction(Catalog &catalog, ClientContext &context) {
 	auto &transaction = Transaction::Get(context, catalog);
 	this->db = &DatabaseInstance::GetDatabase(context);
-	this->transaction_id = transaction.transaction_id;
-	this->start_time = transaction.start_time;
+	if (!transaction.IsDuckTransaction()) {
+		this->transaction_id = transaction_t(-1);
+		this->start_time = transaction_t(-1);
+	} else {
+		auto &dtransaction = (DuckTransaction &)transaction;
+		this->transaction_id = dtransaction.transaction_id;
+		this->start_time = dtransaction.start_time;
+	}
 	this->transaction = &transaction;
 	this->context = &context;
 }

package/src/duckdb/src/catalog/default/default_functions.cpp

@@ -11,8 +11,7 @@ namespace duckdb {
 
 static DefaultMacro internal_macros[] = {
 	{DEFAULT_SCHEMA, "current_user", {nullptr}, "'duckdb'"},                       // user name of current execution context
-	{DEFAULT_SCHEMA, "current_catalog", {nullptr}, "'duckdb'"},                    // name of current database (called "catalog" in the SQL standard)
-	{DEFAULT_SCHEMA, "current_database", {nullptr}, "'duckdb'"},                   // name of current database
+	{DEFAULT_SCHEMA, "current_catalog", {nullptr}, "current_database()"},          // name of current database (called "catalog" in the SQL standard)
 	{DEFAULT_SCHEMA, "user", {nullptr}, "current_user"},                           // equivalent to current_user
 	{DEFAULT_SCHEMA, "session_user", {nullptr}, "'duckdb'"},                       // session user name
 	{"pg_catalog", "inet_client_addr", {nullptr}, "NULL"},                       // address of the remote connection
@@ -93,6 +92,7 @@ static DefaultMacro internal_macros[] = {
 	{DEFAULT_SCHEMA, "generate_subscripts", {"arr", "dim", nullptr}, "unnest(generate_series(1, array_length(arr, dim)))"},
 	{DEFAULT_SCHEMA, "fdiv", {"x", "y", nullptr}, "floor(x/y)"},
 	{DEFAULT_SCHEMA, "fmod", {"x", "y", nullptr}, "(x-y*floor(x/y))"},
+	{DEFAULT_SCHEMA, "count_if", {"l", nullptr}, "sum(if(l, 1, 0))"},
 
 	// algebraic list aggregates
 	{DEFAULT_SCHEMA, "list_avg", {"l", nullptr}, "list_aggr(l, 'avg')"},
@@ -145,7 +145,7 @@ unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroIn
 	bind_info->temporary = true;
 	bind_info->internal = true;
 	bind_info->type = function->type == MacroType::TABLE_MACRO ? CatalogType::TABLE_MACRO_ENTRY : CatalogType::MACRO_ENTRY;
-	bind_info->function = move(function);
+	bind_info->function = std::move(function);
 	return bind_info;
 
 }
@@ -155,8 +155,8 @@ unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(De
 	auto expressions = Parser::ParseExpressionList(default_macro.macro);
 	D_ASSERT(expressions.size() == 1);
 
-	auto result = make_unique<ScalarMacroFunction>(move(expressions[0]));
-	return CreateInternalTableMacroInfo(default_macro, move(result));
+	auto result = make_unique<ScalarMacroFunction>(std::move(expressions[0]));
+	return CreateInternalTableMacroInfo(default_macro, std::move(result));
 }
 
 unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroInfo(DefaultMacro &default_macro) {
@@ -166,8 +166,8 @@ unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroIn
 	D_ASSERT(parser.statements[0]->type == StatementType::SELECT_STATEMENT);
 
 	auto &select = (SelectStatement &) *parser.statements[0];
-	auto result = make_unique<TableMacroFunction>(move(select.node));
-	return CreateInternalTableMacroInfo(default_macro, move(result));
+	auto result = make_unique<TableMacroFunction>(std::move(select.node));
+	return CreateInternalTableMacroInfo(default_macro, std::move(result));
 }
 
 static unique_ptr<CreateFunctionInfo> GetDefaultFunction(const string &input_schema, const string &input_name) {

package/src/duckdb/src/catalog/default/default_schemas.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/catalog/default/default_schemas.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/duck_schema_entry.hpp"
 #include "duckdb/common/string_util.hpp"
 
 namespace duckdb {
@@ -25,7 +25,7 @@ DefaultSchemaGenerator::DefaultSchemaGenerator(Catalog &catalog) : DefaultGenera
 
 unique_ptr<CatalogEntry> DefaultSchemaGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
 	if (GetDefaultSchema(entry_name)) {
-		return make_unique_base<CatalogEntry, SchemaCatalogEntry>(&catalog, StringUtil::Lower(entry_name), true);
+		return make_unique_base<CatalogEntry, DuckSchemaEntry>(&catalog, StringUtil::Lower(entry_name), true);
 	}
 	return nullptr;
 }

package/src/duckdb/src/catalog/default/default_types.cpp

@@ -28,6 +28,8 @@ static DefaultType internal_types[] = {{"int", LogicalTypeId::INTEGER},
                                        {"blob", LogicalTypeId::BLOB},
                                        {"varbinary", LogicalTypeId::BLOB},
                                        {"binary", LogicalTypeId::BLOB},
+                                       {"bit", LogicalTypeId::BIT},
+                                       {"bitstring", LogicalTypeId::BIT},
                                        {"int8", LogicalTypeId::BIGINT},
                                        {"bigint", LogicalTypeId::BIGINT},
                                        {"int64", LogicalTypeId::BIGINT},
@@ -78,7 +80,6 @@ static DefaultType internal_types[] = {{"int", LogicalTypeId::INTEGER},
                                        {"union", LogicalTypeId::UNION},
                                        {"timestamptz", LogicalTypeId::TIMESTAMP_TZ},
                                        {"timetz", LogicalTypeId::TIME_TZ},
-                                       {"json", LogicalTypeId::JSON},
                                        {"enum", LogicalTypeId::ENUM},
                                        {"null", LogicalTypeId::SQLNULL},
                                        {nullptr, LogicalTypeId::INVALID}};