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

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

@@ -1,6 +1,4 @@
 #include "duckdb/catalog/default/default_views.hpp"
-#include "duckdb/parser/parser.hpp"
-#include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
@@ -15,13 +13,14 @@ struct DefaultView {
 };
 
 static DefaultView internal_views[] = {
-    {DEFAULT_SCHEMA, "pragma_database_list", "SELECT * FROM pragma_database_list()"},
+    {DEFAULT_SCHEMA, "pragma_database_list", "SELECT database_oid AS seq, database_name AS name, path AS file FROM duckdb_databases() WHERE NOT internal ORDER BY 1"},
     {DEFAULT_SCHEMA, "sqlite_master", "select 'table' \"type\", table_name \"name\", table_name \"tbl_name\", 0 rootpage, sql from duckdb_tables union all select 'view' \"type\", view_name \"name\", view_name \"tbl_name\", 0 rootpage, sql from duckdb_views union all select 'index' \"type\", index_name \"name\", table_name \"tbl_name\", 0 rootpage, sql from duckdb_indexes;"},
     {DEFAULT_SCHEMA, "sqlite_schema", "SELECT * FROM sqlite_master"},
     {DEFAULT_SCHEMA, "sqlite_temp_master", "SELECT * FROM sqlite_master"},
     {DEFAULT_SCHEMA, "sqlite_temp_schema", "SELECT * FROM sqlite_master"},
     {DEFAULT_SCHEMA, "duckdb_constraints", "SELECT * FROM duckdb_constraints()"},
     {DEFAULT_SCHEMA, "duckdb_columns", "SELECT * FROM duckdb_columns() WHERE NOT internal"},
+    {DEFAULT_SCHEMA, "duckdb_databases", "SELECT * FROM duckdb_databases() WHERE NOT internal"},
     {DEFAULT_SCHEMA, "duckdb_indexes", "SELECT * FROM duckdb_indexes()"},
     {DEFAULT_SCHEMA, "duckdb_schemas", "SELECT * FROM duckdb_schemas() WHERE NOT internal"},
     {DEFAULT_SCHEMA, "duckdb_tables", "SELECT * FROM duckdb_tables() WHERE NOT internal"},
@@ -32,7 +31,7 @@ static DefaultView internal_views[] = {
     {"pg_catalog", "pg_attrdef", "SELECT column_index oid, table_oid adrelid, column_index adnum, column_default adbin from duckdb_columns() where column_default is not null;"},
     {"pg_catalog", "pg_class", "SELECT table_oid oid, table_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, estimated_size::real reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, index_count > 0 relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'r' relkind, column_count relnatts, check_constraint_count relchecks, false relhasoids, has_primary_key relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_tables() UNION ALL SELECT view_oid oid, view_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'v' relkind, column_count relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_views() UNION ALL SELECT sequence_oid oid, sequence_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, case when temporary then 't' else 'p' end relpersistence, 'S' relkind, 0 relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_sequences() UNION ALL SELECT index_oid oid, index_name relname, schema_oid relnamespace, 0 reltype, 0 reloftype, 0 relowner, 0 relam, 0 relfilenode, 0 reltablespace, 0 relpages, 0 reltuples, 0 relallvisible, 0 reltoastrelid, 0 reltoastidxid, false relhasindex, false relisshared, 't' relpersistence, 'i' relkind, NULL relnatts, 0 relchecks, false relhasoids, false relhaspkey, false relhasrules, false relhastriggers, false relhassubclass, false relrowsecurity, true relispopulated, NULL relreplident, false relispartition, 0 relrewrite, 0 relfrozenxid, NULL relminmxid, NULL relacl, NULL reloptions, NULL relpartbound FROM duckdb_indexes()"},
     {"pg_catalog", "pg_constraint", "SELECT table_oid*1000000+constraint_index oid, constraint_text conname, schema_oid connamespace, CASE constraint_type WHEN 'CHECK' then 'c' WHEN 'UNIQUE' then 'u' WHEN 'PRIMARY KEY' THEN 'p' WHEN 'FOREIGN KEY' THEN 'f' ELSE 'x' END contype, false condeferrable, false condeferred, true convalidated, table_oid conrelid, 0 contypid, 0 conindid, 0 conparentid, 0 confrelid, NULL confupdtype, NULL confdeltype, NULL confmatchtype, true conislocal, 0 coninhcount, false connoinherit, constraint_column_indexes conkey, NULL confkey, NULL conpfeqop, NULL conppeqop, NULL conffeqop, NULL conexclop, expression conbin FROM duckdb_constraints()"},
-	{"pg_catalog", "pg_database", "SELECT 0 oid, 'main' datname"},
+	{"pg_catalog", "pg_database", "SELECT database_oid oid, database_name datname FROM duckdb_databases()"},
     {"pg_catalog", "pg_depend", "SELECT * FROM duckdb_dependencies()"},
 	{"pg_catalog", "pg_description", "SELECT NULL objoid, NULL classoid, NULL objsubid, NULL description WHERE 1=0"},
     {"pg_catalog", "pg_enum", "SELECT NULL oid, a.type_oid enumtypid, list_position(b.labels, a.elabel) enumsortorder, a.elabel enumlabel FROM (SELECT UNNEST(labels) elabel, type_oid FROM duckdb_types() WHERE logical_type='ENUM') a JOIN duckdb_types() b ON a.type_oid=b.type_oid;"},
@@ -52,23 +51,19 @@ static DefaultView internal_views[] = {
     {"information_schema", "tables", "SELECT database_name table_catalog, schema_name table_schema, table_name, CASE WHEN temporary THEN 'LOCAL TEMPORARY' ELSE 'BASE TABLE' END table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'YES' is_insertable_into, 'NO' is_typed, CASE WHEN temporary THEN 'PRESERVE' ELSE NULL END commit_action FROM duckdb_tables() UNION ALL SELECT NULL table_catalog, schema_name table_schema, view_name table_name, 'VIEW' table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'NO' is_insertable_into, 'NO' is_typed, NULL commit_action FROM duckdb_views;"},
     {nullptr, nullptr, nullptr}};
 
-static unique_ptr<CreateViewInfo> GetDefaultView(const string &input_schema, const string &input_name) {
+static unique_ptr<CreateViewInfo> GetDefaultView(ClientContext &context, const string &input_schema, const string &input_name) {
 	auto schema = StringUtil::Lower(input_schema);
 	auto name = StringUtil::Lower(input_name);
 	for (idx_t index = 0; internal_views[index].name != nullptr; index++) {
 		if (internal_views[index].schema == schema && internal_views[index].name == name) {
 			auto result = make_unique<CreateViewInfo>();
 			result->schema = schema;
+			result->view_name = name;
 			result->sql = internal_views[index].sql;
-
-			Parser parser;
-			parser.ParseQuery(internal_views[index].sql);
-			D_ASSERT(parser.statements.size() == 1 && parser.statements[0]->type == StatementType::SELECT_STATEMENT);
-			result->query = unique_ptr_cast<SQLStatement, SelectStatement>(move(parser.statements[0]));
 			result->temporary = true;
 			result->internal = true;
-			result->view_name = name;
-			return result;
+
+			return CreateViewInfo::FromSelect(context, std::move(result));
 		}
 	}
 	return nullptr;
@@ -79,11 +74,8 @@ DefaultViewGenerator::DefaultViewGenerator(Catalog &catalog, SchemaCatalogEntry
 }
 
 unique_ptr<CatalogEntry> DefaultViewGenerator::CreateDefaultEntry(ClientContext &context, const string &entry_name) {
-	auto info = GetDefaultView(schema->name, entry_name);
+	auto info = GetDefaultView(context, schema->name, entry_name);
 	if (info) {
-		auto binder = Binder::CreateBinder(context);
-		binder->BindCreateViewInfo(*info);
-
 		return make_unique_base<CatalogEntry, ViewCatalogEntry>(&catalog, schema, info.get());
 	}
 	return nullptr;

package/src/duckdb/src/catalog/dependency_manager.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/catalog/dependency_manager.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
-#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
 #include "duckdb/catalog/catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/main/client_context.hpp"
@@ -11,7 +11,7 @@
 
 namespace duckdb {
 
-DependencyManager::DependencyManager(Catalog &catalog) : catalog(catalog) {
+DependencyManager::DependencyManager(DuckCatalog &catalog) : catalog(catalog) {
 }
 
 void DependencyManager::AddObject(CatalogTransaction transaction, CatalogEntry *object, DependencyList &dependencies) {
@@ -109,7 +109,7 @@ void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry
 			auto user_type = (TypeCatalogEntry *)dependency;
 			auto table = (TableCatalogEntry *)new_obj;
 			bool deleted_dependency = true;
-			for (auto &column : table->columns.Logical()) {
+			for (auto &column : table->GetColumns().Logical()) {
 				if (column.Type() == user_type->user_type) {
 					deleted_dependency = false;
 					break;
@@ -131,7 +131,7 @@ void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry
 	vector<CatalogEntry *> to_add;
 	if (new_obj->type == CatalogType::TABLE_ENTRY) {
 		auto table = (TableCatalogEntry *)new_obj;
-		for (auto &column : table->columns.Logical()) {
+		for (auto &column : table->GetColumns().Logical()) {
 			auto user_type_catalog = LogicalType::GetCatalog(column.Type());
 			if (user_type_catalog) {
 				to_add.push_back(user_type_catalog);
@@ -180,7 +180,7 @@ void DependencyManager::EraseObjectInternal(CatalogEntry *object) {
 }
 
 void DependencyManager::Scan(const std::function<void(CatalogEntry *, CatalogEntry *, DependencyType)> &callback) {
-	lock_guard<mutex> write_lock(catalog.write_lock);
+	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 	for (auto &entry : dependents_map) {
 		for (auto &dependent : entry.second) {
 			callback(entry.first, dependent.entry, dependent.dependency_type);
@@ -190,7 +190,7 @@ void DependencyManager::Scan(const std::function<void(CatalogEntry *, CatalogEnt
 
 void DependencyManager::AddOwnership(CatalogTransaction transaction, CatalogEntry *owner, CatalogEntry *entry) {
 	// lock the catalog for writing
-	lock_guard<mutex> write_lock(catalog.write_lock);
+	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 
 	// If the owner is already owned by something else, throw an error
 	for (auto &dep : dependents_map[owner]) {

package/src/duckdb/src/catalog/duck_catalog.cpp

@@ -0,0 +1,111 @@
+#include "duckdb/catalog/duck_catalog.hpp"
+#include "duckdb/catalog/dependency_manager.hpp"
+#include "duckdb/catalog/catalog_entry/duck_schema_entry.hpp"
+#include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/parser/parsed_data/drop_info.hpp"
+#include "duckdb/parser/parsed_data/create_schema_info.hpp"
+#include "duckdb/catalog/default/default_schemas.hpp"
+#include "duckdb/function/built_in_functions.hpp"
+#include "duckdb/main/attached_database.hpp"
+
+namespace duckdb {
+
+DuckCatalog::DuckCatalog(AttachedDatabase &db)
+    : Catalog(db), dependency_manager(make_unique<DependencyManager>(*this)),
+      schemas(make_unique<CatalogSet>(*this, make_unique<DefaultSchemaGenerator>(*this))) {
+}
+
+DuckCatalog::~DuckCatalog() {
+}
+
+void DuckCatalog::Initialize(bool load_builtin) {
+	// first initialize the base system catalogs
+	// these are never written to the WAL
+	// we start these at 1 because deleted entries default to 0
+	CatalogTransaction data(GetDatabase(), 1, 1);
+
+	// create the default schema
+	CreateSchemaInfo info;
+	info.schema = DEFAULT_SCHEMA;
+	info.internal = true;
+	CreateSchema(data, &info);
+
+	if (load_builtin) {
+		// initialize default functions
+		BuiltinFunctions builtin(data, *this);
+		builtin.Initialize();
+	}
+
+	Verify();
+}
+
+bool DuckCatalog::IsDuckCatalog() {
+	return true;
+}
+
+//===--------------------------------------------------------------------===//
+// Schema
+//===--------------------------------------------------------------------===//
+CatalogEntry *DuckCatalog::CreateSchema(CatalogTransaction transaction, CreateSchemaInfo *info) {
+	D_ASSERT(!info->schema.empty());
+	DependencyList dependencies;
+	auto entry = make_unique<DuckSchemaEntry>(this, info->schema, info->internal);
+	auto result = entry.get();
+	if (!schemas->CreateEntry(transaction, info->schema, std::move(entry), dependencies)) {
+		if (info->on_conflict == OnCreateConflict::ERROR_ON_CONFLICT) {
+			throw CatalogException("Schema with name %s already exists!", info->schema);
+		} else {
+			D_ASSERT(info->on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT);
+		}
+		return nullptr;
+	}
+	return result;
+}
+
+void DuckCatalog::DropSchema(ClientContext &context, DropInfo *info) {
+	D_ASSERT(!info->name.empty());
+	ModifyCatalog();
+	if (!schemas->DropEntry(GetCatalogTransaction(context), info->name, info->cascade)) {
+		if (!info->if_exists) {
+			throw CatalogException("Schema with name \"%s\" does not exist!", info->name);
+		}
+	}
+}
+
+void DuckCatalog::ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback) {
+	schemas->Scan(GetCatalogTransaction(context), [&](CatalogEntry *entry) { callback(entry); });
+}
+
+void DuckCatalog::ScanSchemas(std::function<void(CatalogEntry *)> callback) {
+	schemas->Scan([&](CatalogEntry *entry) { callback(entry); });
+}
+
+SchemaCatalogEntry *DuckCatalog::GetSchema(CatalogTransaction transaction, const string &schema_name, bool if_exists,
+                                           QueryErrorContext error_context) {
+	D_ASSERT(!schema_name.empty());
+	auto entry = schemas->GetEntry(transaction, schema_name);
+	if (!entry && !if_exists) {
+		throw CatalogException(error_context.FormatError("Schema with name %s does not exist!", schema_name));
+	}
+	return (SchemaCatalogEntry *)entry;
+}
+
+DatabaseSize DuckCatalog::GetDatabaseSize(ClientContext &context) {
+	return db.GetStorageManager().GetDatabaseSize();
+}
+
+bool DuckCatalog::InMemory() {
+	return db.GetStorageManager().InMemory();
+}
+
+string DuckCatalog::GetDBPath() {
+	return db.GetStorageManager().GetDBPath();
+}
+
+void DuckCatalog::Verify() {
+#ifdef DEBUG
+	schemas->Verify(*this);
+#endif
+}
+
+} // namespace duckdb

package/src/duckdb/src/catalog/similar_catalog_entry.cpp

@@ -0,0 +1,26 @@
+#include "duckdb/catalog/similar_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
+
+namespace duckdb {
+
+string SimilarCatalogEntry::GetQualifiedName(bool qualify_catalog, bool qualify_schema) const {
+	D_ASSERT(Found());
+	string result;
+	if (qualify_catalog) {
+		result += schema->catalog->GetName();
+	}
+	if (qualify_schema) {
+		if (!result.empty()) {
+			result += ".";
+		}
+		result += schema->name;
+	}
+	if (!result.empty()) {
+		result += ".";
+	}
+	result += name;
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/allocator.cpp

@@ -102,7 +102,7 @@ Allocator::Allocator()
 Allocator::Allocator(allocate_function_ptr_t allocate_function_p, free_function_ptr_t free_function_p,
                      reallocate_function_ptr_t reallocate_function_p, unique_ptr<PrivateAllocatorData> private_data_p)
     : allocate_function(allocate_function_p), free_function(free_function_p),
-      reallocate_function(reallocate_function_p), private_data(move(private_data_p)) {
+      reallocate_function(reallocate_function_p), private_data(std::move(private_data_p)) {
 	D_ASSERT(allocate_function);
 	D_ASSERT(free_function);
 	D_ASSERT(reallocate_function);

package/src/duckdb/src/common/arrow/arrow_appender.cpp

@@ -43,10 +43,10 @@ struct ArrowAppendData {
 static unique_ptr<ArrowAppendData> InitializeArrowChild(const LogicalType &type, idx_t capacity);
 static ArrowArray *FinalizeArrowChild(const LogicalType &type, ArrowAppendData &append_data);
 
-ArrowAppender::ArrowAppender(vector<LogicalType> types_p, idx_t initial_capacity) : types(move(types_p)) {
+ArrowAppender::ArrowAppender(vector<LogicalType> types_p, idx_t initial_capacity) : types(std::move(types_p)) {
 	for (auto &type : types) {
 		auto entry = InitializeArrowChild(type, initial_capacity);
-		root_data.push_back(move(entry));
+		root_data.push_back(std::move(entry));
 	}
 }
 
@@ -190,7 +190,7 @@ struct ArrowEnumData : public ArrowScalarBaseData<TGT> {
 		// construct the enum child data
 		auto enum_data = InitializeArrowChild(LogicalType::VARCHAR, EnumType::GetSize(type));
 		enum_data->append_vector(*enum_data, EnumType::GetValuesInsertOrder(type), EnumType::GetSize(type));
-		result.child_data.push_back(move(enum_data));
+		result.child_data.push_back(std::move(enum_data));
 	}
 
 	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
@@ -339,7 +339,7 @@ struct ArrowStructData {
 		auto &children = StructType::GetChildTypes(type);
 		for (auto &child : children) {
 			auto child_buffer = InitializeArrowChild(child.second, capacity);
-			result.child_data.push_back(move(child_buffer));
+			result.child_data.push_back(std::move(child_buffer));
 		}
 	}
 
@@ -412,7 +412,7 @@ struct ArrowListData {
 		auto &child_type = ListType::GetChildType(type);
 		result.main_buffer.reserve((capacity + 1) * sizeof(uint32_t));
 		auto child_buffer = InitializeArrowChild(child_type, capacity);
-		result.child_data.push_back(move(child_buffer));
+		result.child_data.push_back(std::move(child_buffer));
 	}
 
 	static void Append(ArrowAppendData &append_data, Vector &input, idx_t size) {
@@ -461,7 +461,7 @@ struct ArrowMapData {
 		internal_struct->child_data.push_back(InitializeArrowChild(key_type, capacity));
 		internal_struct->child_data.push_back(InitializeArrowChild(value_type, capacity));
 
-		result.child_data.push_back(move(internal_struct));
+		result.child_data.push_back(std::move(internal_struct));
 	}
 
 	static void Append(ArrowAppendData &append_data, Vector &input, idx_t size) {
@@ -607,7 +607,7 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 		break;
 	case LogicalTypeId::VARCHAR:
 	case LogicalTypeId::BLOB:
-	case LogicalTypeId::JSON:
+	case LogicalTypeId::BIT:
 		InitializeFunctionPointers<ArrowVarcharData<string_t>>(append_data);
 		break;
 	case LogicalTypeId::UUID:
@@ -685,7 +685,7 @@ ArrowArray *FinalizeArrowChild(const LogicalType &type, ArrowAppendData &append_
 		append_data.finalize(append_data, type, result.get());
 	}
 
-	append_data.array = move(result);
+	append_data.array = std::move(result);
 	return append_data.array.get();
 }
 
@@ -707,7 +707,7 @@ ArrowArray ArrowAppender::Finalize() {
 	result.offset = 0;
 	result.null_count = 0; // needs to be 0
 	result.dictionary = nullptr;
-	root_holder->child_data = move(root_data);
+	root_holder->child_data = std::move(root_data);
 
 	for (idx_t i = 0; i < root_holder->child_data.size(); i++) {
 		root_holder->child_pointers[i] = FinalizeArrowChild(types[i], *root_holder->child_data[i]);

package/src/duckdb/src/common/arrow/arrow_converter.cpp

@@ -1,5 +1,5 @@
 #include "duckdb/common/types/data_chunk.hpp"
-
+#include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/arrow/arrow.hpp"
 #include "duckdb/common/arrow/arrow_converter.hpp"
 #include "duckdb/common/exception.hpp"
@@ -116,7 +116,6 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		child.format = "g";
 		break;
 	case LogicalTypeId::UUID:
-	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR:
 		child.format = "u";
 		break;
@@ -137,7 +136,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 			format_ptr[i] = format[i];
 		}
 		format_ptr[format.size()] = '\0';
-		root_holder.owned_type_names.push_back(move(format_ptr));
+		root_holder.owned_type_names.push_back(std::move(format_ptr));
 		child.format = root_holder.owned_type_names.back().get();
 		break;
 	}
@@ -162,7 +161,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 			format_ptr[i] = format[i];
 		}
 		format_ptr[format.size()] = '\0';
-		root_holder.owned_type_names.push_back(move(format_ptr));
+		root_holder.owned_type_names.push_back(std::move(format_ptr));
 		child.format = root_holder.owned_type_names.back().get();
 		break;
 	}
@@ -170,7 +169,8 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		child.format = "n";
 		break;
 	}
-	case LogicalTypeId::BLOB: {
+	case LogicalTypeId::BLOB:
+	case LogicalTypeId::BIT: {
 		child.format = "z";
 		break;
 	}
@@ -209,7 +209,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 				name_ptr[i] = struct_col_name[i];
 			}
 			name_ptr[struct_col_name.size()] = '\0';
-			root_holder.owned_type_names.push_back(move(name_ptr));
+			root_holder.owned_type_names.push_back(std::move(name_ptr));
 
 			child.children[type_idx]->name = root_holder.owned_type_names.back().get();
 			SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, config_timezone);

package/src/duckdb/src/common/arrow/arrow_wrapper.cpp

@@ -158,7 +158,7 @@ const char *ResultArrowArrayStreamWrapper::MyStreamGetLastError(struct ArrowArra
 }
 
 ResultArrowArrayStreamWrapper::ResultArrowArrayStreamWrapper(unique_ptr<QueryResult> result_p, idx_t batch_size_p)
-    : result(move(result_p)) {
+    : result(std::move(result_p)) {
 	//! We first initialize the private data of the stream
 	stream.private_data = this;
 	//! Ceil Approx_Batch_Size/STANDARD_VECTOR_SIZE

package/src/duckdb/src/common/bind_helpers.cpp

@@ -0,0 +1,67 @@
+#include "duckdb/common/bind_helpers.hpp"
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/types.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/value.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
+
+namespace duckdb {
+
+Value ConvertVectorToValue(vector<Value> set) {
+	if (set.empty()) {
+		return Value::EMPTYLIST(LogicalType::BOOLEAN);
+	}
+	return Value::LIST(std::move(set));
+}
+
+vector<bool> ParseColumnList(const vector<Value> &set, vector<string> &names, const string &loption) {
+	vector<bool> result;
+
+	if (set.empty()) {
+		throw BinderException("\"%s\" expects a column list or * as parameter", loption);
+	}
+	// list of options: parse the list
+	case_insensitive_map_t<bool> option_map;
+	for (idx_t i = 0; i < set.size(); i++) {
+		option_map[set[i].ToString()] = false;
+	}
+	result.resize(names.size(), false);
+	for (idx_t i = 0; i < names.size(); i++) {
+		auto entry = option_map.find(names[i]);
+		if (entry != option_map.end()) {
+			result[i] = true;
+			entry->second = true;
+		}
+	}
+	for (auto &entry : option_map) {
+		if (!entry.second) {
+			throw BinderException("\"%s\" expected to find %s, but it was not found in the table", loption,
+			                      entry.first.c_str());
+		}
+	}
+	return result;
+}
+
+vector<bool> ParseColumnList(const Value &value, vector<string> &names, const string &loption) {
+	vector<bool> result;
+
+	// Only accept a list of arguments
+	if (value.type().id() != LogicalTypeId::LIST) {
+		// Support a single argument if it's '*'
+		if (value.type().id() == LogicalTypeId::VARCHAR && value.GetValue<string>() == "*") {
+			result.resize(names.size(), true);
+			return result;
+		}
+		throw BinderException("\"%s\" expects a column list or * as parameter", loption);
+	}
+	auto &children = ListValue::GetChildren(value);
+	// accept '*' as single argument
+	if (children.size() == 1 && children[0].type().id() == LogicalTypeId::VARCHAR &&
+	    children[0].GetValue<string>() == "*") {
+		result.resize(names.size(), true);
+		return result;
+	}
+	return ParseColumnList(children, names, loption);
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/box_renderer.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 
 const idx_t BoxRenderer::SPLIT_COLUMN = idx_t(-1);
 
-BoxRenderer::BoxRenderer(BoxRendererConfig config_p) : config(move(config_p)) {
+BoxRenderer::BoxRenderer(BoxRendererConfig config_p) : config(std::move(config_p)) {
 }
 
 string BoxRenderer::ToString(ClientContext &context, const vector<string> &names, const ColumnDataCollection &result) {
@@ -590,10 +590,18 @@ void BoxRenderer::Render(ClientContext &context, const vector<string> &names, co
 		bottom_rows = rows_to_render - top_rows;
 	}
 	auto row_count_str = to_string(row_count) + " rows";
+	bool has_limited_rows = config.limit > 0 && row_count == config.limit;
+	if (has_limited_rows) {
+		row_count_str = "? rows";
+	}
 	string shown_str;
 	bool has_hidden_rows = top_rows < row_count;
 	if (has_hidden_rows) {
-		shown_str = "(" + to_string(top_rows + bottom_rows) + " shown)";
+		shown_str = "(";
+		if (has_limited_rows) {
+			shown_str += ">" + to_string(config.limit - 1) + " rows, ";
+		}
+		shown_str += to_string(top_rows + bottom_rows) + " shown)";
 	}
 	auto minimum_row_length = MaxValue<idx_t>(row_count_str.size(), shown_str.size()) + 4;
 
@@ -645,7 +653,7 @@ void BoxRenderer::Render(ClientContext &context, const vector<string> &names, co
 		column_count--;
 		column_count_str += " (" + to_string(column_count) + " shown)";
 	}
-	RenderRowCount(move(row_count_str), move(shown_str), column_count_str, boundaries, has_hidden_rows,
+	RenderRowCount(std::move(row_count_str), std::move(shown_str), column_count_str, boundaries, has_hidden_rows,
 	               has_hidden_columns, total_length, row_count, column_count, minimum_row_length, ss);
 }
 

package/src/duckdb/src/common/compressed_file_system.cpp

@@ -6,11 +6,11 @@ StreamWrapper::~StreamWrapper() {
 }
 
 CompressedFile::CompressedFile(CompressedFileSystem &fs, unique_ptr<FileHandle> child_handle_p, const string &path)
-    : FileHandle(fs, path), compressed_fs(fs), child_handle(move(child_handle_p)) {
+    : FileHandle(fs, path), compressed_fs(fs), child_handle(std::move(child_handle_p)) {
 }
 
 CompressedFile::~CompressedFile() {
-	Close();
+	CompressedFile::Close();
 }
 
 void CompressedFile::Initialize(bool write) {

package/src/duckdb/src/common/enums/expression_type.cpp

@@ -133,6 +133,8 @@ string ExpressionTypeToString(ExpressionType type) {
 		return "COLLATE";
 	case ExpressionType::POSITIONAL_REFERENCE:
 		return "POSITIONAL_REFERENCE";
+	case ExpressionType::BOUND_LAMBDA_REF:
+		return "BOUND_LAMBDA_REF";
 	case ExpressionType::LAMBDA:
 		return "LAMBDA";
 	case ExpressionType::ARROW:

package/src/duckdb/src/common/enums/logical_operator_type.cpp

@@ -50,6 +50,8 @@ string LogicalOperatorToString(LogicalOperatorType type) {
 		return "JOIN";
 	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
 		return "CROSS_PRODUCT";
+	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
+		return "POSITIONAL_JOIN";
 	case LogicalOperatorType::LOGICAL_UNION:
 		return "UNION";
 	case LogicalOperatorType::LOGICAL_EXCEPT:

package/src/duckdb/src/common/enums/optimizer_type.cpp

@@ -18,6 +18,7 @@ static DefaultOptimizerType internal_optimizer_types[] = {
     {"in_clause", OptimizerType::IN_CLAUSE},
     {"join_order", OptimizerType::JOIN_ORDER},
     {"deliminator", OptimizerType::DELIMINATOR},
+    {"unnest_rewriter", OptimizerType::UNNEST_REWRITER},
     {"unused_columns", OptimizerType::UNUSED_COLUMNS},
     {"statistics_propagation", OptimizerType::STATISTICS_PROPAGATION},
     {"common_subexpressions", OptimizerType::COMMON_SUBEXPRESSIONS},

package/src/duckdb/src/common/enums/physical_operator_type.cpp

@@ -63,6 +63,10 @@ string PhysicalOperatorToString(PhysicalOperatorType type) {
 		return "IE_JOIN";
 	case PhysicalOperatorType::CROSS_PRODUCT:
 		return "CROSS_PRODUCT";
+	case PhysicalOperatorType::POSITIONAL_JOIN:
+		return "POSITIONAL_JOIN";
+	case PhysicalOperatorType::POSITIONAL_SCAN:
+		return "POSITIONAL_SCAN";
 	case PhysicalOperatorType::UNION:
 		return "UNION";
 	case PhysicalOperatorType::INSERT:
@@ -131,6 +135,8 @@ string PhysicalOperatorToString(PhysicalOperatorType type) {
 		return "ATTACH";
 	case PhysicalOperatorType::RESULT_COLLECTOR:
 		return "RESULT_COLLECTOR";
+	case PhysicalOperatorType::EXTENSION:
+		return "EXTENSION";
 	case PhysicalOperatorType::INVALID:
 		break;
 	}

package/src/duckdb/src/common/enums/relation_type.cpp

@@ -43,6 +43,8 @@ string RelationTypeToString(RelationType type) {
 		return "UPDATE_RELATION";
 	case RelationType::WRITE_CSV_RELATION:
 		return "WRITE_CSV_RELATION";
+	case RelationType::WRITE_PARQUET_RELATION:
+		return "WRITE_PARQUET_RELATION";
 	case RelationType::READ_CSV_RELATION:
 		return "READ_CSV_RELATION";
 	case RelationType::SUBQUERY_RELATION:

package/src/duckdb/src/common/exception_format_value.cpp

@@ -16,7 +16,7 @@ ExceptionFormatValue::ExceptionFormatValue(hugeint_t huge_val)
     : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(Hugeint::ToString(huge_val)) {
 }
 ExceptionFormatValue::ExceptionFormatValue(string str_val)
-    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(move(str_val)) {
+    : type(ExceptionFormatValueType::FORMAT_VALUE_TYPE_STRING), str_val(std::move(str_val)) {
 }
 
 template <>
@@ -38,7 +38,7 @@ ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(double value) {
 }
 template <>
 ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(string value) {
-	return ExceptionFormatValue(move(value));
+	return ExceptionFormatValue(std::move(value));
 }
 template <>
 ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(const char *value) {