Struct ConnectConfig 

pub struct ConnectConfig {

    pub host: String,
    pub port: u16,
    pub database: String,
    pub user: String,
    pub password: String,
    pub role: Option<String>,
    pub charset: String,
    pub dialect: i32,
    pub wire_crypt: WireCrypt,
    pub connect_timeout: Option<Duration>,
    pub page_size: Option<i32>,
    pub timezone: Option<String>,
    pub parallel_workers: Option<i32>,
    pub native_data_types: bool,
}

Tudo o que é necessário para abrir uma conexão com um servidor Firebird.

Fields

host: String

Nome ou IP do servidor Firebird.

port: u16

Porta TCP do servidor Firebird. O padrão do Firebird é 3050.

database: String

Caminho ou alias do banco de dados no servidor (ex.: employee ou /data/db.fdb).

user: String

Nome do usuário Firebird.

password: String

Senha do usuário Firebird.

role: Option<String>

Papel SQL opcional usado na conexão (ROLE).

charset: String

Charset da conexão (padrão UTF8).

dialect: i32

Dialeto SQL (padrão 3).

wire_crypt: WireCrypt

Política de criptografia da comunicação.

connect_timeout: Option<Duration>

Timeout de TCP + handshake.

page_size: Option<i32>

Tamanho da página para crate::Connection::create_database.

timezone: Option<String>

Fuso horário da sessão (FB4+), ex.: America/Sao_Paulo.

parallel_workers: Option<i32>

Número de workers paralelos para a conexão (FB5).

native_data_types: bool

Quando true, emite SET BIND OF INT128/DECFLOAT/TIME ZONE TO NATIVE logo após o attach (FB4+). Útil quando o servidor está com DataTypeCompatibility ligado e coage esses tipos para os legados — assim eles voltam como Int128/DecFloat/TimeTz em vez de aproximações.

Implementations

impl ConnectConfig

pub fn new() -> Self

Começa a partir dos padrões (localhost:3050, usuário SYSDBA, UTF8, dialeto 3).

Examples found in repository

examples/dump.rs (line 12)

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(())
}

pub fn host(self, host: impl Into<String>) -> Self

Define o host ou IP do servidor Firebird.

Examples found in repository

examples/dump.rs (line 13)

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(())
}

pub fn port(self, port: u16) -> Self

Define a porta TCP do servidor Firebird.

Examples found in repository

examples/dump.rs (lines 14-19)

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(())
}

pub fn database(self, db: impl Into<String>) -> Self

Define o banco por alias ou caminho no servidor.

Examples found in repository

examples/dump.rs (line 20)

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(())
}

pub fn user(self, user: impl Into<String>) -> Self

Define o usuário Firebird.

Examples found in repository

examples/dump.rs (line 21)

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(())
}

pub fn password(self, password: impl Into<String>) -> Self

Define a senha do usuário Firebird.

Examples found in repository

examples/dump.rs (line 22)

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(())
}

pub fn role(self, role: impl Into<String>) -> Self

Define o papel SQL (ROLE) usado após o login.

pub fn charset(self, charset: impl Into<String>) -> Self

Define o charset da conexão, como UTF8, WIN1252 ou ISO8859_1.

pub fn dialect(self, dialect: i32) -> Self

Define o dialeto SQL. Use 3 para bancos modernos.

pub fn wire_crypt(self, wc: WireCrypt) -> Self

Define se a comunicação deve ser criptografada, quando disponível ou obrigatoriamente.

Examples found in repository

examples/dump.rs (line 23)

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(())
}

pub fn connect_timeout(self, t: Duration) -> Self

Define o tempo máximo para abrir o socket TCP e completar o handshake.

pub fn page_size(self, size: i32) -> Self

Define o tamanho de página ao criar um banco novo com crate::Connection::create_database.

pub fn timezone(self, tz: impl Into<String>) -> Self

Define o fuso horário da sessão, por exemplo America/Sao_Paulo.

pub fn parallel_workers(self, n: i32) -> Self

Define o número de workers paralelos solicitado ao servidor Firebird 5.

pub fn native_data_types(self, on: bool) -> Self

Pede os tipos nativos (INT128/DECFLOAT/WITH TIME ZONE) após o attach. Veja ConnectConfig::native_data_types.

Trait Implementations

impl Clone for ConnectConfig

fn clone(&self) -> ConnectConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConnectConfig

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

Formats the value using the given formatter.

impl Default for ConnectConfig

fn default() -> Self

Returns the “default value” for a type.