Method scan_begin

cpp/deeplake_pg/table_am.cpp:675–742

}

TableScanDesc deeplake_table_am_routine::scan_begin(Relation relation,
                                                    Snapshot snapshot,
                                                    int32_t nkeys,
                                                    struct ScanKeyData* key,
                                                    ParallelTableScanDesc parallel_scan,
                                                    uint32_t flags)
{
    // Ensure DeepLake is initialized (for processes that bypass planner/executor hooks,
    // such as autovacuum workers, parallel workers, or standalone ANALYZE)
    pg::init_deeplake();

    DeeplakeScanData* extended_scan = static_cast<DeeplakeScanData*>(palloc0(sizeof(DeeplakeScanData)));
    auto table_id = RelationGetRelid(relation);
    bool is_parallel = (pg::use_parallel_workers && parallel_scan != nullptr);

    // Refresh table data BEFORE creating the scan to ensure num_rows is up to date
    // (table_scan constructor caches num_rows at construction time)
    auto& td_for_refresh = pg::table_storage::instance().get_table_data(table_id);
    const_cast<pg::table_data&>(td_for_refresh).refresh();

    // Initialize extended structure with embedded scan data
    new (extended_scan)
        DeeplakeScanData(table_scan(table_id, is_parallel, query_info::current().receiver_registered()));

    TableScanDesc scan_desc = &extended_scan->postgres_scan;
    scan_desc->rs_rd = relation;
    scan_desc->rs_snapshot = snapshot;
    scan_desc->rs_nkeys = nkeys;
    scan_desc->rs_key = key;
    scan_desc->rs_flags = flags;
    scan_desc->rs_parallel = parallel_scan;

    if (parallel_scan != nullptr) {
        DeeplakeParallelScanDesc* custom_pscan = reinterpret_cast<DeeplakeParallelScanDesc*>(parallel_scan);
        if (IsParallelWorker()) {
            custom_pscan->is_initialized = true;
        }
    }

    auto& td = table_storage::instance().get_table_data(table_id);
    // For UPDATE/DELETE operations, we need all columns because PostgreSQL needs to reconstruct
    // the entire tuple. For SELECT *, we also need all columns.
    // For ANALYZE, we also need all columns to sample data and calculate statistics.
    bool need_all_columns = (flags & SO_TYPE_ANALYZE) ||
                            (!pg::query_info::current().is_count_star() && td.is_star_selected()) ||
                            (pg::query_info::current().command_type() == pg::command_type::CMD_UPDATE) ||
                            (pg::query_info::current().command_type() == pg::command_type::CMD_DELETE);

    if (need_all_columns) {
        for (auto i = 0; i < td.num_columns(); ++i) {
            if (!td.is_column_requested(i)) {
                td.set_column_requested(i, true);
                if (td.can_stream_column(i)) {
                    td.create_streamer(i, -1);
                }
            }
        }
    }