Enum Request 

pub enum Request {
    Hello {
        min_version: u32,
        max_version: u32,
        core_version: String,
        plugin: Option<PluginId>,
    },
    Describe {},
    Validate {
        options: Map<String, Value>,
        template: Option<Value>,
    },
    ValidateConnection {
        connection: Map<String, Value>,
        unresolved: Vec<String>,
    },
    Open {
        connection: Map<String, Value>,
        read_only: bool,
        sandbox: bool,
    },
    Execute {
        sql: String,
        row_limit: Option<u64>,
    },
    Check {
        sql: String,
    },
    Catalog {
        tables: Vec<String>,
        schemas: Vec<String>,
    },
    Write {
        path: String,
        format: String,
        options: Map<String, Value>,
        result_sets: Vec<ResultSetMeta>,
        font_requests: bool,
        template: Option<Value>,
    },
    Fonts {
        paths: Vec<String>,
        error: Option<String>,
        repeated: bool,
    },
    ResultSetEnd {},
    Finish {},
    Deliver {
        local_path: Option<String>,
        remote_path: Option<String>,
        files: Vec<DeliveryFile>,
        connection: Map<String, Value>,
        options: Map<String, Value>,
        message: Option<Message>,
    },
    Load {
        name: String,
    },
    Close {},
    Cancel {},
}

Core → plugin.

Variants

Hello

Always first. The plugin picks a version in both ranges or replies version_mismatch.

Fields

min_version: u32

max_version: u32

core_version: String

plugin: Option<PluginId>

The plugin core wants served, for an executable that provides several. A package that doesn’t provide it replies error; without it, the package serves its first.

Describe

Describe the connection fields a profile output for this plugin takes (used by dre init) and the options a report’s config block for it takes.

Validate

Check one config block of options (a format’s output: keys, a destination entry’s keys) without doing anything. Replies validated.

Fields

options: Map<String, Value>

template: Option<Value>

Format: what the plugin needs to check the output’s template too. For the html and pdf formats, {"file": <absolute path or null>, "project_root", "queries": [...]}. Optional; older plugins ignore it.

ValidateConnection

Source or destination (protocol 1): check a profile entry’s connection settings without connecting: the declared fields’ generic checks, then the plugin’s own rules. Keys in unresolved (an unset env_var()) arrive as null and count as set, unchecked. Replies validated, with warnings for unknown keys.

Fields

connection: Map<String, Value>

unresolved: Vec<String>

Open

Source: open a session. All later execute/check requests run on it.

Fields

connection: Map<String, Value>

read_only: bool

sandbox: bool

Core’s dre query: the session must not reach files, programs or the network beyond the database (protocol 1, optional; older plugins ignore it).

Execute

Source: run one statement. Replies result (then Arrow frames, then result_end) or no_result.

Fields

sql: String

row_limit: Option<u64>

Check

Source: verify one statement without executing it. Replies ok or error.

Fields

sql: String

Catalog

Source advertising catalog: discover accessible relations through native metadata.

Fields

tables: Vec<String>

schemas: Vec<String>

Write

Format: write result sets to path. Followed, per result set, by Arrow frames (at least one, carrying the schema) and a result_set_end, then finish. Replies written.

Fields

path: String

format: String

options: Map<String, Value>

result_sets: Vec<ResultSetMeta>

font_requests: bool

Core can answer need_fonts during this write. Absent on older cores.

template: Option<Value>

Fonts

Reply to a font request within a write; retains the write request id. repeated is set when core already gave this font’s error earlier in the run, so the person has been told once and the format needn’t warn again.

Fields

paths: Vec<String>

error: Option<String>

repeated: bool

ResultSetEnd

Finish

Deliver

Destination: deliver a local file, or with files (only to a plugin advertising multi_file) every file of one output at once. Exactly one of local_path/files is set, unless message is: then files (possibly empty) holds the files to attach to it, and is sent only to a plugin advertising message. options are the destination entry’s plugin options, rendered by core. Replies delivered.

Fields

local_path: Option<String>

remote_path: Option<String>

files: Vec<DeliveryFile>

connection: Map<String, Value>

options: Map<String, Value>

message: Option<Message>

Load

Source: load rows into a temporary table on the session, named after name. Followed by Arrow frames (at least one, carrying the schema) and a result_set_end. Replies loaded. Only sent to plugins advertising load.

Fields

name: String

Close

End the conversation; the plugin exits 0.

Cancel

Protocol 1: stop the request whose id the envelope carries. It has no reply of its own: the request replies error with kind cancelled, or its usual reply if it finished first. A cancel for a request that isn’t running is ignored.

Trait Implementations

impl Clone for Request

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Request

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Request

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Request

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Request

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Request

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Request