#elasticsearch #search

elastic

A modular sync and async client for the Elasticsearch REST API

30 releases

0.20.9 Feb 6, 2018
0.20.8 Dec 17, 2017
0.20.6 Nov 30, 2017
0.13.2 Jul 30, 2017
0.10.0 Mar 20, 2017

#2 in Database implementations

Download history 171/week @ 2018-08-15 118/week @ 2018-08-22 54/week @ 2018-08-29 105/week @ 2018-09-05 178/week @ 2018-09-12 188/week @ 2018-09-19 254/week @ 2018-09-26 228/week @ 2018-10-03 167/week @ 2018-10-10 301/week @ 2018-10-17 105/week @ 2018-10-24 180/week @ 2018-10-31 420/week @ 2018-11-07

355 downloads per month
Used in 1 crate

MIT/Apache

501KB
8K SLoC

elastic Latest Version Gitter

elastic is an efficient, modular API client for Elasticsearch written in Rust. The API is targeting the Elastic Stack 5.x.

elastic provides strongly-typed documents and weakly-typed queries.

Stability

This crate is still quite unstable and is likely to continue to churn breaking releases over the near future with not-so-detailed changelogs.

If you run into any problems upgrading in your own open source projects feel free to open up an issue and we'll give you a hand. The goal is definitely to offer a stable API eventually.

Example

Add elastic to your Cargo.toml:

[dependencies]
elastic = "*"
elastic_derive = "*"
serde_json = "*"

Create a SyncClient and start making requests:

#[macro_use]
extern crate elastic_derive;
#[macro_use]
extern crate serde_json;
extern crate elastic;

use serde_json::Value;
use elastic::prelude::*;

// A reqwest HTTP client and default parameters.
// The builder includes the base node url (http://localhost:9200).
let client = SyncClientBuilder::new().build()?;

let query = "some query string";

// A search request with a freeform body.
let res = client.search::<Value>()
                .index("_all")
                .body(json!({
                    "query": {
                        "query_string": {
                            "query": query
                        }
                    }
                }))
                .send()?;

// Iterate through the hits in the response.
for hit in res.hits() {
    println!("{:?}", hit);
}

elastic also offers an AsyncClient for use with the tokio asynchronous io stack. See the examples folder for complete samples.

Building documents

Document mapping is derived at compile-time from your Plain Old Rust Structures. Just add a #[derive(ElasticType)] attribute:

#[derive(ElasticType, Serialize, Deserialize)]
struct MyDocument {
	pub id: i32,
	pub title: String,
	pub timestamp: Date<DefaultDateMapping<EpochMillis>>,
	pub content: Text<DefaultTextMapping>,
}

And you can start using MyDocument in Client request methods.

See the docs for more details.

Alternatives

If you'd like to use a strongly-typed Query DSL builder see rs-es. This client does the hard work of providing an idiomatic Rust API for interacting with Elasticsearch. It has the advantage of letting you know your queries will parse at compile-time instead of runtime.

License

Licensed under either of these:

Dependencies

~19MB
~413K SLoC