influxdb/influxdb_iox_client
Carol (Nichols || Goulding) 73828323ac
feat: Ingester Flight gRPC API (#3623)
* feat: Add a way to run ingester with an in-memory catalog from the CLI

If you set the --catalog-dsn string to "mem", rather than using that as
a Postgres connection URL, create an in-memory catalog.

Planning on using this in tests, so not documenting.

* fix: Set default topic to the same value as SHARED_KAFKA_TOPIC

Namely, both should use an underscore. I don't think there's a way to
directly share these values between a constant and an annotation.

* feat: Add a flight API (handshake only) to ingester

* fix: Create partitions if using file-based write buffer

* fix: Change the server fixture to handle ingester server type

For now, the ingester doesn't implement the deployment API. Not sure if
it should or not.

* feat: Start implementing ingester do_get, namely decoding the query

Skip serialization of the predicate for the moment.

* refactor: Rename ingest protos to ingester to match crate name

* refactor: Rename QueryResults to QueryData

* feat: Move ingester flight client to new querier crate

* fix: Off by one error, different starting indexes in sequencers

* fix: Create new CLI argument to pick the catalog type

* fix: Create a CLI option to set the number of topics to auto-create in the write buffer

* fix: Check the arrow flight service's health to tell that the ingester gRPC is up

* fix: Set postgres as the default catalog type

* fix: Return an error rather than panicking if CLI args aren't right
2022-02-09 19:07:44 +00:00
..
src feat: Ingester Flight gRPC API (#3623) 2022-02-09 19:07:44 +00:00
Cargo.toml chore: feature flag consistency (#3574) 2022-01-28 16:38:59 +00:00
README.md chore: remove unused code 2021-04-08 10:02:28 -04:00

README.md

InfluxDB IOx Client

This is the official Rust client library for connecting to InfluxDB IOx.

Using the HTTP API

If you only want to use the HTTP API, create an influxdb_iox_client::Client. Here is an example of creating an instance that connects to an IOx server running at http://127.0.0.1:8080 and creating a database named telemetry:

#[tokio::main]
fn main() {
    use data_types::database_rules::DatabaseRules;
    use influxdb_iox_client::ClientBuilder;

    let client = ClientBuilder::default()
        .build("http://127.0.0.1:8080")
        .expect("client should be valid");

    client
        .create_database("telemetry", &DatabaseRules::default())
        .await
        .expect("failed to create database");
}

Using the Arrow Flight API

IOx supports an Arrow Flight gRPC API. To use it, enable the flight feature, which is off by default:

[dependencies]
influxdb_iox_client = { version = "[..]", features = ["flight"] }

Then you can create an influxdb_iox_client::FlightClient by using the FlightClientBuilder. Here is an example of creating an instance that connects to an IOx server with its gRPC services available at http://localhost:8082 and using it to perform a query:

#[tokio::main]
fn main() {
    use data_types::database_rules::DatabaseRules;
    use influxdb_iox_client::FlightClientBuilder;

    let client = FlightClientBuilder::default()
        .build("http://127.0.0.1:8082")
        .expect("client should be valid");

    let mut query_results = client
        .perform_query(scenario.database_name(), sql_query)
        .await;

    let mut batches = vec![];

    while let Some(data) = query_results.next().await {
        batches.push(data);
    }
}