Enum AuthorizerContext 

#[non_exhaustive]
pub enum AuthorizerContext<'a> {
    CreateIndex(CreateIndex<'a>),
    CreateTable(CreateTable<'a>),
    CreateTempIndex(CreateTempIndex<'a>),
    CreateTempTable(CreateTempTable<'a>),
    CreateTempTrigger(CreateTempTrigger<'a>),
    CreateTempView(CreateTempView<'a>),
    CreateTrigger(CreateTrigger<'a>),
    CreateView(CreateView<'a>),
    Delete(Delete<'a>),
    DropIndex(DropIndex<'a>),
    DropTable(DropTable<'a>),
    DropTempIndex(DropTempIndex<'a>),
    DropTempTable(DropTempTable<'a>),
    DropTempTrigger(DropTempTrigger<'a>),
    DropTempView(DropTempView<'a>),
    DropTrigger(DropTrigger<'a>),
    DropView(DropView<'a>),
    Insert(Insert<'a>),
    Pragma(Pragma<'a>),
    Read(Read<'a>),
    Select(Select<'a>),
    Transaction(Transaction<'a>),
    Update(Update<'a>),
    Attach(Attach<'a>),
    Detach(Detach<'a>),
    AlterTable(AlterTable<'a>),
    Reindex(Reindex<'a>),
    Analyze(Analyze<'a>),
    CreateVTable(CreateVTable<'a>),
    DropVTable(DropVTable<'a>),
    Function(Function<'a>),
    Savepoint(Savepoint<'a>),
    Recursive(Recursive<'a>),
    Unknown(Unknown<'a>),
}

Available on crate feature __sqlite-shared only.

Context information passed to the authorizer callback.

One variant per SQLite action code. Each variant carries the arguments for that action under descriptive field names, so there is no need to consult a table of what each positional argument means. The callback is invoked during SQL statement compilation (not during execution).

Added in SQLite 3.0.0 (June 2004).

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.

CreateIndex(CreateIndex<'a>)

CREATE INDEX

CreateTable(CreateTable<'a>)

CREATE TABLE

CreateTempIndex(CreateTempIndex<'a>)

CREATE TEMP INDEX

CreateTempTable(CreateTempTable<'a>)

CREATE TEMP TABLE

CreateTempTrigger(CreateTempTrigger<'a>)

CREATE TEMP TRIGGER

CreateTempView(CreateTempView<'a>)

CREATE TEMP VIEW

CreateTrigger(CreateTrigger<'a>)

CREATE TRIGGER

CreateView(CreateView<'a>)

CREATE VIEW

Delete(Delete<'a>)

DELETE

DropIndex(DropIndex<'a>)

DROP INDEX

DropTable(DropTable<'a>)

DROP TABLE

DropTempIndex(DropTempIndex<'a>)

DROP TEMP INDEX

DropTempTable(DropTempTable<'a>)

DROP TEMP TABLE

DropTempTrigger(DropTempTrigger<'a>)

DROP TEMP TRIGGER

DropTempView(DropTempView<'a>)

DROP TEMP VIEW

DropTrigger(DropTrigger<'a>)

DROP TRIGGER

DropView(DropView<'a>)

DROP VIEW

Insert(Insert<'a>)

INSERT

Pragma(Pragma<'a>)

PRAGMA

Read(Read<'a>)

Reading a column value.

Select(Select<'a>)

SELECT

Transaction(Transaction<'a>)

Transaction control (BEGIN, COMMIT, ROLLBACK).

Update(Update<'a>)

UPDATE

Attach(Attach<'a>)

ATTACH DATABASE

Detach(Detach<'a>)

DETACH DATABASE

AlterTable(AlterTable<'a>)

ALTER TABLE

Reindex(Reindex<'a>)

REINDEX

Analyze(Analyze<'a>)

ANALYZE

CreateVTable(CreateVTable<'a>)

CREATE VIRTUAL TABLE

DropVTable(DropVTable<'a>)

DROP VIRTUAL TABLE

Function(Function<'a>)

A SQL function call.

Savepoint(Savepoint<'a>)

SAVEPOINT

Recursive(Recursive<'a>)

A recursive SELECT.

Unknown(Unknown<'a>)

An action code this version of diesel does not model.

Implementations

impl<'a> AuthorizerContext<'a>

pub fn is_schema_modifying(&self) -> bool

Returns true if this action modifies the database schema.

Schema-modifying actions include creating, dropping, or altering tables, indexes, triggers, views, and virtual tables.

Example

use diesel::sqlite::{SqliteConnection, AuthorizerContext, AuthorizerDecision};

conn.on_authorize(|ctx| {
    if ctx.is_schema_modifying() {
        AuthorizerDecision::Deny
    } else {
        AuthorizerDecision::Allow
    }
});

Trait Implementations

impl<'a> Clone for AuthorizerContext<'a>

fn clone(&self) -> AuthorizerContext<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for AuthorizerContext<'a>

impl<'a> Debug for AuthorizerContext<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for AuthorizerContext<'a>

impl<'a> PartialEq for AuthorizerContext<'a>

fn eq(&self, other: &AuthorizerContext<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for AuthorizerContext<'a>