Error codes

The .NET, TypeScript, and Python drivers expose CamusDB error codes through their exception/error objects. Each driver decodes its transport's error responses for you. Use retry helpers for retryable conflicts.

Base your application logic on the code, not the message text. The code identifies the condition; the message is for people. For example, replay a transaction through a retry helper on CADB0502 or CADB0504, and show the user a validation error on a CADB03xx constraint failure. Use this page to look up a code you see in a log or a response.

Error envelopes for protocol clients

A failed HTTP response looks like this:

{
  "status": "failed",
  "code": "CADB0400",
  "message": "error message"
}

Unary and streaming gRPC calls carry the same domain code in the camus-error-code trailer. A gRPC batch operation carries the code inside its BatchError message.

How to read them

CADB00xx: catalog, metadata, or storage-state problems
CADB03xx: data integrity constraint failures
CADB04xx: invalid SQL, invalid input, or unsupported expression shape
CADB05xx: transaction, schema-catch-up, prepared-statement, and auth conditions
CADB051x: authentication, authorization, users, and grants
CADB06xx: startup or configuration validation errors
CADB07xx: backup and point-in-time-recovery operations
CADB08xx: C# extension loading, functions, triggers, procedures, and detected storage damage (CADB0837)

Some codes are ordinary errors that users see. Others mostly report corruption, an unexpected internal state, or an inconsistency in the storage layer.

Common user-facing errors

Code	Name	When it is generated
`CADB0010`	`DatabaseDoesntExist`	An operation targets a database name that has not been explicitly created, a name that was dropped or renamed away, or, with authentication enabled, a database the caller holds no grant on.
`CADB0011`	`TableDoesntExist`	A query, DML statement, schema change, or table rename references a table that does not exist, or the table name is empty.
`CADB0012`	`DatabaseAlreadyExists`	`CREATE DATABASE` targets an existing database, or a database rename targets a name that is already registered.
`CADB0013`	`TableAlreadyExists`	`CREATE TABLE` tries to create a table name that already exists, or `ALTER TABLE ... RENAME TO ...` targets an existing table name.
`CADB0016`	`IndexDoesntExist`	Reserved for index lookups or DDL against an index that does not exist. It is defined but not commonly thrown by the current user-facing path.
`CADB0018`	`DatabaseNameReserved`	`CREATE DATABASE` or a database rename uses a reserved name such as `_system` or `information_schema`.
`CADB0019`	`DatabaseCreationIncomplete`	Reserved for an incomplete database-create recovery condition from older standalone storage layouts. It is defined in the core list but is not expected on the current shared-storage create path.
`CADB0300`	`DuplicateUniqueKeyValue`	An insert, update, or index backfill would violate a unique index or unique key.
`CADB0301`	`NotNullViolation`	An insert or update tries to store `NULL` into a `NOT NULL` column.
`CADB0302`	`ValueTooLong`	An insert, update, or cast tries to store a `STRING` or `BYTES` value longer than the column's configured or default maximum length.
`CADB0303`	`CheckConstraintViolation`	An insert, update, or `ALTER TABLE ... ADD CONSTRAINT ... CHECK` would make a row violate a check constraint, or check evaluation hits incompatible values or a regex failure inside the check.
`CADB0304`	`ForeignKeyViolation`	A child `INSERT` or `UPDATE` has no parent row, or `ALTER TABLE ... ADD CONSTRAINT ... FOREIGN KEY` finds an existing child row without a parent.
`CADB0305`	`ForeignKeyRestrictDelete`	A `DELETE` would remove a parent key that a child row still references.
`CADB0306`	`ForeignKeyRestrictUpdate`	An `UPDATE` would change a parent key that a child row still references.
`CADB0400`	`InvalidInput`	Also covers negative LIMIT/OFFSET, ambiguous ORDER BY output names, non-boolean predicates, unpaired UTF-16 surrogates in SQL parameters, malformed JSON on SQL endpoints, invalid LIKE escape values, and constant division by zero. The request shape is invalid: missing names, invalid DDL/DML parameters, malformed query structure, invalid check definitions, invalid regex patterns, unsupported function arguments, invalid casts, malformed UUID input, duplicate aliases, invalid transaction priority, invalid table settings such as row-level TTL options, invalid index rename inputs, invalid `INSERT INTO ... SELECT` column counts, invalid CTAS projections, invalid `GROUP BY` / `HAVING` / `DISTINCT` combinations, and similar user mistakes.
`CADB0401`	`UnknownType`	CamusDB is asked to encode, decode, cast, or evaluate a type it does not understand in that context.
`CADB0402`	`DuplicatePrimaryKey`	Reserved for duplicate primary-key violations. The current storage path usually reports uniqueness failures as `CADB0300`.
`CADB0403`	`DuplicateColumn`	A schema definition, INSERT target list, UPDATE SET list, ON CONFLICT update arm, or typed row write repeats a column name, ignoring case; also a column rename targeting an existing name. Repeated write targets are refused before writing. HTTP 400.
`CADB0404`	`UnknownColumn`	A statement references or renames a column name that is not present or not currently visible in the schema state.
`CADB0405`	`UnknownKey`	Query planning or scanning expected a known row or index key shape but received a key it could not map correctly. This is uncommon for ordinary SQL and usually points to an internal query/storage mismatch.
`CADB0406`	`SqlSyntaxError`	The SQL parser cannot parse the statement text, including unknown characters or unsupported whitespace; the scanner reports the line and column.
`CADB0407`	`InvalidAstStmt`	The parser succeeded, but the resulting AST shape is invalid, unsupported, or semantically unusable for the requested executor path.
`CADB0408`	`SchemaLimitExceeded`	A database, table, column, or index name is longer than `max_identifier_length`, or a schema operation would exceed `max_columns_per_table`, `max_indexes_per_table`, or `max_tables_per_database`.
`CADB0409`	`InvalidAsOfSystemTime`	An `AS OF SYSTEM TIME` query uses a malformed value, a future or non-positive timestamp, an incompatible parameter, or a transaction shape that cannot be pinned to an arbitrary historical snapshot.
`CADB0410`	`MalformedVector`	A `BYTES` value is used where a packed float32 vector is required, but its byte count is not a whole number of 4-byte elements, or the vector has zero elements.
`CADB0411`	`VectorDimensionMismatch`	Two vector operands of a distance function have different dimensions. The message names both dimensions.
`CADB0412`	`InvalidVectorValue`	A vector element is `NaN` or an infinity, or `cosine_distance` receives a zero-magnitude vector, for which the metric is undefined.
`CADB0413`	`StatementTooDeeplyNested`	A statement's parse tree is deeper than CamusDB's safety limit. Rewrite the statement with less nesting, or split it into more statements.
`CADB0414`	`ColumnStorageNotApplicable`	A `STORAGE` strategy was given for a column type that has no variable-length value. Use storage strategies only on `STRING`, `BYTES`/`BLOB`, `JSONB`, and `ARRAY` columns.
`CADB0415`	`InvalidForeignKeyDefinition`	A foreign key references an invalid target: wrong column count or type, no matching primary key or unique index, a view, a materialized view, or another database.
`CADB0416`	`ForeignKeyCycle`	A foreign key would create a cycle across two or more tables. A self-reference is allowed.
`CADB0417`	`NumericValueOutOfRange`	A `NUMERIC` value or arithmetic result is outside the supported range of `-99999999999999999999999999999.999999999` to `99999999999999999999999999999.999999999`.
`CADB0418`	`InvalidJsonText`	Text given for a `JSONB` value is not a document the type can store: invalid JSON, a `\u0000` escape or a lone surrogate in a string, or a number past the PostgreSQL `numeric` limits. A cast, a typed literal, a write to a `JSONB` column, or a `JSONB` parameter can raise it. HTTP 400. See JSON documents.
`CADB0419`	`JsonNestingTooDeep`	A `JSONB` document nests objects and arrays deeper than 512 levels. HTTP 400.
`CADB0420`	`IntegerValueOutOfRange`	Integer arithmetic, a literal, aggregate, or cast exceeds `INT64`. Use `NUMERIC` when a wider exact value is intended. HTTP 400; gRPC `OUT_OF_RANGE`.
`CADB0421`	`FloatValueOutOfRange`	Finite float arithmetic, a literal, aggregate, or cast overflows or underflows to zero. HTTP 400; gRPC `OUT_OF_RANGE`.
`CADB0422`	`JsonbValueTooLarge`	A built JSONB aggregate exceeds 268,435,455 bytes. Reduce the group or result size. HTTP 400; gRPC `INVALID_ARGUMENT`.
`CADB0501`	`TransactionAlreadyCompleted`	The caller tries to commit or roll back a transaction that is already committed, already rolled back, or otherwise no longer active. It is also used when Kahuna, the transactional storage layer, returns a permanent non-retryable commit failure and the transaction is already dead.
`CADB0502`	`TransactionConflict`	The transaction cannot acquire the needed lock or hits a conflicting concurrent write. Conflict messages include bounded diagnostic context such as the table/database, a small sample of contended keys, and the waiting transaction mode when available.
`CADB0503`	`SchemaCatchingUp`	The node is more than one schema version behind the committed schema head for that database, so it temporarily rejects reads and DML until schema apply catches up. Retry on another node or retry later.
`CADB0504`	`TransactionMustRetry`	A transient condition exhausted internal retries, usually during transaction start, admission, routing, leader change, inter-node transport, lock-wait deadline, a storage write conflict before the affected write was applied, or a read range that could not currently be served. Retry the whole transaction from `BEGIN`.
`CADB0505`	`TransactionLifetimeExceeded`	A serializable read-write transaction stayed open longer than the configured maximum lifetime, currently one hour by default. CamusDB aborts it explicitly instead of letting a runaway transaction continue forever. Roll it back and retry from `BEGIN`.
`CADB0506`	`TransactionMutationLimitExceeded`	A read-write transaction would exceed the maximum mutation count, currently 20,000 row/index mutations by default. Split the work into smaller transactions; retrying the same transaction will fail again.
`CADB0507`	`SpillStorageUnavailable`	A query operator needed spill-to-disk temporary storage, but CamusDB could not create the spill directory or open a spill file. Free disk space, fix permissions under `data_dir`, or run the query on a node with writable spill storage.
`CADB0508`	`DatabaseHasLiveDescendants`	`DROP DATABASE` targets a database that still has live branch descendants. Drop descendant branches first, then drop the parent.
`CADB0509`	`TransactionFinalizeUnresolved`	A `COMMIT` or `ROLLBACK` could not reach a terminal answer after bounded same-handle retries. The final outcome is not known yet, so retry the same finalize request on the same transaction id; do not replay the business operation from `BEGIN`.
`CADB0510`	`OrphanNotFound`	`CREATE DATABASE ... RELINK TO`, `CREATE TABLE ... RELINK TO`, or orphan reclamation references an orphan id that does not exist, was already recovered, or was already reclaimed.
`CADB0511`	`CommentTooLong`	A `COMMENT ON` statement or inline `COMMENT` clause exceeds the maximum comment length of `65,535` characters. Shorten the comment and retry.
`CADB0512`	`UserAlreadyExists`	`CREATE USER` targets an existing user without `IF NOT EXISTS`.
`CADB0513`	`UserDoesNotExist`	`ALTER USER`, `DROP USER`, `GRANT`, or `REVOKE` targets a user that does not exist. `GRANT` never creates users implicitly.
`CADB0514`	`UnsupportedAuthPlugin`	`IDENTIFIED WITH <plugin>` names an unsupported authentication plugin. Only `sha256_password` is accepted.
`CADB0515`	`InvalidPrivilege`	`GRANT` or `REVOKE` names an unknown privilege or a privilege that is invalid for the target scope.
`CADB0516`	`AuthenticationFailed`	Authentication failed because credentials are missing, invalid, expired, revoked, or rejected. Login failures intentionally use the same error shape for unknown users and wrong passwords.
`CADB0517`	`InsufficientPrivilege`	The caller is authenticated but lacks the privilege required by the statement, on any table it touches, including tables read by joins and subqueries.
`CADB0518`	`TooManyAuthAttempts`	The login rate limit or the password-verification concurrency protection rejected the attempt.
`CADB0519`	`InsecureTransport`	A credential-bearing request arrived over plaintext while authentication is enabled and TLS is required. Use `https://`, or configure the server to trust a TLS-terminating proxy.
`CADB0520`	`UnknownPreparedStatement`	A prepared statement handle is not registered on this node, stream, or principal. It may have expired, been closed, belonged to another gRPC stream, been prepared on another node, or disappeared during restart. Prepare again and replay once.
`CADB0521`	`PreparedStatementLimitExceeded`	A prepared-statement registration would exceed a configured count cap, retained-byte budget, or maximum statement size. Close unused handles, reduce distinct SQL shapes, shorten the SQL, or tune the prepared-statement limits.
`CADB0522`	`AnalyzeRequiresNoPendingWrites`	`ANALYZE` was issued inside a transaction that has already written rows it has not committed. `ANALYZE` scans under its own read-only snapshot so the statistics it publishes describe committed data only, and that snapshot cannot read past the caller's own uncommitted writes (write intents). Commit or roll back first, then run `ANALYZE`.
`CADB0523`	`ViewDoesntExist`	A statement references a view or materialized view that does not exist. Also returned by `SHOW STATISTICS FOR` on a plain view, which stores no rows and therefore has no statistics of its own; ask for the statistics of the tables its definition reads.
`CADB0524`	`ViewAlreadyExists`	The name is already taken by a view or a materialized view. A name taken by an ordinary table raises `CADB0013` instead, so the error names the kind of object actually in the way.
`CADB0525`	`ViewNotUpdatable`	DML was issued against a view that is not auto-updatable, or against a materialized view. All views are currently read-only. The message names the specific rule that was violated.
`CADB0526`	`ViewColumnNotUpdatable`	An `UPDATE` or `INSERT` through a view targeted a column that is computed rather than a direct base-column reference, so there is no base column to write.
`CADB0527`	`ViewCheckOptionViolated`	A row written through a view with `WITH CHECK OPTION` does not satisfy the view's predicate. CamusDB evaluates it with the same three-valued logic as a `CHECK` constraint, so a predicate that returns `NULL` passes.
`CADB0528`	`ViewRecursionDetected`	A view's dependencies form a cycle. CamusDB detects it at DDL time by walking the stored dependency ids; `max_view_expansion_depth` is a runtime backstop, not the defense.
`CADB0529`	`CannotChangeViewShape`	`CREATE OR REPLACE VIEW` tried to change the view's existing column names, types, or order. Only appending columns is allowed. Drop and recreate to change the shape.
`CADB0530`	`DependentObjectsExist`	A schema change would orphan an object that depends on the target. Raised for dependent views and foreign keys, including a dropped referenced table, a dropped referenced column, a dropped backing index, or a truncate of a referenced parent. Drop the dependent object or constraint first.
`CADB0531`	`MaterializedViewNotPopulated`	A query read a materialized view that was created `WITH NO DATA` and never refreshed. This is an error rather than an empty result, because an empty result would make a forgotten `REFRESH` indistinguishable from a correct empty answer.
`CADB0532`	`RefreshAlreadyInProgress`	A `REFRESH` of this materialized view is already running, on this node or another. CamusDB refuses the new one instead of queuing it, because two concurrent refreshes would both succeed and the later swap would silently discard the earlier one's work.
`CADB0533`	`FeatureNotSupported`	A statement CamusDB parses but has not implemented, such as `REFRESH MATERIALIZED VIEW ... CONCURRENTLY`. Distinct from a syntax error: the statement is well-formed, and the message names the missing capability and the form that works today.
`CADB0534`	`ConcurrentSchemaChange`	An operation that derives a new definition from one it read found that the definition had changed underneath it, so it refused to publish over the change. Nothing was applied; run it again against the current definition.
`CADB0535`	`SequenceUnavailable`	A monotonic counter, such as a database id, a table id, or the registry generation stamp, could not be reached: the partition that stores it reported no confirmed Raft leader for the whole `sequence_retry_budget_ms` window, because a node is still joining or an election is in flight. Nothing was allocated or written, so CamusDB classifies it as retryable rather than as a corruption error. Maps to HTTP 503; run the statement again.
`CADB0536`	`InsufficientDiskSpace`	A write was refused before mutation because free space on the data directory volume is below `min_free_disk_bytes`. Reads, DDL, and internal system work remain available so an operator can recover space. Free disk on that node or lower the threshold, then retry. Maps to HTTP 507.
`CADB0537`	`SnapshotPrecedesContentsGeneration`	An `AS OF SYSTEM TIME` read named a point before the table's current contents began. A `TRUNCATE` replaced the key space that holds the rows, so the live schema can no longer locate the old rows. Returning an empty result would look the same as a correct empty answer; this code prevents that. Read at or after the cut, or recover the retired contents with `CREATE TABLE ... RELINK TO`.
`CADB0538`	`StatementNotAllowedInTransaction`	A statement that commits its own work ran inside the caller's explicit transaction. Three statements are refused: `TRUNCATE`, `ALTER TABLE ... REWRITE STORAGE`, and `ALTER SEQUENCE ... RESTART`. A later `ROLLBACK` cannot undo what they commit. Commit or roll back first, then run the statement.
`CADB0539`	`BranchSnapshotProtectionLost`	A branch database lost the snapshot protection that pins inherited ancestor history at its fork point. CamusDB fails closed instead of returning a possibly incomplete result. Recreate the branch from the parent. Maps to HTTP 410.
`CADB0542`	`SequenceAlreadyExists`	`CREATE SEQUENCE` targets a name already held by a sequence, table, or view. Pick another name or use `IF NOT EXISTS` when appropriate.
`CADB0543`	`SequenceDoesntExist`	A sequence statement or sequence function names a sequence that does not exist.
`CADB0544`	`SequenceExhausted`	The sequence has no value left to issue because the next value would pass its `MAXVALUE`.
`CADB0545`	`InvalidSequenceDefinition`	A sequence definition cannot hold: non-positive increment, `CACHE` below 1, `MAXVALUE` below `MINVALUE`, or `START` outside the range.
`CADB0546`	`SequenceValueNotYetDefined`	`currval` or `lastval` was called before this transaction drew a value from the sequence.
`CADB0547`	`SequenceCallNotAllowedHere`	A sequence call was written in a context where CamusDB cannot know how many values it would draw before the statement runs.
`CADB0548`	`SequenceInUse`	A sequence is owned by an identity column, or a column default depends on it. Drop or change the dependent object first.
`CADB0549`	`SpillLimitExceeded`	A spill write would exceed `spill_max_total_bytes` for live spill files on this node. The statement fails, its spill files are deleted, and no partial write is kept. Free spill space by letting other queries finish, raise the limit, or disable the total-byte limit with a value of `0` or below.
`CADB0550`	`ReturningResultTooLarge`	The `RETURNING` rows of a write statement do not fit in one gRPC non-query reply or non-query batch reply. The statement is rolled back before commit. Use a streaming query endpoint, or set `discard_returning_rows` (gRPC) or `discardReturningRows` (HTTP, TypeScript) to receive only the row count. The .NET `ExecuteNonQueryAsync()` sets it.
`CADB0551`	`QueryNotFound`	`CANCEL QUERY` did not find a visible running query with that id. The query may have ended, the id may be wrong, or the query may belong to another user.
`CADB0552`	`QueryNotCancellable`	`CANCEL QUERY` named a statement that cannot be stopped now, usually because it is a write, a schema change, or a statement that has not finished parsing.
`CADB0553`	`QueryOwnerUnreachable`	The node that may own the query id did not answer before the cancel timeout. The query may still be running; retry the cancel if needed.
`CADB0554`	`QueryCancelled`	A statement was stopped by `CANCEL QUERY`. Rows already returned to the client before this error were real rows.
`CADB0555`	`LockNotAvailable`	FOR UPDATE NOWAIT met a held row. HTTP 409 / gRPC ABORTED; not automatically retried.
`CADB0556`	`ResultSetTooLarge`	A buffered result exceeded its row or estimated-memory cap. The statement rolls back; reduce the result or batch size. HTTP 400 / gRPC RESOURCE_EXHAUSTED.
`CADB0557`	`StatementTooLarge`	Inline SQL exceeded max_statement_bytes before parsing. HTTP 413 / gRPC INVALID_ARGUMENT.
`CADB0558`	`ConcurrencyLimitExceeded`	The node reached its explicit-transaction or cluster-activity fan-out cap. Back off before retrying. HTTP 503 / gRPC RESOURCE_EXHAUSTED.
`CADB0559`	`JsonbValueCorrupt`	Stored `JSONB` bytes do not decode. This means damaged data or a value written by a newer build. The statement fails and returns no partial document. HTTP 500.
`CADB0600`	`InvalidConfig`	Configuration is invalid: an explicit `--config` or `CAMUS_CONFIG_PATH` file does not exist, the mode is wrong, a listener or Raft port is invalid, peer lists are malformed, schema-ack settings are invalid, transaction/locking/priority settings are invalid, prepared-statement settings are invalid, statistics, automatic-analyze, row-level TTL, spill, large-value, diagnostics, parser-cache, or regex settings are invalid, config keys are unknown, or `kahuna` options are unsupported. Also raised at runtime when a `SET CLUSTER SETTING` value breaks a cross-field invariant; the message names both settings, and nothing is applied.

Backup and restore errors

Only the backup and point-in-time recovery administration API raises CADB07xx codes. Each code maps to a specific HTTP status. See Backup And Restore for the full reference.

Code	Name	When it is generated
`CADB0700`	`BackupNotConfigured`	A backup or restore was requested but `kahuna.backup_dir` is unset. Backups are opt-in.
`CADB0701`	`BackupChainInvalid`	A backup chain does not start at a full backup, has a gap or broken parent link, or contains a cycle.
`CADB0702`	`BackupNeedsFullBackup`	An incremental backup's parent fell below the retention floor, so no contiguous increment is possible.
`CADB0703`	`RestorePointOutOfWindow`	The requested restore point lies outside the chain's recoverable coverage.
`CADB0704`	`RestoreFailed`	A restore failed while copying the base image or replaying the write-ahead log (WAL).
`CADB0705`	`BackupParentMissing`	The parent backup named by an incremental request does not exist.
`CADB0706`	`BackupCorruptArtifact`	An artifact is missing, truncated, extra, duplicated, or fails its recorded digest.
`CADB0707`	`RestoreTargetConflict`	The restore destination already exists or overlaps the live data root, the backup root, or another job's target.
`CADB0708`	`BackupExactCheckpointUnavailable`	The storage backend cannot produce an exact as-of checkpoint at the requested cut.
`CADB0709`	`BackupUnsupportedFormat`	A manifest or artifact is in a legacy or unsupported format.
`CADB070A`	`BackupRetryableLeadershipLoss`	Partition leadership was lost mid-operation. Nothing durable was applied.
`CADB070B`	`BackupCancelled`	The caller cancelled the operation.
`CADB070C`	`RemoteRestoreDisabled`	No `kahuna.restore_root` is configured and the unconfined opt-in is off.
`CADB070D`	`BackupTopologyChanged`	Cluster topology changed during a coordinated backup, so the captured partition set is not one consistent cut. Nothing was published.
`CADB070E`	`BackupNotCoordinator`	A coordinated backup was requested on a node that does not lead the backup meta partition.
`CADB070F`	`BackupInsecureRoot`	The backup or restore root is a symlink, or is group- or world-writable.
`CADB0710`	`PitrBootstrapFailed`	A joining node could not seed itself from a restored backup chain. The restored data root may be missing, its WAL may not be empty, the chain or MAC may be invalid, or the seeded point may be outside the leader's retained log window.

C# extension errors

These codes cover extension assembly loading and code invoked through custom functions, triggers, and procedures. See C# Extensions for deployment and transaction behavior.

Code	Name	When it is generated
`CADB0800`	`ExtensionPathInvalid`	An extension path is relative, empty, or listed more than once.
`CADB0801`	`ExtensionFileNotFound`	A configured extension file does not exist.
`CADB0802`	`ExtensionNotAnAssembly`	The configured file is not a loadable .NET assembly.
`CADB0803`	`ExtensionContractMismatch`	The extension was built against a newer contract than the server supports.
`CADB0804`	`ExtensionDuplicateAssembly`	Two configured files declare the same extension name and version.
`CADB0805`	`ExtensionDuplicateMember`	A member name collides with a built-in or is defined twice in one extension.
`CADB0806`	`ExtensionVerificationFailed`	A safe extension uses an API or assembly that its trust policy does not allow.
`CADB0807`	`ExtensionAssemblyRefused`	A safe extension attempted to load a disallowed assembly at runtime.
`CADB0808`	`ExtensionInvalidSignature`	A function, trigger, or procedure has a shape CamusDB cannot bind.
`CADB0809`	`ExtensionFunctionFailed`	A scalar, table, or aggregate extension function threw an exception.
`CADB0810`	`ExtensionValueOutOfRange`	A CamusDB `NUMERIC` does not fit a .NET `decimal`, or a returned value exceeds the CamusDB range.
`CADB0811`	`TriggerTypeNotFound`	`CREATE TRIGGER` names a CLR type that no installed extension provides.
`CADB0812`	`TriggerTypeAmbiguous`	More than one installed extension provides the named trigger type.
`CADB0813`	`TriggerTypeInvalid`	The named type does not implement the trigger contract.
`CADB0814`	`TriggerAlreadyExists`	The table already has a trigger with that name.
`CADB0815`	`TriggerNotFound`	`DROP TRIGGER` names a trigger the table does not have.
`CADB0816`	`TriggerTargetInvalid`	A trigger targets a view, materialized view, or another unsupported object.
`CADB0817`	`TriggerBindingMismatch`	The installed version of a trigger's extension does not define its CLR type.
`CADB0818`	`TriggerFailed`	Trigger code threw and the statement was rolled back.
`CADB0819`	`ExtensionNestingTooDeep`	Nested triggers and procedures exceeded 16 levels.
`CADB0820`	`ExtensionStatementRefused`	Extension SQL attempted DDL, transaction control, or another unsupported statement.
`CADB0821`	`ProcedureNotFound`	`CALL` names no procedure in the installed extensions.
`CADB0822`	`ProcedureFailed`	Procedure code threw and all changes made by the call were rolled back.
`CADB0823`	`ExtensionCaughtSqlError`	Extension code caught a nested SQL failure, but the transaction is rollback-only.
`CADB0824`	`TransactionRollbackOnly`	A statement failed and aborted the transaction. Later statements are refused; COMMIT rolls it back. See Failed statements.
`CADB0825`	`TriggerMutationConflict`	A `BEFORE` trigger changed a row the outer statement had already read and was still writing.
`CADB0826`	`TriggerQueueTooLarge`	Rows retained for `AFTER` triggers exceeded `spill_threshold_bytes`.
`CADB0827`	`ExtensionManifestInvalid`	An extension assembly has no manifest or an invalid name, version, or requirement.
`CADB0828`	`ExtensionNotAvailable`	The requested extension or version is not loaded on this node.
`CADB0829`	`ExtensionAlreadyInstalled`	The extension is already installed in this database.
`CADB0830`	`ExtensionNotInstalled`	The extension is not installed, including a loaded extension used by `CREATE TRIGGER`.
`CADB0831`	`ExtensionRequirementMissing`	A required extension is not installed in the database.
`CADB0832`	`ExtensionMemberConflict`	Another installed extension defines the same scalar, table-function, aggregate, or procedure name.
`CADB0833`	`ExtensionHasDependents`	Dependent extensions or objects prevent a drop, or the target version lacks a member in use.
`CADB0834`	`ExtensionNotLoadedOnNode`	This node does not load the installed name, version, and SHA-256; statements using that extension fail.
`CADB0835`	`ExtensionClusterMismatch`	A responding cluster node does not load the target build for an install or update.
`CADB0836`	`TriggerRowMappingInvalid`	A typed trigger row class does not fit its table; the message lists the mapping problems.

Corruption and internal-state errors

These codes usually report storage corruption, inconsistent schema metadata, or an unexpected engine state. They rarely point to an ordinary application mistake.

Code	Name	When it is generated
`CADB0014`	`SystemSpaceCorrupt`	CamusDB cannot decode or trust internal metadata, row payloads, schema blobs, index metadata, registry entries, or other persisted system structures.
`CADB0015`	`TableCorrupt`	Reserved for table-level corruption detection. It is defined in the core list but is not commonly surfaced by the current code path.
`CADB0017`	`InvalidIndexLayout`	Reserved for invalid persisted index layout or index metadata shape. It is defined but not commonly surfaced by the current runtime path.
`CADB00297`	`InvalidPageOffset`	Reserved for invalid low-level page offsets in storage structures. Not commonly surfaced by the current KV-backed runtime path.
`CADB0096`	`InvalidInformationSchema`	Reserved for invalid information-schema state. Defined, but not commonly thrown in the current public execution path.
`CADB0097`	`InvalidPageLength`	Reserved for invalid low-level page lengths in storage structures.
`CADB0098`	`InvalidPageChecksum`	Reserved for low-level page checksum mismatches.
`CADB0099`	`InvalidInternalOperation`	CamusDB reached an unexpected internal state: impossible planner state, invalid replicated index shape, row disappearance during update, unexpected forwarder response, or other invariants that should not fail in normal use.
`CADB0540`	`LargeValueCorrupt`	A compressed or out-of-line value failed to decompress or did not match the checksum recorded in the row.
`CADB0541`	`LargeValueNotResolved`	An internal read path attempted to decode an out-of-line value that was not fetched first. Report it.
`CADB0837`	`StorageCorrupted`	The storage engine reports damage. HTTP 500 / gRPC DATA_LOSS. Not retryable; never interpret it as an empty result. See storage health.

Retry guidance

You can usually retry after these codes:

CADB0502 TransactionConflict
CADB0503 SchemaCatchingUp
CADB0504 TransactionMustRetry
CADB0505 TransactionLifetimeExceeded
CADB0516 AuthenticationFailed after obtaining fresh credentials
CADB0518 TooManyAuthAttempts after waiting for the rate-limit window
CADB0520 UnknownPreparedStatement after preparing the statement again
CADB0532 RefreshAlreadyInProgress once the running refresh finishes
CADB0534 ConcurrentSchemaChange after re-reading the current definition
CADB0535 SequenceUnavailable once the partition's election settles
CADB0536 InsufficientDiskSpace after freeing disk space or lowering the threshold
CADB070A BackupRetryableLeadershipLoss once a leader is elected
CADB070D BackupTopologyChanged once cluster membership is stable

CADB0509 TransactionFinalizeUnresolved needs a different kind of retry: send the same COMMIT or ROLLBACK again for the same transaction id. Do not start a new transaction or replay the statements, because the original commit may already have succeeded on the server.

These codes usually mean you must change the request before you retry:

CADB0010 DatabaseDoesntExist
CADB0012 DatabaseAlreadyExists
CADB0018 DatabaseNameReserved
CADB0400 InvalidInput
CADB0404 UnknownColumn
CADB0406 SqlSyntaxError
CADB0408 SchemaLimitExceeded
CADB0409 InvalidAsOfSystemTime
CADB0410 MalformedVector
CADB0411 VectorDimensionMismatch
CADB0412 InvalidVectorValue
CADB0413 StatementTooDeeplyNested
CADB0300 DuplicateUniqueKeyValue
CADB0301 NotNullViolation
CADB0302 ValueTooLong
CADB0303 CheckConstraintViolation
CADB0506 TransactionMutationLimitExceeded
CADB0507 SpillStorageUnavailable
CADB0508 DatabaseHasLiveDescendants
CADB0510 OrphanNotFound
CADB0511 CommentTooLong
CADB0512 UserAlreadyExists
CADB0513 UserDoesNotExist
CADB0514 UnsupportedAuthPlugin
CADB0515 InvalidPrivilege
CADB0517 InsufficientPrivilege
CADB0519 InsecureTransport
CADB0521 PreparedStatementLimitExceeded
CADB0522 AnalyzeRequiresNoPendingWrites
CADB0523 ViewDoesntExist
CADB0524 ViewAlreadyExists
CADB0525 ViewNotUpdatable
CADB0526 ViewColumnNotUpdatable
CADB0527 ViewCheckOptionViolated
CADB0528 ViewRecursionDetected
CADB0529 CannotChangeViewShape
CADB0530 DependentObjectsExist
CADB0531 MaterializedViewNotPopulated
CADB0533 FeatureNotSupported
CADB0537 SnapshotPrecedesContentsGeneration
CADB0538 StatementNotAllowedInTransaction
CADB0539 BranchSnapshotProtectionLost
CADB0700 BackupNotConfigured
CADB0702 BackupNeedsFullBackup
CADB0703 RestorePointOutOfWindow
CADB0705 BackupParentMissing
CADB0707 RestoreTargetConflict
CADB070C RemoteRestoreDisabled
CADB070E BackupNotCoordinator

These codes usually need an operator to investigate. Retrying without that investigation rarely helps:

CADB0014 SystemSpaceCorrupt
CADB0099 InvalidInternalOperation
CADB0701 BackupChainInvalid
CADB0704 RestoreFailed
CADB0706 BackupCorruptArtifact
CADB070F BackupInsecureRoot

How to read them​

Common user-facing errors​

Backup and restore errors​

C# extension errors​

Corruption and internal-state errors​

Retry guidance​

Related pages​