ATTACH feature

Author: qxip

README.md

@@ -83,6 +83,30 @@ GIGAPI SELECT * FROM my_measurement WHERE time > now() - interval '1 hour';
 
 Behind the scenes, the extension performs the same steps as the `gigapi()` table function, rewriting the query to read from specific data files before execution. If a query is not prefixed with `GIGAPI`, it will be handled by DuckDB's default planner.
 
+## ATTACH Support for GigAPI
+
+The extension supports DuckDB's `ATTACH` statement, allowing you to create a virtual schema that pipes all table references through the GigAPI metadata engine. This enables seamless integration with tools and workflows that expect standard DuckDB schemas and tables.
+
+### Usage
+
+```sql
+-- Attach a GigAPI database as schema 'bq'
+ATTACH 'mydb' AS bq (TYPE gigapi, READ_ONLY);
+
+-- List all tables in the attached GigAPI schema
+SHOW TABLES;
+
+-- Query a table from the attached schema
+SELECT * FROM bq.example;
+```
+
+**How it works:**
+- Any table reference in the attached schema (e.g., `bq.example`) is transparently routed through the `gigapi()` table function.
+- You do not need to manually create views or enumerate tables; the extension handles all resolution dynamically.
+- Metadata queries (e.g., `SHOW TABLES`, `DESCRIBE`, etc.) are also supported and routed through GigAPI.
+
+This makes it easy to use GigAPI-backed data as if it were a native DuckDB database.
+
 ## Developer Information
 
 ### Dry Run Function

src/gigapi_attach.cpp

@@ -0,0 +1,65 @@
+#include "include/gigapi_attach.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/main/extension_util.hpp"
+#include "duckdb/main/database.hpp"
+#include "duckdb/parser/parser.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/statement/select_statement.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/make_uniq.hpp"
+
+namespace duckdb {
+
+// Table entry that pipes through gigapi()
+class GigapiTableEntry : public TableCatalogEntry {
+public:
+    GigapiTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, const std::string &name)
+        : TableCatalogEntry(CatalogType::TABLE_ENTRY, schema, name) {}
+
+    unique_ptr<LogicalOperator> GetScanOperator(ClientContext &context) override {
+        // Build: SELECT * FROM gigapi('schema.table')
+        std::string qualified = schema.name + "." + name;
+        std::string query = "SELECT * FROM gigapi('" + qualified + "')";
+        Parser parser;
+        parser.ParseQuery(query);
+        if (parser.statements.empty() || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
+            throw BinderException("Failed to parse gigapi table scan query");
+        }
+        Binder binder(context);
+        auto bound = binder.Bind(*parser.statements[0]);
+        return std::move(bound.plan);
+    }
+};
+
+GigapiSchema::GigapiSchema(Catalog &catalog, const std::string &name)
+    : SchemaCatalogEntry(catalog, name) {}
+
+TableCatalogEntry *GigapiSchema::GetTable(ClientContext &context, const std::string &table_name) {
+    // Always return a GigapiTableEntry for any table name
+    return new GigapiTableEntry(*catalog, *this, table_name);
+}
+
+// Handler for ATTACH ... (TYPE gigapi, ...)
+static void GigapiAttachHandler(ClientContext &context, const std::string &schema_name) {
+    auto &catalog = Catalog::GetSystemCatalog(context);
+    CreateSchemaInfo info;
+    info.schema = schema_name;
+    info.if_not_exists = true;
+    catalog.CreateSchema(context, info);
+
+    // Replace the schema with our custom schema
+    auto &db = DatabaseInstance::Get(context);
+    auto &schemas = db.GetCatalogSet(CatalogType::SCHEMA_ENTRY);
+    schemas.DropEntry(context, schema_name, false);
+    auto gigapi_schema = make_uniq<GigapiSchema>(catalog, schema_name);
+    schemas.AddEntry(context, std::move(gigapi_schema));
+}
+
+void RegisterGigapiAttach(DatabaseInstance &instance) {
+    // Register the attach handler for TYPE gigapi
+    ExtensionUtil::RegisterAttachHandler(instance, "gigapi", GigapiAttachHandler);
+}
+
+} // namespace duckdb 

src/gigapi_extension.cpp

@@ -38,6 +38,7 @@
 #include "duckdb/catalog/catalog_transaction.hpp"
 #include "duckdb/common/pair.hpp"
 
+#include "include/gigapi_attach.hpp"
 
 namespace duckdb {
 
@@ -610,6 +611,8 @@ static void LoadInternal(DatabaseInstance &instance) {
 
 	auto giga_test_create_empty_index_scalar = ScalarFunction("giga_test_create_empty_index", {LogicalType::VARCHAR}, LogicalType::BOOLEAN, GigapiTestCreateEmptyIndexFunction);
 	ExtensionUtil::RegisterFunction(instance, giga_test_create_empty_index_scalar);
+
+	RegisterGigapiAttach(instance);
 }
 
 void GigapiExtension::Load(DuckDB &db) {

src/include/gigapi_attach.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "duckdb.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+
+namespace duckdb {
+
+class GigapiSchema : public SchemaCatalogEntry {
+public:
+    GigapiSchema(Catalog &catalog, const std::string &name);
+
+    TableCatalogEntry *GetTable(ClientContext &context, const std::string &table_name) override;
+};
+
+void RegisterGigapiAttach(DatabaseInstance &instance);
+
+} // namespace duckdb