quack-ruby 0.1.0

data/ext/quack/vendor/quack_protocol/src/constants.rs

@@ -0,0 +1,11 @@
+pub(crate) const QUACK_V1: u64 = 1;
+pub(crate) const QUACK_V3: u64 = 3;
+pub(crate) const MIN_QUACK_VERSION: u64 = QUACK_V1;
+pub(crate) const MAX_QUACK_VERSION: u64 = QUACK_V3;
+pub(crate) const DEFAULT_QUACK_PORT: u16 = 9494;
+pub(crate) const QUACK_ENDPOINT: &str = "/quack";
+pub(crate) const DUCKDB_MIME_TYPE: &str = "application/duckdb";
+pub(crate) const FIELD_END: u16 = 0xffff;
+pub(crate) const OPTIONAL_INDEX_INVALID: u64 = u64::MAX;
+pub(crate) const DEFAULT_HEARTBEAT_TIMEOUT_SECS: u64 = 60;
+pub(crate) const MAX_HEARTBEAT_TIMEOUT_SECS: u64 = 300;

data/ext/quack/vendor/quack_protocol/src/errors.rs

@@ -0,0 +1,103 @@
+pub type Result<T> = std::result::Result<T, QuackError>;
+
+// The current protocol has no typed error code. Exact comparison keeps this
+// retirement heuristic narrower than arbitrary SQL error text containing one
+// of these server messages. It must never be used to authorize replay.
+const RETIRE_CONNECTION_MESSAGES: [&str; 2] = [
+    "Invalid connection id",
+    "Connection does not exist / already disconnected",
+];
+
+#[derive(Debug, thiserror::Error)]
+pub enum QuackError {
+    #[error(transparent)]
+    Proxy(#[from] crate::ProxyError),
+    #[error("quack protocol error: {0}")]
+    Protocol(String),
+    #[error("quack server error: {0}")]
+    Server(String),
+    #[error("unsupported quack type: {0}")]
+    UnsupportedType(String),
+    #[error("http error: {0}")]
+    Http(#[from] reqwest::Error),
+    #[error("url parse error: {0}")]
+    Url(#[from] url::ParseError),
+    #[error("utf-8 error: {0}")]
+    Utf8(#[from] std::string::FromUtf8Error),
+}
+
+impl QuackError {
+    pub(crate) fn protocol(message: impl Into<String>) -> Self {
+        Self::Protocol(message.into())
+    }
+
+    pub(crate) fn server(message: impl Into<String>) -> Self {
+        Self::Server(message.into())
+    }
+
+    pub(crate) fn unsupported(message: impl Into<String>) -> Self {
+        Self::UnsupportedType(message.into())
+    }
+
+    /// The connection that produced this error should not be reused.
+    ///
+    /// Transport and framing failures leave no way to tell what the server did
+    /// with the request, so a pool retires the connection rather than hand it
+    /// to the next caller. Errors raised without touching the wire - bad
+    /// arguments, unsupported types - are not counted.
+    ///
+    /// This says nothing about whether the request ran. Current protocol
+    /// versions carry only an error message string, and SQL can produce the
+    /// same text as a missing-connection response, so no error is safe to
+    /// retry automatically.
+    pub fn is_connection_fatal(&self) -> bool {
+        match self {
+            Self::Http(_) | Self::Protocol(_) => true,
+            Self::Proxy(error) => !matches!(
+                error,
+                crate::ProxyError::QueryFailed | crate::ProxyError::ConnectionBusy
+            ),
+            Self::Server(message) => RETIRE_CONNECTION_MESSAGES
+                .iter()
+                .any(|known| message == known),
+            Self::UnsupportedType(_) | Self::Url(_) | Self::Utf8(_) => false,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn exact_connection_error_text_retires() {
+        for message in RETIRE_CONNECTION_MESSAGES {
+            let err = QuackError::server(message);
+            assert!(err.is_connection_fatal(), "{message}");
+        }
+    }
+
+    #[test]
+    fn sql_error_text_containing_connection_message_is_not_fatal() {
+        for message in [
+            "Invalid Input Error: Invalid connection id",
+            "statement failed: Invalid connection id after committing",
+            "Connection does not exist / already disconnected (from SQL)",
+        ] {
+            let err = QuackError::server(message);
+            assert!(!err.is_connection_fatal(), "{message}");
+        }
+    }
+
+    #[test]
+    fn sql_errors_leave_the_connection_usable() {
+        let err = QuackError::server("Table with name t does not exist!");
+        assert!(!err.is_connection_fatal());
+    }
+
+    #[test]
+    fn transport_errors_are_fatal() {
+        let err = QuackError::protocol("expected PREPARE_RESPONSE, got FetchResponse");
+        assert!(err.is_connection_fatal());
+    }
+}

data/ext/quack/vendor/quack_protocol/src/inspection.rs

@@ -0,0 +1,250 @@
+//! Bounded metadata inspection for HTTP proxies. Payloads remain opaque.
+//!
+//! Headers share the client's codec. Incomplete input is distinct from invalid
+//! input; callers must stop collecting at [`MAX_MESSAGE_HEADER_BYTES`]. Neither this
+//! API nor its errors expose SQL, authentication fields, or upstream error text.
+
+pub use crate::messages::MessageType as Operation;
+use crate::{
+    QuackError,
+    binary::BinaryReader,
+    messages::{self, QuackMessage},
+};
+
+pub const MAX_MESSAGE_HEADER_BYTES: usize = 4096;
+pub const MAX_CONTROL_RESPONSE_BYTES: usize = 16 * 1024;
+pub const MAX_CONNECTION_ID_BYTES: usize = 256;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct MessageHeader {
+    pub operation: Operation,
+    pub connection_id: Option<String>,
+    pub client_query_id: Option<u64>,
+    /// Number of bytes occupied by the header; excludes the opaque body.
+    pub encoded_len: usize,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, thiserror::Error)]
+pub enum InspectionError {
+    #[error("incomplete quack message header")]
+    Incomplete,
+    #[error("invalid quack message header")]
+    Invalid,
+    #[error("quack metadata exceeds inspection limit")]
+    TooLarge,
+}
+
+/// Inspects only the header, even when `prefix` also contains a large payload.
+pub fn inspect_message_header(prefix: &[u8]) -> Result<MessageHeader, InspectionError> {
+    let bounded = &prefix[..prefix.len().min(MAX_MESSAGE_HEADER_BYTES)];
+    let mut reader = BinaryReader::new(bounded);
+    let header = match messages::decode_header(&mut reader) {
+        Ok(header) => header,
+        Err(_) if reader.is_incomplete() => {
+            return Err(if bounded.len() == MAX_MESSAGE_HEADER_BYTES {
+                InspectionError::TooLarge
+            } else {
+                InspectionError::Incomplete
+            });
+        }
+        Err(_) => return Err(InspectionError::Invalid),
+    };
+    if header
+        .connection_id
+        .as_ref()
+        .is_some_and(|id| id.len() > MAX_CONNECTION_ID_BYTES)
+    {
+        return Err(InspectionError::TooLarge);
+    }
+    Ok(MessageHeader {
+        operation: header.message_type,
+        connection_id: header.connection_id,
+        client_query_id: header.client_query_id,
+        encoded_len: bounded.len() - reader.remaining(),
+    })
+}
+
+/// Only bounded control responses are decoded. Never call on result payloads.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ControlResponse {
+    Connected { connection_id: String },
+    Success,
+    Error { fatal: bool },
+}
+
+pub fn inspect_control_response(bytes: &[u8]) -> Result<ControlResponse, InspectionError> {
+    if bytes.len() > MAX_CONTROL_RESPONSE_BYTES {
+        return Err(InspectionError::TooLarge);
+    }
+    let header = inspect_message_header(bytes)?;
+    if !matches!(
+        header.operation,
+        Operation::ConnectionResponse | Operation::SuccessResponse | Operation::ErrorResponse
+    ) {
+        return Err(InspectionError::Invalid);
+    }
+    if header.operation == Operation::ErrorResponse {
+        let mut reader = BinaryReader::new(&bytes[header.encoded_len..]);
+        let (message, invalidated) = reader
+            .read_object(messages::read_error_fields)
+            .map_err(|_| InspectionError::Invalid)?;
+        reader.assert_eof().map_err(|_| InspectionError::Invalid)?;
+        // Legacy versions carry only text. This conservative fallback can cause
+        // recycling, but must never authorize replay or release ownership.
+        let fatal = invalidated
+            || message.starts_with("FATAL Error:")
+            || message.starts_with("INTERNAL Error:")
+            || message.starts_with("Fatal Error:")
+            || message.starts_with("Internal Error:")
+            || QuackError::server(message).is_connection_fatal();
+        return Ok(ControlResponse::Error { fatal });
+    }
+    // These bodies are compatible across v1 and v3; v3's added fields are optional.
+    let message = messages::decode_message_for_version(bytes, crate::constants::QUACK_V3)
+        .map_err(|_| InspectionError::Invalid)?;
+    match message {
+        QuackMessage::ConnectionResponse {
+            header,
+            quack_version,
+            ..
+        } => {
+            if quack_version.is_some_and(|v| v != 1 && v != 3) {
+                return Err(InspectionError::Invalid);
+            }
+            Ok(ControlResponse::Connected {
+                connection_id: header.connection_id.ok_or(InspectionError::Invalid)?,
+            })
+        }
+        QuackMessage::SuccessResponse { .. } => Ok(ControlResponse::Success),
+        _ => Err(InspectionError::Invalid),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        binary::BinaryWriter,
+        messages::{MessageHeader as WireMessageHeader, encode_header, encode_message},
+    };
+
+    fn header(operation: Operation, connection: Option<&str>) -> WireMessageHeader {
+        WireMessageHeader {
+            message_type: operation,
+            connection_id: connection.map(str::to_owned),
+            client_query_id: Some(42),
+        }
+    }
+
+    #[test]
+    fn every_request_header_accepts_all_chunk_boundaries_without_payload() {
+        for operation in [
+            Operation::ConnectionRequest,
+            Operation::PrepareRequest,
+            Operation::FetchRequest,
+            Operation::SendDataRequest,
+            Operation::DisconnectMessage,
+            Operation::CancelRequest,
+            Operation::Acknowledgement,
+            Operation::HeartbeatRequest,
+        ] {
+            let mut writer = BinaryWriter::new();
+            encode_header(&mut writer, &header(operation, Some("connection-example"))).unwrap();
+            let mut bytes = writer.into_bytes();
+            for end in 0..bytes.len() {
+                assert_eq!(
+                    inspect_message_header(&bytes[..end]),
+                    Err(InspectionError::Incomplete)
+                );
+            }
+            let expected = inspect_message_header(&bytes).unwrap();
+            assert_eq!(expected.operation, operation);
+            assert_eq!(expected.client_query_id, Some(42));
+            assert_eq!(expected.encoded_len, bytes.len());
+            bytes.resize(1024 * 1024, 0xfe);
+            assert_eq!(inspect_message_header(&bytes).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn malformed_and_oversized_headers_do_not_panic_or_echo_input() {
+        assert_eq!(
+            inspect_message_header(&[2, 0, 1]),
+            Err(InspectionError::Invalid)
+        );
+        let mut writer = BinaryWriter::new();
+        encode_header(
+            &mut writer,
+            &header(Operation::PrepareRequest, Some(&"x".repeat(257))),
+        )
+        .unwrap();
+        assert_eq!(
+            inspect_message_header(writer.as_slice()),
+            Err(InspectionError::TooLarge)
+        );
+        for length in 0..MAX_MESSAGE_HEADER_BYTES + 20 {
+            let bytes = vec![0xff; length];
+            assert!(inspect_message_header(&bytes).is_err());
+        }
+        // An attacker-controlled usize::MAX string length must not overflow ensure().
+        let mut writer = BinaryWriter::new();
+        writer.write_field(1, |w| w.write_uleb(3u64)).unwrap();
+        writer.write_field(2, |w| w.write_uleb(u64::MAX)).unwrap();
+        assert!(inspect_message_header(writer.as_slice()).is_err());
+    }
+
+    #[test]
+    fn complete_control_response_is_required_and_errors_are_sanitized() {
+        let success = encode_message(&QuackMessage::SuccessResponse {
+            header: header(Operation::SuccessResponse, Some("example")),
+        })
+        .unwrap();
+        assert_eq!(
+            inspect_control_response(&success).unwrap(),
+            ControlResponse::Success
+        );
+        assert!(inspect_control_response(&success[..success.len() - 1]).is_err());
+        let mut trailing = success.clone();
+        trailing.push(0);
+        assert!(inspect_control_response(&trailing).is_err());
+        for (message, fatal) in [
+            ("Catalog Error: private query text", false),
+            ("FATAL Error: private details", true),
+            ("Invalid connection id", true),
+        ] {
+            let bytes = encode_message(&QuackMessage::ErrorResponse {
+                header: header(Operation::ErrorResponse, None),
+                message: message.into(),
+            })
+            .unwrap();
+            assert_eq!(
+                inspect_control_response(&bytes).unwrap(),
+                ControlResponse::Error { fatal }
+            );
+        }
+    }
+
+    #[test]
+    fn structured_invalidation_recycles_and_malicious_extra_info_is_bounded() {
+        for count in [0, u64::MAX] {
+            let mut writer = BinaryWriter::new();
+            encode_header(&mut writer, &header(Operation::ErrorResponse, None)).unwrap();
+            writer
+                .write_object(|w| {
+                    w.write_field(1, |w| w.write_string("private details"))?;
+                    w.write_field(2, |w| w.write_string("Catalog"))?;
+                    w.write_field(3, |w| w.write_uleb(count))?;
+                    w.write_field(4, |w| w.write_bool(true))
+                })
+                .unwrap();
+            if count == 0 {
+                assert_eq!(
+                    inspect_control_response(writer.as_slice()).unwrap(),
+                    ControlResponse::Error { fatal: true }
+                );
+            } else {
+                assert!(inspect_control_response(writer.as_slice()).is_err());
+            }
+        }
+    }
+}

data/ext/quack/vendor/quack_protocol/src/json.rs

@@ -0,0 +1,225 @@
+use base64::Engine;
+use base64::engine::general_purpose::STANDARD;
+use serde_json::{Map, Number, Value as JsonValue, json};
+
+use crate::errors::{QuackError, Result};
+use crate::vector::{Row, TimeUnit, TimestampUnit, Value, decimal_to_string};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum BigIntJsonMode {
+    String,
+    Number,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum BytesJsonMode {
+    Base64,
+    Hex,
+    Array,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TaggedJsonMode {
+    Default,
+    Tagged,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct JsonOptions {
+    pub bigint: BigIntJsonMode,
+    pub bytes: BytesJsonMode,
+    pub decimal: TaggedJsonMode,
+    pub date: TaggedJsonMode,
+    pub time: TaggedJsonMode,
+    pub timestamp: TaggedJsonMode,
+}
+
+impl Default for JsonOptions {
+    fn default() -> Self {
+        Self {
+            bigint: BigIntJsonMode::String,
+            bytes: BytesJsonMode::Base64,
+            decimal: TaggedJsonMode::Default,
+            date: TaggedJsonMode::Default,
+            time: TaggedJsonMode::Default,
+            timestamp: TaggedJsonMode::Default,
+        }
+    }
+}
+
+pub fn to_json_value(value: &Value, options: JsonOptions) -> Result<JsonValue> {
+    Ok(match value {
+        Value::Null => JsonValue::Null,
+        Value::Bool(value) => JsonValue::Bool(*value),
+        Value::Int(value) => bigint_to_json(*value as i128, options.bigint)?,
+        Value::UInt(value) => unsigned_bigint_to_json(*value as u128, options.bigint)?,
+        Value::HugeInt(value) => bigint_to_json(*value, options.bigint)?,
+        Value::UHugeInt(value) => unsigned_bigint_to_json(*value, options.bigint)?,
+        Value::Float(value) => Number::from_f64(*value as f64)
+            .map(JsonValue::Number)
+            .unwrap_or(JsonValue::Null),
+        Value::Double(value) => Number::from_f64(*value)
+            .map(JsonValue::Number)
+            .unwrap_or(JsonValue::Null),
+        Value::String(value) => JsonValue::String(value.clone()),
+        Value::Bytes(value) => bytes_to_json(value, options.bytes),
+        Value::Decimal(value) => match options.decimal {
+            TaggedJsonMode::Tagged => json!({
+                "kind": "decimal",
+                "value": value.value.to_string(),
+                "width": value.width,
+                "scale": value.scale
+            }),
+            TaggedJsonMode::Default => JsonValue::String(decimal_to_string(value)),
+        },
+        Value::Date(value) => match options.date {
+            TaggedJsonMode::Tagged => json!({ "kind": "date", "days": value.days }),
+            TaggedJsonMode::Default => JsonValue::String(date_to_iso(value.days)),
+        },
+        Value::Time(value) => match options.time {
+            TaggedJsonMode::Tagged => json!({
+                "kind": "time",
+                "unit": match value.unit { TimeUnit::Micros => "micros", TimeUnit::Nanos => "nanos" },
+                "value": value.value.to_string()
+            }),
+            TaggedJsonMode::Default => JsonValue::String(time_to_string(value.value, value.unit)),
+        },
+        Value::TimeTz(value) => json!({ "kind": "time_tz", "bits": value.bits.to_string() }),
+        Value::Timestamp(value) => match options.timestamp {
+            TaggedJsonMode::Tagged => {
+                let unit = match value.unit {
+                    TimestampUnit::Seconds => "seconds",
+                    TimestampUnit::Millis => "millis",
+                    TimestampUnit::Micros => "micros",
+                    TimestampUnit::Nanos => "nanos",
+                };
+                if value.timezone_utc {
+                    json!({ "kind": "timestamp", "unit": unit, "value": value.value.to_string(), "timezone": "utc" })
+                } else {
+                    json!({ "kind": "timestamp", "unit": unit, "value": value.value.to_string() })
+                }
+            }
+            TaggedJsonMode::Default => {
+                JsonValue::String(timestamp_to_iso(value.value, value.unit)?)
+            }
+        },
+        Value::Interval(value) => json!({
+            "kind": "interval",
+            "months": value.months,
+            "days": value.days,
+            "micros": value.micros.to_string()
+        }),
+        Value::List(values) => JsonValue::Array(
+            values
+                .iter()
+                .map(|value| to_json_value(value, options))
+                .collect::<Result<Vec<_>>>()?,
+        ),
+        Value::Struct(row) => {
+            let mut object = Map::new();
+            for (key, value) in row {
+                object.insert(key.clone(), to_json_value(value, options)?);
+            }
+            JsonValue::Object(object)
+        }
+    })
+}
+
+pub fn to_json_row(row: &Row, options: JsonOptions) -> Result<JsonValue> {
+    let mut object = Map::new();
+    for (key, value) in row {
+        object.insert(key.clone(), to_json_value(value, options)?);
+    }
+    Ok(JsonValue::Object(object))
+}
+
+pub fn to_json_rows(rows: &[Row], options: JsonOptions) -> Result<Vec<JsonValue>> {
+    rows.iter().map(|row| to_json_row(row, options)).collect()
+}
+
+fn bigint_to_json(value: i128, mode: BigIntJsonMode) -> Result<JsonValue> {
+    match mode {
+        BigIntJsonMode::String => Ok(JsonValue::String(value.to_string())),
+        BigIntJsonMode::Number => i64::try_from(value)
+            .ok()
+            .map(Number::from)
+            .map(JsonValue::Number)
+            .ok_or_else(|| {
+                QuackError::protocol(format!("bigint value {value} exceeds JSON number range"))
+            }),
+    }
+}
+
+fn unsigned_bigint_to_json(value: u128, mode: BigIntJsonMode) -> Result<JsonValue> {
+    match mode {
+        BigIntJsonMode::String => Ok(JsonValue::String(value.to_string())),
+        BigIntJsonMode::Number => u64::try_from(value)
+            .ok()
+            .map(|value| JsonValue::Number(Number::from(value)))
+            .ok_or_else(|| {
+                QuackError::protocol(format!("bigint value {value} exceeds JSON number range"))
+            }),
+    }
+}
+
+fn bytes_to_json(value: &[u8], mode: BytesJsonMode) -> JsonValue {
+    match mode {
+        BytesJsonMode::Base64 => JsonValue::String(STANDARD.encode(value)),
+        BytesJsonMode::Hex => {
+            JsonValue::String(value.iter().map(|byte| format!("{byte:02x}")).collect())
+        }
+        BytesJsonMode::Array => JsonValue::Array(value.iter().map(|byte| json!(byte)).collect()),
+    }
+}
+
+fn date_to_iso(days: i32) -> String {
+    let epoch = chrono::NaiveDate::from_ymd_opt(1970, 1, 1).expect("valid epoch");
+    (epoch + chrono::Duration::days(days as i64))
+        .format("%Y-%m-%d")
+        .to_string()
+}
+
+fn time_to_string(value: i64, unit: TimeUnit) -> String {
+    let nanos = match unit {
+        TimeUnit::Micros => value as i128 * 1_000,
+        TimeUnit::Nanos => value as i128,
+    };
+    let total_seconds = nanos.div_euclid(1_000_000_000);
+    let fraction = nanos.rem_euclid(1_000_000_000);
+    let hours = total_seconds / 3_600;
+    let minutes = (total_seconds % 3_600) / 60;
+    let seconds = total_seconds % 60;
+    let fraction_text = if fraction == 0 {
+        String::new()
+    } else {
+        format!(".{:09}", fraction)
+            .trim_end_matches('0')
+            .to_string()
+    };
+    format!("{hours:02}:{minutes:02}:{seconds:02}{fraction_text}")
+}
+
+fn timestamp_to_iso(value: i64, unit: TimestampUnit) -> Result<String> {
+    let nanos = match unit {
+        TimestampUnit::Seconds => value as i128 * 1_000_000_000,
+        TimestampUnit::Millis => value as i128 * 1_000_000,
+        TimestampUnit::Micros => value as i128 * 1_000,
+        TimestampUnit::Nanos => value as i128,
+    };
+    let seconds = nanos.div_euclid(1_000_000_000);
+    let fraction = nanos.rem_euclid(1_000_000_000);
+    let datetime = chrono::DateTime::from_timestamp(seconds as i64, fraction as u32)
+        .ok_or_else(|| QuackError::protocol(format!("timestamp value {value} is outside range")))?;
+    let fraction_text = if fraction == 0 {
+        String::new()
+    } else {
+        format!(".{:09}", fraction)
+            .trim_end_matches('0')
+            .to_string()
+    };
+    Ok(format!(
+        "{}{}Z",
+        datetime.format("%Y-%m-%dT%H:%M:%S"),
+        fraction_text
+    ))
+}

data/ext/quack/vendor/quack_protocol/src/lib.rs

@@ -0,0 +1,54 @@
+//! Rust client-side SDK for DuckDB's experimental Quack remote protocol.
+//!
+//! The crate implements the HTTP client transport plus the DuckDB
+//! `BinarySerializer`-compatible message, logical type, and `DataChunk` codecs
+//! needed by a Quack client.
+//!
+//! [`QuackClient`] is one session on the server and runs one query at a time;
+//! [`QuackPool`] keeps several sessions so queries can run concurrently.
+
+#[cfg(feature = "arrow")]
+pub mod arrow;
+mod binary;
+mod builders;
+mod client;
+mod constants;
+mod errors;
+mod proxy_error;
+pub use proxy_error::ProxyError;
+pub mod inspection;
+mod json;
+mod logical_types;
+mod messages;
+mod pool;
+mod sql;
+mod tls;
+mod values;
+mod vector;
+
+pub use builders::{ColumnDefinition, ColumnInput, column, data_chunk, data_chunk_from_rows};
+pub use client::{
+    QuackClient, QuackClientOptions, QuackConnectionInfo, QuackResultStream, QueryMetadata,
+};
+pub use errors::{QuackError, Result};
+pub use futures_core::Stream;
+pub use json::{
+    BigIntJsonMode, BytesJsonMode, JsonOptions, TaggedJsonMode, to_json_row, to_json_rows,
+    to_json_value,
+};
+pub use logical_types::{
+    ChildType, CoordinateReferenceSystem, ExtraTypeInfo, LogicalType, LogicalTypeId, LogicalTypes,
+};
+pub use pool::{DEFAULT_MAX_CONNECTIONS, PooledClient, QuackPool, QuackPoolOptions};
+pub use sql::{SqlParameter, SqlParameters, format_sql, sql_literal};
+pub use values::{
+    date_from_iso_date, date_value, decimal_value, interval_value, time_tz_value, time_value,
+    timestamp_value,
+};
+pub use vector::{
+    DataChunk, DateValue, DecimalValue, IntervalValue, Row, TimeTzValue, TimeUnit, TimeValue,
+    TimestampUnit, TimestampValue, Value, decimal_to_string, rows_from_chunk,
+};
+
+#[cfg(test)]
+mod protocol_tests;