Plano de execução

import pg from "pg";

const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });

/** Tabelas que a consulta varre por inteiro mesmo quando o banco é proibido de fazer isso. */
export async function tabelasSemIndice(sql: string): Promise<string[]> {
  const conexao = await pool.connect();
  try {
    await conexao.query("BEGIN");
    // Com a varredura completa desligada, ela só aparece se nenhum índice serve
    await conexao.query("SET LOCAL enable_seqscan = off");
    const { rows } = await conexao.query(`EXPLAIN ${sql}`); // só planeja, não executa
    const plano = rows.map((r) => r["QUERY PLAN"]).join("\n");
    return [...plano.matchAll(/Seq Scan on (\w+)/g)].map((m) => m[1]);
  } finally {
    await conexao.query("ROLLBACK");
    conexao.release();
  }
}

// Num teste: expect(await tabelasSemIndice(consulta)).toEqual([]);

import os
import re

import psycopg

conexao = psycopg.connect(os.environ["DATABASE_URL"])


def tabelas_sem_indice(sql: str) -> list[str]:
    """Tabelas que a consulta varre por inteiro mesmo quando o banco é proibido de fazer isso."""
    with conexao.transaction(force_rollback=True):
        # Com a varredura completa desligada, ela só aparece se nenhum índice serve
        conexao.execute("SET LOCAL enable_seqscan = off")
        linhas = conexao.execute(f"EXPLAIN {sql}").fetchall()  # só planeja, não executa
    plano = "\n".join(linha[0] for linha in linhas)
    return re.findall(r"Seq Scan on (\w+)", plano)

# Num teste: assert tabelas_sem_indice(consulta) == []

package main

import (
	"context"
	"fmt"
	"os"
	"regexp"
	"strings"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgxpool"
)

var varreduraCompleta = regexp.MustCompile(`Seq Scan on (\w+)`)

// tabelasSemIndice devolve as tabelas que a consulta varre por inteiro mesmo quando
// o banco é proibido de fazer isso.
func tabelasSemIndice(ctx context.Context, db *pgxpool.Pool, sql string) ([]string, error) {
	tx, err := db.Begin(ctx)
	if err != nil {
		return nil, err
	}
	defer tx.Rollback(ctx)

	// Com a varredura completa desligada, ela só aparece se nenhum índice serve
	if _, err := tx.Exec(ctx, "SET LOCAL enable_seqscan = off"); err != nil {
		return nil, err
	}
	linhas, err := tx.Query(ctx, "EXPLAIN "+sql) // só planeja, não executa
	if err != nil {
		return nil, err
	}
	plano, err := pgx.CollectRows(linhas, pgx.RowTo[string])
	if err != nil {
		return nil, err
	}
	tabelas := []string{}
	for _, m := range varreduraCompleta.FindAllStringSubmatch(strings.Join(plano, "\n"), -1) {
		tabelas = append(tabelas, m[1])
	}
	return tabelas, nil
}

// Num teste: if len(tabelas) > 0 { t.Errorf("sem índice: %v", tabelas) }

import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

public class Plano {
    static final Pattern VARREDURA_COMPLETA = Pattern.compile("Seq Scan on (\\w+)");

    /** Tabelas que a consulta varre por inteiro mesmo quando o banco é proibido de fazer isso. */
    static List<String> tabelasSemIndice(Connection db, String sql) throws SQLException {
        db.setAutoCommit(false);
        try (var comando = db.createStatement()) {
            // Com a varredura completa desligada, ela só aparece se nenhum índice serve
            comando.execute("SET LOCAL enable_seqscan = off");
            var plano = new StringBuilder();
            try (var linhas = comando.executeQuery("EXPLAIN " + sql)) { // só planeja, não executa
                while (linhas.next()) plano.append(linhas.getString(1)).append('\n');
            }
            var tabelas = new ArrayList<String>();
            var m = VARREDURA_COMPLETA.matcher(plano);
            while (m.find()) tabelas.add(m.group(1));
            return tabelas;
        } finally {
            db.rollback();
        }
    }

    // Num teste: assertEquals(List.of(), tabelasSemIndice(db, consulta));
}

using System.Text.RegularExpressions;
using Npgsql;

await using var db = NpgsqlDataSource.Create(Environment.GetEnvironmentVariable("DATABASE_URL")!);

// Tabelas que a consulta varre por inteiro mesmo quando o banco é proibido de fazer isso
async Task<List<string>> TabelasSemIndice(string sql)
{
    await using var conexao = await db.OpenConnectionAsync();
    await using var tx = await conexao.BeginTransactionAsync(); // desfeita ao descartar
    // Com a varredura completa desligada, ela só aparece se nenhum índice serve
    await using (var desligar = new NpgsqlCommand("SET LOCAL enable_seqscan = off", conexao, tx))
        await desligar.ExecuteNonQueryAsync();

    var plano = new List<string>();
    await using var explicar = new NpgsqlCommand($"EXPLAIN {sql}", conexao, tx); // só planeja
    await using var linhas = await explicar.ExecuteReaderAsync();
    while (await linhas.ReadAsync()) plano.Add(linhas.GetString(0));

    return Regex.Matches(string.Join('\n', plano), @"Seq Scan on (\w+)")
        .Select(m => m.Groups[1].Value).ToList();
}

// Num teste: Assert.Empty(await TabelasSemIndice(consulta));