Extended protocol SELECT fails with 'permission denied for table pg_type'

[johannesdb]

Description

SELECT queries with bind parameters via the extended query protocol fail with:

permission denied for table pg_type (errno 1105) (sqlstate HY000)

This appears to happen because the extended protocol's Describe/Parse step needs to resolve parameter types via pg_type, and DoltgreSQL denies access to it for non-superuser connections.

Simple protocol SELECT (via raw_sql()) and SELECTs on the superuser (postgres) connection work fine.

Reproduction

// Connect as a non-superuser:
let pool = PgPoolOptions::new()
    .connect("postgres://myuser:mypass@localhost:5433/mydb")
    .await?;

// This fails:
let user = sqlx::query_as::<_, User>("SELECT * FROM users WHERE google_id = $1")
    .bind("some-google-id")
    .fetch_optional(&pool)
    .await?;
// Error: permission denied for table pg_type (errno 1105)

// But this works (simple protocol, no bind parameters):
let sql = "SELECT * FROM users WHERE google_id = 'some-google-id'";
let user = pool.fetch_optional(sqlx::raw_sql(sql)).await?;

The error occurs on the very first extended protocol query. It is not specific to any table — any SELECT with $1 bind parameters triggers it.

Context

This may be related to #1465 (SQLAlchemy pg_type access issues) and #442 (pg_catalog table name resolution). The fix for #1465 may have resolved the OID resolution but not the permission check for non-superuser connections.

Workaround

We converted all SELECT queries to use the simple query protocol via sqlx::raw_sql(), avoiding bind parameters entirely.

Alternatively, connecting as the postgres superuser avoids the permission error, but that's not suitable for production.

Environment

• DoltgreSQL: dolthub/doltgresql:latest (Docker), version 0.55.0
• Client: SQLx 0.8 (Rust) via extended query protocol
• Non-superuser database connection

[Hydrocharged]

Greetings! I am unable to reproduce this, could you provide more details? Preferably, a small Rust project that sets up everything for the repro would be fantastic to ensure that we're able to get this fixed as soon as possible.

For reference, this was my attempt at a repro:

use sqlx::FromRow;
use sqlx::postgres::PgPoolOptions;

#[derive(FromRow)]
struct User {
    id: sqlx::types::Uuid,
    name: Option<String>,
    email: Option<String>,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let database_url = "postgresql://postgres:password@localhost:5432/postgres";
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await?;

    sqlx::query("DROP TABLE IF EXISTS \"users\";")
    .execute(&pool)
    .await?;

    sqlx::query("DROP USER IF EXISTS myuser;")
    .execute(&pool)
    .await?;

    sqlx::query("CREATE TABLE \"users\" (id uuid default gen_random_uuid(), name text, email text);")
    .execute(&pool)
    .await?;

    sqlx::query("CREATE USER myuser PASSWORD 'password';")
    .execute(&pool)
    .await?;

    sqlx::query("GRANT SELECT ON \"users\" TO myuser;")
    .execute(&pool)
    .await?;

	sqlx::query("INSERT INTO \"users\" (name, email) VALUES ($1, $2)")
    .bind("Alice")
    .bind("alice@example.com")
    .execute(&pool)
    .await?;

    let database_url_2 = "postgresql://myuser:password@localhost:5432/postgres";
    let pool_2 = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url_2)
        .await?;

    let user = sqlx::query_as::<_, User>("SELECT * FROM \"users\" WHERE email = $1")
    .bind("alice@example.com")
    .fetch_optional(&pool_2)
    .await?;

    sqlx::query("DROP TABLE \"users\";")
    .execute(&pool)
    .await?;

    sqlx::query("DROP USER myuser;")
    .execute(&pool)
    .await?;

    Ok(())
}

This executes as expected without an error. Removing the GRANT SELECT results in an error stating that myuser can't access users, which is the expected behavior.

[johannesdb]

Thanks for looking into this! I was unable to reproduce the pg_type permission error on dolthub/doltgresql:latest either — it may have been fixed in a recent release.

However, while building the repro I discovered two other extended protocol issues that affect us:

• JSONB: Sent as raw JSON text instead of binary JSONB format (missing 0x01 version prefix), causing SQLx to panic with "unsupported JSONB format version 123"
• TIMESTAMPTZ: Sent as 29-byte text string instead of 8-byte int64, causing "Buffer exceeds 8 bytes" decode errors

Both affect superuser and non-superuser connections equally. Basic types (UUID, VARCHAR) work fine.

Full repro: https://github.com/johannesdb/doltgresql-pg-type-repro

docker compose up -d && sleep 10 && cargo run