Method drop_table

cpp/deeplake_pg/table_storage.cpp:970–1023

}

void table_storage::drop_table(const std::string& table_name)
{
    // Load metadata BEFORE acquiring the DDL lock.
    // force_load_table_metadata() may trigger CREATE TABLE (via SPI) for tables
    // in the S3 catalog that don't exist in pg_class yet.  CREATE TABLE goes
    // through the table AM which also acquires the DDL lock — doing that while
    // we already hold it would self-deadlock (LWLocks are not recursive).
    if (!table_exists(table_name)) {
        force_load_table_metadata();
    }
    pg::table_ddl_lock_guard ddl_lock;
    if (table_exists(table_name)) {
        auto& table_data = get_table_data(table_name);
        auto creds = session_credentials::get_credentials();

        // Update stateless catalog if enabled
        if (pg::stateless_enabled) {
            const auto root_dir = []() {
                auto root = session_credentials::get_root_path();
                if (root.empty()) {
                    root = pg::utils::get_deeplake_root_directory();
                }
                return root;
            }();
            pg::dl_catalog::ensure_catalog(root_dir, creds);
            auto [schema_name, simple_table_name] = split_table_name(table_name);
            pg::dl_catalog::table_meta meta;
            meta.table_id = schema_name + "." + simple_table_name;
            meta.schema_name = schema_name;
            meta.table_name = simple_table_name;
            meta.dataset_path = table_data.get_dataset_path().url();
            meta.state = "dropping";
            pg::dl_catalog::upsert_table(root_dir, creds, meta);
            pg::dl_catalog::bump_catalog_version(root_dir, session_credentials::get_credentials());
            catalog_version_ = pg::dl_catalog::get_catalog_version(root_dir, session_credentials::get_credentials());
        }

        try {
            table_data.commit(); // Ensure all changes are committed before deletion
            table_version_tracker::drop_table(table_data.get_table_oid());
            deeplake_api::delete_dataset(table_data.get_dataset_path(), std::move(creds)).get_future().get();
        } catch (const storage::storage_key_not_found&) {
            // Dataset does not exist, silently continue with deletion
            elog(DEBUG1, "Dataset not found during table drop, continuing silently");
        } catch (const base::exception& e) {
            // Dataset deletion failed - log warning but continue with table cleanup
            // This handles cases where dataset was already deleted externally
            elog(WARNING, "Failed to delete dataset during table drop: %s", e.what());
        }
        erase_table(table_name);
    }
    /// FreeTupleDesc(table_data.tuple_descriptor_);
    erase_table_metadata(table_name);
}

void table_storage::insert_slot(Oid table_id, TupleTableSlot* slot)
{