Go nativo · Qualquer servidor Chargewire · licença Apache-2.0

    O driver ADBC Chargewire

    Um driver genérico para o protocolo Chargewire: ele se comunica com qualquer servidor que implemente o Chargewire 1.0, não com um banco de dados específico. Um núcleo em Go com bindings para Python atende Python, Go, R, C/C++, Rust e outros clientes ADBC.

    Arrow de ponta a ponta

    Os resultados chegam do servidor como Arrow IPC direto em uma pyarrow Table, em um RecordReader do Go ou em qualquer outro consumidor ADBC, sem conversão linha a linha.

    Feito para redes reais

    Downloads retomáveis, novas tentativas seguras com chaves de idempotência, envio, consulta de estado e leitura assíncronos para consultas longas atrás de proxies, e renovação de tokens. Um cancelamento interrompe a instrução no servidor.

    TLS por padrão

    O TLS é verificado, a menos que você o desligue, e as credenciais nunca vão no URI. TLS mútuo, troca de tokens para SSO e login pelo navegador funcionam onde o servidor os oferece.

    Uma API C. Todas as linguagens.

    Os exemplos desta página estão em Python, mas ADBC expõe cada driver como uma biblioteca compartilhada compatível com C — o mesmo núcleo nativo funciona em Go, Rust, Java, C#, C/C++, JavaScript e outras linguagens. Um driver para toda arquitetura.

    PythonGoRustJavaC#C / C++JavaScriptRRubyKotlin
    Saiba mais sobre Apache Arrow ADBC

    Instale e consulte

    Instale o pacote Python, defina o URI e as credenciais do servidor no ambiente e leia os resultados como uma tabela Arrow.

    pip install adbc-driver-chargewire
    1import os
    2from adbc_driver_chargewire import dbapi
    3
    4with dbapi.connect(
    5    uri=os.environ["CHARGEWIRE_URI"],
    6    username=os.environ["CHARGEWIRE_USERNAME"],
    7    password=os.environ["CHARGEWIRE_PASSWORD"],
    8) as conn, conn.cursor() as cur:
    9    cur.execute(operation="SELECT 42 AS answer, ? AS greeting", parameters=["hello"])
    10    print(cur.fetch_arrow_table())

    CHARGEWIRE_URI é chargewire://host:port: HTTPS, com o protocolo em /chargewire. Acrescente ?tls=false apenas para um servidor local de desenvolvimento.

    Carregue dados com ingestão em massa

    A ingestão em massa recebe um leitor Arrow, então os lotes são enviados à medida que são produzidos. Este exemplo cria a tabela; mode="append" carrega em uma tabela existente.

    1import os
    2import pyarrow as pa
    3from adbc_driver_chargewire import dbapi
    4
    5schema = pa.schema([("id", pa.int64()), ("amount", pa.float64())])
    6
    7def batches():
    8    for start in range(0, 4000, 1000):
    9        yield pa.record_batch(
    10            [pa.array(range(start, start + 1000), type=pa.int64()),
    11             pa.array([12.50] * 1000, type=pa.float64())],
    12            schema=schema,
    13        )
    14
    15with dbapi.connect(
    16    uri=os.environ["CHARGEWIRE_URI"],
    17    username=os.environ["CHARGEWIRE_USERNAME"],
    18    password=os.environ["CHARGEWIRE_PASSWORD"],
    19) as conn, conn.cursor() as cur:
    20    with pa.RecordBatchReader.from_batches(schema, batches()) as reader:
    21        rows = cur.adbc_ingest(table_name="orders", data=reader, mode="create")
    22    conn.commit()
    23    print(f"Loaded {rows:,} rows")

    Em Go

    Programas em Go usam o driver diretamente, sem gerenciador de drivers.

    go get github.com/gizmodata/chargewire-adbc/go/v2
    package main
    
    import (
    	"context"
    	"fmt"
    	"log"
    	"os"
    
    	"github.com/apache/arrow-go/v18/arrow/memory"
    	"github.com/gizmodata/chargewire-adbc/go/v2/chargewire"
    )
    
    func main() {
    	ctx := context.Background()
    	drv := chargewire.NewDriver(memory.DefaultAllocator)
    	db, err := drv.NewDatabaseWithContext(ctx, map[string]string{
    		"uri":      os.Getenv("CHARGEWIRE_URI"),
    		"username": os.Getenv("CHARGEWIRE_USERNAME"),
    		"password": os.Getenv("CHARGEWIRE_PASSWORD"),
    	})
    	if err != nil {
    		log.Fatal(err)
    	}
    	defer db.Close(ctx)
    
    	cnxn, err := db.Open(ctx)
    	if err != nil {
    		log.Fatal(err)
    	}
    	defer cnxn.Close(ctx)
    
    	stmt, err := cnxn.NewStatement(ctx)
    	if err != nil {
    		log.Fatal(err)
    	}
    	defer stmt.Close(ctx)
    	if err := stmt.SetSqlQuery(ctx, "SELECT 42 AS answer"); err != nil {
    		log.Fatal(err)
    	}
    	reader, _, err := stmt.ExecuteQuery(ctx)
    	if err != nil {
    		log.Fatal(err)
    	}
    	defer reader.Release()
    	for reader.Next() {
    		fmt.Println(reader.RecordBatch().Column(0)) // [42]
    	}
    }

    C/C++, R, Rust e outras linguagens

    Uma linha instala a biblioteca do driver e o manifesto de driver, para que todo gerenciador de drivers ADBC do computador o carregue como driver = "chargewire".

    curl https://install.adbc.gizmodata.com/chargewire | sh
    irm https://install.adbc.gizmodata.com/chargewire.ps1 | iex
    Leia a documentação do driver →

    Driver ADBC para Chargewire — perguntas frequentes

    Com quais servidores o driver Chargewire funciona?

    Com qualquer servidor que implemente o protocolo Chargewire, versão 1 (especificação 1.0.0). É um driver genérico, não ligado a um banco de dados, e é testado com o chargewire-duckdb, o servidor de referência, e com o Hardcharger.

    Devo usar o driver Chargewire ou o driver Hardcharger?

    Para o Hardcharger, use o driver Hardcharger: ele é construído sobre este e acrescenta as opções próprias do Hardcharger, como tags de consulta e configurações de sessão, e os URIs hardcharger://. Use o driver Chargewire para qualquer outro servidor Chargewire, ou quando quiser um driver que não esteja ligado a um servidor específico.

    O driver Chargewire é gratuito?

    Sim. É de código aberto, sob Apache-2.0.

    Em quais plataformas ele roda?

    O wheel Python traz o driver para Linux em x86-64 e arm64 (glibc 2.17 ou mais recente), macOS 13 ou mais recente com Apple silicon e Intel, e Windows x64. Cada versão publicada no GitHub também traz a biblioteca compartilhada para Windows Arm64, para as outras linguagens ADBC.

    O que é o Chargewire?

    Um protocolo aberto para SQL sobre HTTP com resultados em Apache Arrow. A página do protocolo é gizmodata.com/chargewire.

    Pronto para mover seus dados?

    Instale o Hardcharger gratuitamente e use drivers ADBC para transmitir sua primeira tabela.

    Agende uma demonstração!Agendamento via Calendly