All Errors

The PGRST103 error (HTTP 416: Range Not Satisfiable) occurs when you request a data range using .range() or pagination parameters that exceeds the available rows in your Supabase table. This guide walks through validating pagination bounds, fetching total counts before querying, and handling out-of-bounds requests gracefully.

This error occurs when you attempt to create or update a user password in Supabase Auth that doesn't meet the configured password strength requirements. Your password may be too short, lack required character types, or be a known compromised password.

Firestore transactions require an active network connection to the backend and will fail immediately when the client is offline. This is by design—transactions need to read and verify data on the server to ensure consistency.

PostgreSQL "insufficient privilege to bypass row security" error occurs when a user attempts to access or modify rows in a table with Row-Level Security (RLS) policies enabled, but lacks the BYPASSRLS privilege. This is a security feature that enforces data access restrictions. Fix by granting BYPASSRLS attribute to the role or by creating appropriate RLS policies for the user.

This error occurs when you attempt to calculate a power (exponentiation) with mathematically invalid arguments to PostgreSQL functions like POWER() or POW(). Common causes include raising a negative base to a fractional exponent or zero raised to a negative power, which would result in complex numbers or undefined values that PostgreSQL cannot represent.

The "session_not_found" error occurs when Supabase Auth detects that the session ID in your JWT token no longer exists in the auth.sessions table. This typically happens due to session expiration, token refresh failures, or URL mismatches between your Supabase configuration and frontend application.

The "NOGOODSLAVE No good slave available for failover" error occurs in Redis Sentinel when attempting a failover but no healthy replica instances are available to promote to master. This typically happens when all replicas are offline, lagging, or unreachable.

SQLSTATE 22002 occurs when a NULL value is fetched from the database but no indicator variable was specified to capture its null status. This commonly happens in embedded SQL (ECPG) or applications using cursor variables without proper null handling.

The PostgreSQL error 2201W "Invalid row count in LIMIT clause" occurs when a non-integer, negative, or otherwise invalid value is passed to the LIMIT clause in a SQL query. LIMIT expects a non-negative integer or NULL, and providing strings, floating-point numbers, negative values, or other invalid types triggers this error. Fixing requires ensuring the LIMIT value is properly validated and cast to an integer in your application code.

MySQL throws ER_WINDOW_DUPLICATE_NAME when the WINDOW clause in a SELECT statement defines the same window name more than once. Each named window specification must have a unique identifier to avoid ambiguity when functions reference them.

PostgreSQL raises HV004 when a foreign-data wrapper encounters a data type mismatch between the local foreign table column definition and the remote object's actual data type. This commonly occurs when PostgreSQL foreign table columns are declared with incompatible types or when using FDWs like oracle_fdw where type conversion is not supported. Aligning the column data types between local and remote definitions resolves the error.

This PostgreSQL error occurs when you try to create a unique constraint or primary key on a partitioned table without including all partition key columns. PostgreSQL enforces uniqueness only within each partition, so the constraint must include the partition key columns to ensure proper behavior. The fix requires adding all partition key columns to your constraint definition.

This error indicates your Firebase Cloud Function threw an unhandled exception. It happens when your code crashes without proper error handling, preventing the function from returning a valid response to the client.

MySQL error EE_WRITE (3) indicates a failure writing to a file, typically caused by permission problems, non-existent directories, or path issues with the tmpdir setting. This error blocks database operations until the underlying filesystem problem is resolved. Quick fixes include checking permissions, verifying directory existence, and ensuring the MySQL tmpdir points to a valid location.

This generic Firebase Cloud Messaging error occurs when FCM encounters an unexpected condition that doesn't fit standard error categories. The fix involves validating Firebase setup, checking network connectivity, reviewing message payloads, and implementing robust error logging to identify the root cause.

This MySQL client error occurs when a prepared statement is executed without binding values to all the parameter placeholders (?) defined in the SQL query. The error indicates a mismatch between the expected parameters and the data actually provided.

This MySQL client error occurs when DNS SRV record lookup fails during connection attempts using the mysql_real_connect_dns_srv() function or --dns-srv-name option. The error indicates the DNS server either cannot find the SRV record, the SRV record is misconfigured, or DNS resolution is failing. This commonly affects MySQL 8.0+ clients using DNS SRV for failover and load balancing scenarios.

This error occurs when importing users with a password hash algorithm that Firebase Authentication does not recognize or support. Learn how to identify supported hash algorithms, validate import parameters, and correctly configure user migration.

The "must be owner of table" error (PostgreSQL error code 42501) occurs when pg_restore attempts to perform operations on tables owned by a different user. This typically happens when restoring a dump to a different database environment or when the restoring user lacks superuser privileges.

SQLITE_LOCKED_SHAREDCACHE occurs when multiple connections to the same database in shared-cache mode attempt conflicting operations simultaneously. This error indicates a table-level lock conflict and typically appears in multi-threaded applications. The recommended solution is to disable shared-cache mode or migrate to WAL mode, which handles concurrent access more efficiently.