Enum SqliteLimit 

#[non_exhaustive]
pub enum SqliteLimit {
    Length,
    SqlLength,
    ColumnCount,
    ExprDepth,
    CompoundSelect,
    VdbeOp,
    FunctionArg,
    Attached,
    LikePatternLength,
    VariableNumber,
    TriggerDepth,
    WorkerThreads,
}

Available on crate feature __sqlite-shared only.

SQLite resource limits that can be configured per-connection.

These control aspects of SQLite’s behavior and can be used to prevent resource exhaustion or limit query complexity.

Each variant exposes two associated constants: DEFAULT_*_LIMIT (SQLite’s documented default) and SAFE_*_LIMIT (the hardened value applied by SqliteConnection::set_recommended_security_limits). A connection’s actual runtime default can differ from DEFAULT_*_LIMIT because some builds raise the compile-time maximum (for example the bundled libsqlite3-sys raises FunctionArg and VariableNumber).

See the SQLite documentation for details.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Length

Maximum length of any string or BLOB or table row, in bytes.

See DEFAULT_LENGTH_LIMIT and SAFE_LENGTH_LIMIT.

SqlLength

Maximum length of an SQL statement, in bytes.

See DEFAULT_SQL_LENGTH_LIMIT and SAFE_SQL_LENGTH_LIMIT.

ColumnCount

Maximum number of columns in a table definition, result set, or index, and also the maximum number of columns in the ORDER BY or GROUP BY clauses.

See DEFAULT_COLUMN_COUNT_LIMIT and SAFE_COLUMN_COUNT_LIMIT.

ExprDepth

Maximum depth of the parse tree for any expression.

This can help prevent stack overflow from deeply nested expressions.

See DEFAULT_EXPR_DEPTH_LIMIT and SAFE_EXPR_DEPTH_LIMIT.

CompoundSelect

Maximum number of terms in a compound SELECT statement.

See DEFAULT_COMPOUND_SELECT_LIMIT and SAFE_COMPOUND_SELECT_LIMIT.

VdbeOp

Maximum number of instructions in a virtual machine program used to implement an SQL statement.

If sqlite3_prepare_v2() or the equivalent tries to allocate space for more than this many opcodes in a single prepared statement, an SQLITE_NOMEM error is returned.

See DEFAULT_VDBE_OP_LIMIT and SAFE_VDBE_OP_LIMIT.

FunctionArg

Maximum number of arguments on a function.

See DEFAULT_FUNCTION_ARG_LIMIT and SAFE_FUNCTION_ARG_LIMIT.

Attached

Maximum number of attached databases.

See DEFAULT_ATTACHED_LIMIT and SAFE_ATTACHED_LIMIT.

LikePatternLength

Maximum length of the pattern argument to the LIKE or GLOB operators.

See DEFAULT_LIKE_PATTERN_LENGTH_LIMIT and SAFE_LIKE_PATTERN_LENGTH_LIMIT.

VariableNumber

Maximum index number of any parameter in an SQL statement.

See DEFAULT_VARIABLE_NUMBER_LIMIT and SAFE_VARIABLE_NUMBER_LIMIT.

TriggerDepth

Maximum recursion depth of triggers.

See DEFAULT_TRIGGER_DEPTH_LIMIT and SAFE_TRIGGER_DEPTH_LIMIT.

WorkerThreads

Maximum number of auxiliary worker threads that a single prepared statement may start.

See DEFAULT_WORKER_THREADS_LIMIT and SAFE_WORKER_THREADS_LIMIT.

Implementations

impl SqliteLimit

pub const DEFAULT_LENGTH_LIMIT: i32 = 1_000_000_000

SQLite’s default for Length.

pub const SAFE_LENGTH_LIMIT: i32 = 1_000_000

Hardened value for Length.

pub const DEFAULT_SQL_LENGTH_LIMIT: i32 = 1_000_000_000

SQLite’s default for SqlLength.

pub const SAFE_SQL_LENGTH_LIMIT: i32 = 100_000

Hardened value for SqlLength.

pub const DEFAULT_COLUMN_COUNT_LIMIT: i32 = 2_000

SQLite’s default for ColumnCount.

pub const SAFE_COLUMN_COUNT_LIMIT: i32 = 100

Hardened value for ColumnCount.

pub const DEFAULT_EXPR_DEPTH_LIMIT: i32 = 1_000

SQLite’s default for ExprDepth.

pub const SAFE_EXPR_DEPTH_LIMIT: i32 = 10

Hardened value for ExprDepth.

pub const DEFAULT_COMPOUND_SELECT_LIMIT: i32 = 500

SQLite’s default for CompoundSelect.

pub const SAFE_COMPOUND_SELECT_LIMIT: i32 = 3

Hardened value for CompoundSelect.

pub const DEFAULT_VDBE_OP_LIMIT: i32 = 250_000_000

SQLite’s default for VdbeOp.

pub const SAFE_VDBE_OP_LIMIT: i32 = 25_000

Hardened value for VdbeOp.

pub const DEFAULT_FUNCTION_ARG_LIMIT: i32 = 127

SQLite’s default for FunctionArg.

pub const SAFE_FUNCTION_ARG_LIMIT: i32 = 8

Hardened value for FunctionArg.

pub const DEFAULT_ATTACHED_LIMIT: i32 = 10

SQLite’s default for Attached.

pub const SAFE_ATTACHED_LIMIT: i32 = 0

Hardened value for Attached.

pub const DEFAULT_LIKE_PATTERN_LENGTH_LIMIT: i32 = 50_000

SQLite’s default for LikePatternLength.

pub const SAFE_LIKE_PATTERN_LENGTH_LIMIT: i32 = 50

Hardened value for LikePatternLength.

pub const DEFAULT_VARIABLE_NUMBER_LIMIT: i32 = 32_766

SQLite’s published default for VariableNumber.

A particular build may compile a different maximum. The default libsqlite3-sys bundle sets SQLITE_MAX_VARIABLE_NUMBER=250000, so a connection’s runtime default can exceed this published value.

pub const SAFE_VARIABLE_NUMBER_LIMIT: i32 = 10

Hardened value for VariableNumber.

pub const DEFAULT_TRIGGER_DEPTH_LIMIT: i32 = 1_000

SQLite’s default for TriggerDepth.

pub const SAFE_TRIGGER_DEPTH_LIMIT: i32 = 10

Hardened value for TriggerDepth.

pub const DEFAULT_WORKER_THREADS_LIMIT: i32 = 0

SQLite’s default for WorkerThreads.

pub const SAFE_WORKER_THREADS_LIMIT: i32 = 0

Hardened value for WorkerThreads, equal to its default, so the recommended setter leaves it untouched.

Trait Implementations

impl Clone for SqliteLimit

fn clone(&self) -> SqliteLimit

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for SqliteLimit

impl Debug for SqliteLimit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for SqliteLimit

impl Hash for SqliteLimit

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SqliteLimit

fn eq(&self, other: &SqliteLimit) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for SqliteLimit