Struct Client 

pub struct Client { /* private fields */ }

A Geode database client supporting both QUIC and gRPC transports.

Use the builder pattern to configure the client, then call connect to establish a connection.

Transport Selection

The transport is selected based on the DSN scheme:

• quic:// - QUIC transport (default)
• grpc:// - gRPC transport

Example

use geode_client::Client;

// QUIC transport (legacy API)
let client = Client::new("127.0.0.1", 3141)
    .skip_verify(true)  // Development only!
    .page_size(500)
    .client_name("my-app");

// Or use DSN with explicit transport
let client = Client::from_dsn("quic://127.0.0.1:3141?insecure=true")?;
let client = Client::from_dsn("grpc://127.0.0.1:50051")?;

let mut conn = client.connect().await?;
let (page, _) = conn.query("RETURN 1 AS x").await?;
conn.close()?;

Client configuration for connecting to a Geode server.

The password field uses SecretString from the secrecy crate to ensure credentials are zeroized from memory on drop and not accidentally leaked in debug output or error messages.

Implementations

impl Client

pub fn new(host: impl Into<String>, port: u16) -> Self

Create a new QUIC client for the specified host and port.

This method creates a client using QUIC transport. For gRPC transport, use from_dsn with a grpc:// scheme.

Arguments

• host - The server hostname or IP address
• port - The server port (typically 3141 for Geode)

Example

use geode_client::Client;

let client = Client::new("localhost", 3141);
let client = Client::new("192.168.1.100", 8443);
let client = Client::new(String::from("geode.example.com"), 3141);

pub fn from_dsn(dsn_str: &str) -> Result<Self>

Create a new client from a DSN (Data Source Name) string.

Supported DSN Formats

• quic://host:port?options - QUIC transport (recommended)
• grpc://host:port?options - gRPC transport
• host:port?options - Legacy format (defaults to QUIC)

Supported Options

• tls - Enable/disable TLS (0/1/true/false)
• insecure or skip_verify - Skip TLS verification
• page_size - Results page size (default: 1000)
• client_name or hello_name - Client name
• client_version or hello_ver - Client version
• conformance - GQL conformance level
• username or user - Authentication username
• password or pass - Authentication password

Examples

use geode_client::Client;

// QUIC transport (explicit)
let client = Client::from_dsn("quic://localhost:3141").unwrap();

// gRPC transport
let client = Client::from_dsn("grpc://localhost:50051?tls=0").unwrap();

// Legacy format (defaults to QUIC)
let client = Client::from_dsn("localhost:3141?insecure=true").unwrap();

// With authentication
let client = Client::from_dsn("quic://admin:secret@localhost:3141").unwrap();

// IPv6 support
let client = Client::from_dsn("grpc://[::1]:50051").unwrap();

Errors

Returns Error::InvalidDsn if:

• DSN is empty
• Scheme is unsupported (not quic://, grpc://, or schemeless)
• Host is missing
• Port is invalid

pub fn transport(&self) -> Transport

Get the transport type for this client.

pub fn skip_verify(self, skip: bool) -> Self

Skip TLS certificate verification.

Security Warning

This should only be used in development environments. Disabling certificate verification makes the connection vulnerable to man-in-the-middle attacks.

Arguments

• skip - If true, skip certificate verification

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

Set the page size for query results.

Controls how many rows are returned per page when fetching results. Larger values reduce round-trips but use more memory.

Arguments

• size - Number of rows per page (default: 1000)

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

Set the client name sent to the server.

This appears in server logs and can help with debugging.

Arguments

• name - Client application name (default: “geode-rust-quinn”)

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

Set the client version sent to the server.

Arguments

• version - Client version string (default: “0.1.0”)

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

Set the GQL conformance level.

Arguments

• level - Conformance level (default: “min”)

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

Set the authentication username.

Arguments

• username - The username for authentication

Example

use geode_client::Client;

let client = Client::new("localhost", 3141)
    .username("admin")
    .password("secret");

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

Set the authentication password.

The password is stored using SecretString which ensures it is:

• Zeroized from memory when dropped
• Not accidentally leaked in debug output

Arguments

• password - The password for authentication

pub fn connect_timeout(self, seconds: u64) -> Self

Set the connection timeout in seconds.

This controls how long to wait for the initial QUIC connection to be established. Default is 10 seconds.

Arguments

• seconds - Timeout in seconds (must be > 0)

pub fn hello_timeout(self, seconds: u64) -> Self

Set the HELLO handshake timeout in seconds.

This controls how long to wait for the server to respond to the initial HELLO message. Default is 5 seconds.

Arguments

• seconds - Timeout in seconds (must be > 0)

pub fn idle_timeout(self, seconds: u64) -> Self

Set the idle connection timeout in seconds.

This controls how long an idle connection can remain open before being automatically closed by the QUIC layer. Default is 30 seconds.

Arguments

• seconds - Timeout in seconds (must be > 0)

pub fn validate(&self) -> Result<()>

Validate the client configuration.

Performs validation on all configuration parameters including:

• Hostname format (RFC 1035 compliant)
• Port number (1-65535)
• Page size (1-100,000)

This method is automatically called by connect. You can call it manually to validate configuration before attempting to connect.

Errors

Returns a validation error if any parameter is invalid.

Example

use geode_client::Client;

let client = Client::new("localhost", 3141);
assert!(client.validate().is_ok());

// Invalid hostname
let invalid = Client::new("-invalid-host", 3141);
assert!(invalid.validate().is_err());

pub async fn connect(&self) -> Result<Connection>

Connect to the Geode database.

Establishes a QUIC connection to the server, performs the TLS handshake, and sends the initial HELLO message.

Returns

A Connection that can be used to execute queries.

Errors

Returns an error if:

• The hostname cannot be resolved
• The connection cannot be established
• TLS verification fails (unless skip_verify is true)
• The HELLO handshake fails

Example

let client = Client::new("localhost", 3141).skip_verify(true);
let mut conn = client.connect().await?;
// Use connection...
conn.close()?;

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

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

Performs copy-assignment from source.