COPY FROM un archivo del servidor o un INSERT gigante: qué usar en su lugar

VERICTO-061 Media En CI (CLI offline): FLAGGED

COPY users FROM '/var/lib/postgresql/users.csv' WITH (FORMAT csv); hace que el servidor PostgreSQL lea un archivo de su propio disco, lo que requiere ser superusuario o tener el rol pg_read_server_files. No se pierde nada, pero cualquier rol que pueda hacerlo puede leer archivos a los que llega el proceso del servidor. Envía los datos desde el cliente con COPY ... FROM STDIN (\copy de psql). Los lotes INSERT ... VALUES muy grandes plantean un problema parecido de tamaño.

Por qué pasa

El COPY del lado del servidor es la forma que muestran muchos ejemplos, y funciona en desarrollo, donde la aplicación suele conectarse como superusuario en la misma máquina que el archivo. Los lotes INSERT gigantes salen de código generado que pone toda una importación en una sola sentencia, lenta de analizar, que retiene locks mucho tiempo y falla entera.

Cómo corregirlo

Carga desde el cliente, que solo necesita INSERT sobre la tabla:

\copy users FROM 'users.csv' WITH (FORMAT csv)

Desde el código de la aplicación, usa el soporte de COPY FROM STDIN de tu driver. Divide las importaciones grandes con INSERT en lotes; el protocolo de PostgreSQL además limita una sentencia a 65.535 parámetros.

Cómo evitar que vuelva a pasar

VERICTO-061 · INSERT batch con más de 10k filas · Severidad: Media · Nodo del AST: CopyStmt > FROM file

La sentencia que la regla reporta

-- import.sql
COPY users FROM '/var/lib/postgresql/users.csv' WITH (FORMAT csv);

Salida real de la CLI

$ npx @vericto/vericto-cli@2.3.0 check --offline import.sql
note: offline mode: 42 standard rules at default severities, engine 5.1.0. Custom rules, overrides, sensitive columns, allowlists and the audit trail apply online only.
! import.sql  FLAGGED  VERICTO-061 medium
    CopyStmt > FROM file
    fix: Stream the rows from the client with COPY … FROM STDIN (psql \copy) instead of a server-side file
0 blocked · 0 allowed · 1 flagged · 0 monitored   (ruleset standard@engine-5.1.0 · mode: offline (engine 5.1.0, 42 standard rules, no workspace policy))

La CLI la marca como FLAGGED y sale con 0: se informa sin frenar el job. Con --fail-on flag (o fail_on = "flag" en .vericto.toml) sale con 1 y el job falla.

La versión corregida

-- import.sql
COPY users FROM STDIN WITH (FORMAT csv);
$ npx @vericto/vericto-cli@2.3.0 check --offline import.sql
note: offline mode: 42 standard rules at default severities, engine 5.1.0. Custom rules, overrides, sensitive columns, allowlists and the audit trail apply online only.
0 blocked · 1 allowed · 0 flagged · 0 monitored   (ruleset standard@engine-5.1.0 · mode: offline (engine 5.1.0, 42 standard rules, no workspace policy))

Pruébalo gratis, sin cuenta

La CLI revisa tus archivos .sql en tu máquina con las 42 reglas estándar: sin registro, sin API key y sin que el SQL salga de tu equipo. Es open source (AGPL-3.0-only).

npx @vericto/vericto-cli@2.3.0 check --offline migrations/

En cada pull request

La GitHub Action vericto/check-sql (Apache-2.0) corre la misma revisión offline sobre los archivos .sql que cambia el PR y anota los hallazgos en el PR. Guárdala como .github/workflows/vericto.yml:

on: pull_request
jobs:
  vericto:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
        with: { fetch-depth: 0 }
      - uses: vericto/check-sql@v1
        with: { offline: true, upload-sarif: false }

En runtime, para agentes de IA

El SQL que escribe un agente de IA no pasa por un PR. El proxy TCP de Vericto revisa cada sentencia entre la aplicación o el agente y la base de datos, y la herramienta check_sql de MCP deja que el agente compruebe el SQL antes de ejecutarlo. Los dos usan el perfil de runtime, que también bloquea los cambios de esquema.

La condición AST en el engine

La regla es un predicado determinístico sobre el AST, en src/rules/evaluator.rs del engine open source (AGPL-3.0-only), en el commit de esta página:

"VERICTO-061" => find(stmts, |s| {
    (s.kind == StatementKind::Insert
        && s.insert_row_count.map(|n| n > 10_000).unwrap_or(false))
        || (s.kind == StatementKind::Copy && s.copy_from_file)
})
.map(|s| {
    if s.kind == StatementKind::Copy {
        let mut v = violation(
            rule,
            s,
            Some("Stream the rows from the client with COPY … FROM STDIN (psql \\copy) instead of a server-side file".to_string()),
        );
        v.ast_node_path = "CopyStmt > FROM file".to_string();
        v
    } else {
        let count = s.insert_row_count.unwrap_or(0);
        let mut v = violation(
            rule,
            s,
            Some("Split the batch into chunks of ≤1,000 rows with COPY or multiple INSERT statements".to_string()),
        );
        v.ast_node_path = format!("InsertStmt > ValuesList count = {count}");
        v
    }
}),

Preguntas frecuentes