Struct ColumnMeta 

pub struct ColumnMeta {
    pub index: usize,
    pub sql_type: i32,
    pub sub_type: i32,
    pub scale: i32,
    pub length: i32,
    pub nullable: bool,
    pub field: String,
    pub relation: String,
    pub alias: String,
    pub owner: String,
}

Metadados que descrevem uma coluna da saída de uma instrução preparada (ou um de seus parâmetros de entrada).

Fields

index: usize

Posição na mensagem, começando em zero.

sql_type: i32

Tipo SQL base (SQL_*, com o bit anulável removido).

sub_type: i32

Sub-tipo Firebird. Para texto pode indicar charset; para BLOB indica o sub-tipo do BLOB.

scale: i32

Escala de tipos numéricos (NUMERIC/DECIMAL); valores negativos indicam casas decimais.

length: i32

Comprimento declarado em bytes (CHAR/VARCHAR) ou largura do tipo.

nullable: bool

Verdadeiro se a coluna ou parâmetro aceita NULL.

field: String

Nome subjacente da coluna.

relation: String

Nome da relação/tabela de origem, quando o servidor informa.

alias: String

Alias de saída (o nome que a lista SELECT deu a ela).

owner: String

Dono da relação de origem, quando o servidor informa.

Implementations

impl ColumnMeta

pub fn name(&self) -> &str

O nome que os chamadores veem para esta coluna (alias se presente, senão field).

Examples found in repository

examples/dump.rs (line 40)

fn main() -> Result<()> {
    let cfg = ConnectConfig::new()
        .host(std::env::var("FB_HOST").unwrap_or_else(|_| "127.0.0.1".into()))
        .port(
            std::env::var("FB_PORT")
                .ok()
                .and_then(|p| p.parse().ok())
                .unwrap_or(3555),
        )
        .database(std::env::var("FB_DB").unwrap_or_else(|_| "employee".into()))
        .user(std::env::var("FB_USER").unwrap_or_else(|_| "SYSDBA".into()))
        .password(std::env::var("FB_PASSWORD").expect("set FB_PASSWORD"))
        .wire_crypt(WireCrypt::Enabled);

    let mut conn = Connection::connect(&cfg)?;
    println!("conectado: protocolo v{}", conn.protocol_version());
    let tx = conn.begin()?;

    let sql = "SELECT emp_no, first_name FROM employee WHERE emp_no = 2";
    let stmt = conn.prepare(&tx, sql)?;
    println!(
        "\nstmt_type={} colunas={}",
        stmt.stmt_type(),
        stmt.columns().len()
    );
    for c in stmt.columns() {
        println!(
            "  [{}] name={:?} field={:?} relation={:?} alias={:?} owner={:?} type={} sub={} scale={} len={}",
            c.index,
            c.name(),
            c.field,
            c.relation,
            c.alias,
            c.owner,
            c.sql_type,
            c.sub_type,
            c.scale,
            c.length
        );
    }

    stmt.drop_statement(&mut conn)?;
    tx.commit(&mut conn)?;
    conn.close()?;
    Ok(())
}

Trait Implementations

impl Clone for ColumnMeta

fn clone(&self) -> ColumnMeta

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColumnMeta

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

Formats the value using the given formatter.

impl Default for ColumnMeta

fn default() -> ColumnMeta

Returns the “default value” for a type.