Merge pull request #152 from Mytherin/bumpsqlite

Mytherin · web-flow · commit ed38d770e0bb · 2025-05-13T23:39:54.000+02:00
Apply patches and bump to latest DuckDB version
diff --git a/.github/workflows/MainDistributionPipeline.yml b/.github/workflows/MainDistributionPipeline.yml
@@ -16,7 +16,7 @@ jobs:
     name: Build extension binaries
     uses: duckdb/extension-ci-tools/.github/workflows/_extension_distribution.yml@v1.2.2
     with:
-      duckdb_version: v1.2.2
+      duckdb_version: main
       extension_name: sqlite_scanner
       ci_tools_version: v1.2.2
 
@@ -26,7 +26,7 @@ jobs:
     uses: duckdb/extension-ci-tools/.github/workflows/_extension_deploy.yml@v1.2.2
     secrets: inherit
     with:
-      duckdb_version: v1.2.2
+      duckdb_version: main
       extension_name: sqlite_scanner
       ci_tools_version: v1.2.2
       deploy_latest: ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' }}
diff --git a/duckdb b/duckdb
@@ -1 +1 @@
-Subproject commit 7c039464e452ddc3330e2691d3fa6d305521d09b
+Subproject commit 93fda3591f4298414fa362c59219c09e03f718ab
diff --git a/extension-ci-tools b/extension-ci-tools
@@ -1 +1 @@
-Subproject commit 5ae521a4c9709bb3cb35dc6d79e044f67bc58bf0
+Subproject commit 4317e39099f4b71d614f00d044aaec651bec6fc9
diff --git a/src/include/sqlite_db.hpp b/src/include/sqlite_db.hpp
@@ -50,7 +50,7 @@ class SQLiteDB {
 	vector<IndexInfo> GetIndexInfo(const string &table_name);
 
 	static void DebugSetPrintQueries(bool print);
-	
+
 	bool IsOpen();
 	void Close();
 };
diff --git a/src/include/storage/sqlite_catalog.hpp b/src/include/storage/sqlite_catalog.hpp
@@ -33,22 +33,22 @@ class SQLiteCatalog : public Catalog {
 
 	void ScanSchemas(ClientContext &context, std::function<void(SchemaCatalogEntry &)> callback) override;
 
-	optional_ptr<SchemaCatalogEntry> GetSchema(CatalogTransaction transaction, const string &schema_name,
-	                                           OnEntryNotFound if_not_found,
-	                                           QueryErrorContext error_context = QueryErrorContext()) override;
+	optional_ptr<SchemaCatalogEntry> LookupSchema(CatalogTransaction transaction, const EntryLookupInfo &schema_lookup,
+	                                              OnEntryNotFound if_not_found) override;
 
 	SQLiteSchemaEntry &GetMainSchema() {
 		return *main_schema;
 	}
 
-	unique_ptr<PhysicalOperator> PlanInsert(ClientContext &context, LogicalInsert &op,
-	                                        unique_ptr<PhysicalOperator> plan) override;
-	unique_ptr<PhysicalOperator> PlanCreateTableAs(ClientContext &context, LogicalCreateTable &op,
-	                                               unique_ptr<PhysicalOperator> plan) override;
-	unique_ptr<PhysicalOperator> PlanDelete(ClientContext &context, LogicalDelete &op,
-	                                        unique_ptr<PhysicalOperator> plan) override;
-	unique_ptr<PhysicalOperator> PlanUpdate(ClientContext &context, LogicalUpdate &op,
-	                                        unique_ptr<PhysicalOperator> plan) override;
+	PhysicalOperator &PlanCreateTableAs(ClientContext &context, PhysicalPlanGenerator &planner, LogicalCreateTable &op,
+	                                    PhysicalOperator &plan) override;
+	PhysicalOperator &PlanInsert(ClientContext &context, PhysicalPlanGenerator &planner, LogicalInsert &op,
+	                             optional_ptr<PhysicalOperator> plan) override;
+	PhysicalOperator &PlanDelete(ClientContext &context, PhysicalPlanGenerator &planner, LogicalDelete &op,
+	                             PhysicalOperator &plan) override;
+	PhysicalOperator &PlanUpdate(ClientContext &context, PhysicalPlanGenerator &planner, LogicalUpdate &op,
+	                             PhysicalOperator &plan) override;
+
 	unique_ptr<LogicalOperator> BindCreateIndex(Binder &binder, CreateStatement &stmt, TableCatalogEntry &table,
 	                                            unique_ptr<LogicalOperator> plan) override;
 
diff --git a/src/include/storage/sqlite_schema_entry.hpp b/src/include/storage/sqlite_schema_entry.hpp
@@ -36,7 +36,7 @@ class SQLiteSchemaEntry : public SchemaCatalogEntry {
 	void Scan(ClientContext &context, CatalogType type, const std::function<void(CatalogEntry &)> &callback) override;
 	void Scan(CatalogType type, const std::function<void(CatalogEntry &)> &callback) override;
 	void DropEntry(ClientContext &context, DropInfo &info) override;
-	optional_ptr<CatalogEntry> GetEntry(CatalogTransaction transaction, CatalogType type, const string &name) override;
+	optional_ptr<CatalogEntry> LookupEntry(CatalogTransaction transaction, const EntryLookupInfo &lookup_info) override;
 
 private:
 	void AlterTable(SQLiteTransaction &transaction, RenameTableInfo &info);
diff --git a/src/sqlite_db.cpp b/src/sqlite_db.cpp
@@ -114,7 +114,8 @@ void SQLiteDB::Close() {
 
 vector<string> SQLiteDB::GetEntries(string entry_type) {
 	vector<string> result;
-	SQLiteStatement stmt = Prepare("SELECT name FROM sqlite_master WHERE length(sql) > 0 AND type='" + entry_type + "'");
+	SQLiteStatement stmt =
+	    Prepare("SELECT name FROM sqlite_master WHERE length(sql) > 0 AND type='" + entry_type + "'");
 	while (stmt.Step()) {
 		auto table_name = stmt.GetValue<string>(0);
 		result.push_back(std::move(table_name));
diff --git a/src/sqlite_scanner.cpp b/src/sqlite_scanner.cpp
@@ -102,13 +102,14 @@ static void SqliteInitInternal(ClientContext &context, const SqliteBindData &bin
 	string sql;
 	if (bind_data.sql.empty()) {
 		auto col_names = StringUtil::Join(
-			local_state.column_ids.data(), local_state.column_ids.size(), ", ", [&](const idx_t column_id) {
-				return column_id == (column_t)-1 ? "ROWID"
-												 : '"' + SQLiteUtils::SanitizeIdentifier(bind_data.names[column_id]) + '"';
-			});
-
-		sql =
-		    StringUtil::Format("SELECT %s FROM \"%s\"", col_names, SQLiteUtils::SanitizeIdentifier(bind_data.table_name));
+		    local_state.column_ids.data(), local_state.column_ids.size(), ", ", [&](const idx_t column_id) {
+			    return column_id == (column_t)-1
+			               ? "ROWID"
+			               : '"' + SQLiteUtils::SanitizeIdentifier(bind_data.names[column_id]) + '"';
+		    });
+
+		sql = StringUtil::Format("SELECT %s FROM \"%s\"", col_names,
+		                         SQLiteUtils::SanitizeIdentifier(bind_data.table_name));
 		if (bind_data.rows_per_group.IsValid()) {
 			// we are scanning a subset of the rows - generate a WHERE clause based on
 			// the rowid
diff --git a/src/storage/sqlite_catalog.cpp b/src/storage/sqlite_catalog.cpp
@@ -31,9 +31,10 @@ void SQLiteCatalog::ScanSchemas(ClientContext &context, std::function<void(Schem
 	callback(*main_schema);
 }
 
-optional_ptr<SchemaCatalogEntry> SQLiteCatalog::GetSchema(CatalogTransaction transaction, const string &schema_name,
-                                                          OnEntryNotFound if_not_found,
-                                                          QueryErrorContext error_context) {
+optional_ptr<SchemaCatalogEntry> SQLiteCatalog::LookupSchema(CatalogTransaction transaction,
+                                                             const EntryLookupInfo &schema_lookup,
+                                                             OnEntryNotFound if_not_found) {
+	auto &schema_name = schema_lookup.GetEntryName();
 	if (schema_name == DEFAULT_SCHEMA || schema_name == INVALID_SCHEMA) {
 		return main_schema.get();
 	}
diff --git a/src/storage/sqlite_delete.cpp b/src/storage/sqlite_delete.cpp
@@ -87,15 +87,15 @@ InsertionOrderPreservingMap<string> SQLiteDelete::ParamsToString() const {
 //===--------------------------------------------------------------------===//
 // Plan
 //===--------------------------------------------------------------------===//
-unique_ptr<PhysicalOperator> SQLiteCatalog::PlanDelete(ClientContext &context, LogicalDelete &op,
-                                                       unique_ptr<PhysicalOperator> plan) {
+PhysicalOperator &SQLiteCatalog::PlanDelete(ClientContext &context, PhysicalPlanGenerator &planner, LogicalDelete &op,
+                                            PhysicalOperator &plan) {
 	if (op.return_chunk) {
 		throw BinderException("RETURNING clause not yet supported for deletion of a SQLite table");
 	}
 	auto &bound_ref = op.expressions[0]->Cast<BoundReferenceExpression>();
-	auto insert = make_uniq<SQLiteDelete>(op, op.table, bound_ref.index);
-	insert->children.push_back(std::move(plan));
-	return std::move(insert);
+	auto &delete_op = planner.Make<SQLiteDelete>(op, op.table, bound_ref.index);
+	delete_op.children.push_back(plan);
+	return delete_op;
 }
 
 } // namespace duckdb
diff --git a/src/storage/sqlite_index.cpp b/src/storage/sqlite_index.cpp
@@ -35,8 +35,8 @@ class LogicalSQLiteCreateIndex : public LogicalExtensionOperator {
 	unique_ptr<CreateIndexInfo> info;
 	TableCatalogEntry &table;
 
-	unique_ptr<PhysicalOperator> CreatePlan(ClientContext &context, PhysicalPlanGenerator &generator) override {
-		return make_uniq<SQLiteCreateIndex>(std::move(info), table);
+	PhysicalOperator &CreatePlan(ClientContext &context, PhysicalPlanGenerator &planner) override {
+		return planner.Make<SQLiteCreateIndex>(std::move(info), table);
 	}
 
 	void Serialize(Serializer &writer) const override {
diff --git a/src/storage/sqlite_insert.cpp b/src/storage/sqlite_insert.cpp
@@ -141,66 +141,66 @@ InsertionOrderPreservingMap<string> SQLiteInsert::ParamsToString() const {
 //===--------------------------------------------------------------------===//
 // Plan
 //===--------------------------------------------------------------------===//
-unique_ptr<PhysicalOperator> AddCastToSQLiteTypes(ClientContext &context, unique_ptr<PhysicalOperator> plan) {
+PhysicalOperator &AddCastToSQLiteTypes(ClientContext &context, PhysicalPlanGenerator &planner, PhysicalOperator &plan) {
 	// check if we need to cast anything
 	bool require_cast = false;
-	auto &child_types = plan->GetTypes();
+	auto &child_types = plan.GetTypes();
 	for (auto &type : child_types) {
 		auto sqlite_type = SQLiteUtils::ToSQLiteType(type);
 		if (sqlite_type != type) {
 			require_cast = true;
 			break;
 		}
 	}
-	if (require_cast) {
-		vector<LogicalType> sqlite_types;
-		vector<unique_ptr<Expression>> select_list;
-		for (idx_t i = 0; i < child_types.size(); i++) {
-			auto &type = child_types[i];
-			unique_ptr<Expression> expr;
-			expr = make_uniq<BoundReferenceExpression>(type, i);
-
-			auto sqlite_type = SQLiteUtils::ToSQLiteType(type);
-			if (sqlite_type != type) {
-				// add a cast
-				expr = BoundCastExpression::AddCastToType(context, std::move(expr), sqlite_type);
-			}
-			sqlite_types.push_back(std::move(sqlite_type));
-			select_list.push_back(std::move(expr));
-		}
-		// we need to cast: add casts
-		auto proj =
-		    make_uniq<PhysicalProjection>(std::move(sqlite_types), std::move(select_list), plan->estimated_cardinality);
-		proj->children.push_back(std::move(plan));
-		plan = std::move(proj);
+
+	if (!require_cast) {
+		return plan;
 	}
 
-	return plan;
+	vector<LogicalType> sqlite_types;
+	vector<unique_ptr<Expression>> select_list;
+	for (idx_t i = 0; i < child_types.size(); i++) {
+		auto &type = child_types[i];
+		unique_ptr<Expression> expr;
+		expr = make_uniq<BoundReferenceExpression>(type, i);
+
+		auto sqlite_type = SQLiteUtils::ToSQLiteType(type);
+		if (sqlite_type != type) {
+			// add a cast
+			expr = BoundCastExpression::AddCastToType(context, std::move(expr), sqlite_type);
+		}
+		sqlite_types.push_back(std::move(sqlite_type));
+		select_list.push_back(std::move(expr));
+	}
+	// we need to cast: add casts
+	auto &proj =
+	    planner.Make<PhysicalProjection>(std::move(sqlite_types), std::move(select_list), plan.estimated_cardinality);
+	proj.children.push_back(plan);
+	return proj;
 }
 
-unique_ptr<PhysicalOperator> SQLiteCatalog::PlanInsert(ClientContext &context, LogicalInsert &op,
-                                                       unique_ptr<PhysicalOperator> plan) {
+PhysicalOperator &SQLiteCatalog::PlanInsert(ClientContext &context, PhysicalPlanGenerator &planner, LogicalInsert &op,
+                                            optional_ptr<PhysicalOperator> plan) {
 	if (op.return_chunk) {
 		throw BinderException("RETURNING clause not yet supported for insertion into SQLite table");
 	}
 	if (op.action_type != OnConflictAction::THROW) {
 		throw BinderException("ON CONFLICT clause not yet supported for insertion into SQLite table");
 	}
 
-	plan = AddCastToSQLiteTypes(context, std::move(plan));
-
-	auto insert = make_uniq<SQLiteInsert>(op, op.table, op.column_index_map);
-	insert->children.push_back(std::move(plan));
-	return std::move(insert);
+	D_ASSERT(plan);
+	auto &inner_plan = AddCastToSQLiteTypes(context, planner, *plan);
+	auto &insert = planner.Make<SQLiteInsert>(op, op.table, op.column_index_map);
+	insert.children.push_back(*plan);
+	return insert;
 }
 
-unique_ptr<PhysicalOperator> SQLiteCatalog::PlanCreateTableAs(ClientContext &context, LogicalCreateTable &op,
-                                                              unique_ptr<PhysicalOperator> plan) {
-	plan = AddCastToSQLiteTypes(context, std::move(plan));
-
-	auto insert = make_uniq<SQLiteInsert>(op, op.schema, std::move(op.info));
-	insert->children.push_back(std::move(plan));
-	return std::move(insert);
+PhysicalOperator &SQLiteCatalog::PlanCreateTableAs(ClientContext &context, PhysicalPlanGenerator &planner,
+                                                   LogicalCreateTable &op, PhysicalOperator &plan) {
+	auto &inner_plan = AddCastToSQLiteTypes(context, planner, plan);
+	auto &insert = planner.Make<SQLiteInsert>(op, op.schema, std::move(op.info));
+	insert.children.push_back(inner_plan);
+	return insert;
 }
 
 } // namespace duckdb
diff --git a/src/storage/sqlite_query.cpp b/src/storage/sqlite_query.cpp
@@ -14,7 +14,7 @@
 namespace duckdb {
 
 static unique_ptr<FunctionData> SQLiteQueryBind(ClientContext &context, TableFunctionBindInput &input,
-                                            vector<LogicalType> &return_types, vector<string> &names) {
+                                                vector<LogicalType> &return_types, vector<string> &names) {
 	auto result = make_uniq<SqliteBindData>();
 
 	if (input.inputs[0].IsNull() || input.inputs[1].IsNull()) {
@@ -47,7 +47,7 @@ static unique_ptr<FunctionData> SQLiteQueryBind(ClientContext &context, TableFun
 	if (!stmt.stmt) {
 		throw BinderException("Failed to prepare query \"%s\"", sql);
 	}
-	for(idx_t c = 0; c < stmt.GetColumnCount(); c++) {
+	for (idx_t c = 0; c < stmt.GetColumnCount(); c++) {
 		return_types.emplace_back(LogicalType::VARCHAR);
 		names.emplace_back(stmt.GetName(c));
 	}
diff --git a/src/storage/sqlite_schema_entry.cpp b/src/storage/sqlite_schema_entry.cpp
@@ -296,14 +296,14 @@ void SQLiteSchemaEntry::DropEntry(ClientContext &context, DropInfo &info) {
 	transaction.DropEntry(info.type, info.name, info.cascade);
 }
 
-optional_ptr<CatalogEntry> SQLiteSchemaEntry::GetEntry(CatalogTransaction transaction, CatalogType type,
-                                                       const string &name) {
+optional_ptr<CatalogEntry> SQLiteSchemaEntry::LookupEntry(CatalogTransaction transaction,
+                                                          const EntryLookupInfo &lookup_info) {
 	auto &sqlite_transaction = GetSQLiteTransaction(transaction);
-	switch (type) {
+	switch (lookup_info.GetCatalogType()) {
 	case CatalogType::INDEX_ENTRY:
 	case CatalogType::TABLE_ENTRY:
 	case CatalogType::VIEW_ENTRY:
-		return sqlite_transaction.GetCatalogEntry(name);
+		return sqlite_transaction.GetCatalogEntry(lookup_info.GetEntryName());
 	default:
 		return nullptr;
 	}
diff --git a/src/storage/sqlite_transaction.cpp b/src/storage/sqlite_transaction.cpp
@@ -60,7 +60,8 @@ string ExtractSelectStatement(const string &create_view) {
 	auto &create_statement = parser.statements[0]->Cast<CreateStatement>();
 	if (create_statement.info->type != CatalogType::VIEW_ENTRY) {
 		throw BinderException(
-		    "Failed to create view from SQL string - \"%s\" - view did not contain a CREATE VIEW statement", create_view);
+		    "Failed to create view from SQL string - \"%s\" - view did not contain a CREATE VIEW statement",
+		    create_view);
 	}
 	auto &view_info = create_statement.info->Cast<CreateViewInfo>();
 	return view_info.query->ToString();
@@ -77,9 +78,8 @@ void ExtractColumnIds(const ParsedExpression &expr, TableCatalogEntry &table, Cr
 		}
 		return;
 	}
-	ParsedExpressionIterator::EnumerateChildren(expr, [&](const ParsedExpression &child) {
-		ExtractColumnIds(child, table, info);
-	});
+	ParsedExpressionIterator::EnumerateChildren(
+	    expr, [&](const ParsedExpression &child) { ExtractColumnIds(child, table, info); });
 }
 
 unique_ptr<CreateIndexInfo> FromCreateIndex(ClientContext &context, TableCatalogEntry &table, string sql) {
@@ -88,18 +88,18 @@ unique_ptr<CreateIndexInfo> FromCreateIndex(ClientContext &context, TableCatalog
 	parser.ParseQuery(sql);
 
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::CREATE_STATEMENT) {
-		throw BinderException(
-			"Failed to create index from SQL string - \"%s\" - statement did not contain a single CREATE INDEX statement",
-			sql);
+		throw BinderException("Failed to create index from SQL string - \"%s\" - statement did not contain a single "
+		                      "CREATE INDEX statement",
+		                      sql);
 	}
 	auto &create_statement = parser.statements[0]->Cast<CreateStatement>();
 	if (create_statement.info->type != CatalogType::INDEX_ENTRY) {
 		throw BinderException(
-			"Failed to create view from SQL string - \"%s\" - view did not contain a CREATE INDEX statement", sql);
+		    "Failed to create view from SQL string - \"%s\" - view did not contain a CREATE INDEX statement", sql);
 	}
 	auto info = unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(create_statement.info));
 	info->sql = std::move(sql);
-	for(auto &expr : info->expressions) {
+	for (auto &expr : info->expressions) {
 		ExtractColumnIds(*expr, table, *info);
 	}
 	return info;
@@ -138,11 +138,12 @@ optional_ptr<CatalogEntry> SQLiteTransaction::GetCatalogEntry(const string &entr
 		unique_ptr<CreateViewInfo> view_info;
 		try {
 			view_info = CreateViewInfo::FromCreateView(*context.lock(), sqlite_catalog.GetMainSchema(), sql);
-		} catch(std::exception &ex) {
+		} catch (std::exception &ex) {
 			auto view_sql = ExtractSelectStatement(sql);
 			auto catalog_name = StringUtil::Replace(sqlite_catalog.GetName(), "\"", "\"\"");
 			auto escaped_view_sql = StringUtil::Replace(view_sql, "'", "''");
-			auto view_def = StringUtil::Format("CREATE VIEW %s AS FROM sqlite_query(\"%s\", '%s')", entry_name, catalog_name, escaped_view_sql);
+			auto view_def = StringUtil::Format("CREATE VIEW %s AS FROM sqlite_query(\"%s\", '%s')", entry_name,
+			                                   catalog_name, escaped_view_sql);
 			view_info = CreateViewInfo::FromCreateView(*context.lock(), sqlite_catalog.GetMainSchema(), view_def);
 		}
 		view_info->internal = false;
@@ -160,8 +161,8 @@ optional_ptr<CatalogEntry> SQLiteTransaction::GetCatalogEntry(const string &entr
 		auto index_info = FromCreateIndex(*context.lock(), table, std::move(sql));
 		index_info->catalog = sqlite_catalog.GetName();
 
-		auto index_entry =
-		    make_uniq<SQLiteIndexEntry>(sqlite_catalog, sqlite_catalog.GetMainSchema(), *index_info, std::move(table_name));
+		auto index_entry = make_uniq<SQLiteIndexEntry>(sqlite_catalog, sqlite_catalog.GetMainSchema(), *index_info,
+		                                               std::move(table_name));
 		result = std::move(index_entry);
 		break;
 	}
diff --git a/src/storage/sqlite_update.cpp b/src/storage/sqlite_update.cpp
@@ -103,8 +103,8 @@ InsertionOrderPreservingMap<string> SQLiteUpdate::ParamsToString() const {
 //===--------------------------------------------------------------------===//
 // Plan
 //===--------------------------------------------------------------------===//
-unique_ptr<PhysicalOperator> SQLiteCatalog::PlanUpdate(ClientContext &context, LogicalUpdate &op,
-                                                       unique_ptr<PhysicalOperator> plan) {
+PhysicalOperator &SQLiteCatalog::PlanUpdate(ClientContext &context, PhysicalPlanGenerator &planner, LogicalUpdate &op,
+                                            PhysicalOperator &plan) {
 	if (op.return_chunk) {
 		throw BinderException("RETURNING clause not yet supported for updates of a SQLite table");
 	}
@@ -113,9 +113,9 @@ unique_ptr<PhysicalOperator> SQLiteCatalog::PlanUpdate(ClientContext &context, L
 			throw BinderException("SET DEFAULT is not yet supported for updates of a SQLite table");
 		}
 	}
-	auto insert = make_uniq<SQLiteUpdate>(op, op.table, std::move(op.columns));
-	insert->children.push_back(std::move(plan));
-	return std::move(insert);
+	auto &update = planner.Make<SQLiteUpdate>(op, op.table, std::move(op.columns));
+	update.children.push_back(plan);
+	return update;
 }
 
 } // namespace duckdb

Original file line number	Diff line number	Diff line change
`@@ -31,9 +31,10 @@ void SQLiteCatalog::ScanSchemas(ClientContext &context, std::function<void(Schem`
`31`	`31`	`callback(*main_schema);`
`32`	`32`	`}`
`33`	`33`
`34`		`-optional_ptr<SchemaCatalogEntry> SQLiteCatalog::GetSchema(CatalogTransaction transaction, const string &schema_name,`
`35`		`- OnEntryNotFound if_not_found,`
`36`		`- QueryErrorContext error_context) {`
	`34`	`+optional_ptr<SchemaCatalogEntry> SQLiteCatalog::LookupSchema(CatalogTransaction transaction,`
	`35`	`+ const EntryLookupInfo &schema_lookup,`
	`36`	`+ OnEntryNotFound if_not_found) {`
	`37`	`+ auto &schema_name = schema_lookup.GetEntryName();`
`37`	`38`	`if (schema_name == DEFAULT_SCHEMA \|\| schema_name == INVALID_SCHEMA) {`
`38`	`39`	`return main_schema.get();`
`39`	`40`	`}`