Crate rsolr

A Solr client for Rust.

Rsolr provides capabilities to manipulate and form requests to the Solr server, and contains some shorthands for them. It uses the blocking version of the reqwest http client.

Select

You can retrieve documents as types with implemented Clone and Deserialize.

use serde_json::Value;
use rsolr::Client;
use rsolr::error::RSolrError;
use rsolr::solr_response::Response;

fn query_all() -> Result<Response<Value>, RSolrError> {
    let mut client = Client::new("http://solr:8983", "collection");
    let result = client
        .select("*:*")
        .run();

   match result {
        Ok(solr_result) => {
            let solr_result = client.get_response::<Value>();
            Ok(solr_result.expect("Serialization failed").response.expect("Response is OK, but no solr content"))
        }
        Err(e) => Err(e) // something happened on http
    }
}

Upload JSON doc(s)

You should use types with implemented Clone and Serialize.

use serde::Serialize;
use serde_json::Value;
use rsolr::Client;

#[derive(Serialize, Clone)]
struct SimpleDocument {
    field: Vec<String>
}

fn upload() {
    let document = SimpleDocument { field: vec!("nice".to_string(), "document".to_string()) };
    Client::new("http://solr:8983", "collection")
        .upload_json(document)
        .run().expect("request failed.");
}

Delete

use serde_json::Value;
use rsolr::Client;
fn delete() {
    Client::new("http://solr:8983", "collection")
        .delete("delete:query")
        .run().expect("request failed.");
}

Custom handler with params

You can define any handlers as well.

use serde_json::Value;
use rsolr::Client;
use rsolr::error::RSolrError;
use rsolr::solr_response::Response;
fn more_like_this()  -> Result<Response<Value>, RSolrError> {
    let mut client = Client::new("http://solr:8983", "collection");
    let result = client
        .request_handler("mlt")
        .add_query_param("mlt.fl", "similarity_field")
        .add_query_param("mlt.mintf", "4")
        .add_query_param("mlt.minwl", "3")
        .run();
    match result {
        Ok(solr_result) => Ok(client.get_response::<Value>().expect("Serialization failed").response.expect("No response")),
        Err(e) => Err(e)
    }
}

Cursor-based pagination

Paginated results can be fetched iteratively with the use of solr cursor

use serde_json::Value;
use rsolr::Client;
use rsolr::solr_response::SolrResponse;
fn cursor_fetch_all_pages() -> Vec<SolrResponse<Value>> {
    let mut responses = Vec::new();
    let mut client = Client::new("http://solr:8983", "collection");
    let result = client
        .select("*:*")
        .sort("id asc")
        .cursor()
        .run();
    let mut cursor = result.expect("request failed").expect("no cursor");
    while cursor.next::<Value>().expect("request failed").is_some() {
        responses.push(cursor.get_response::<Value>().expect("parsing failed"));
    }
    responses
}

Modules

cursor

error

query

You can build Solr queries with this module. For easy integration queries should be rendered to str at the end, if you want to use in the client. Currently it’s rather cumbersome, on it.

solr_response

Structs

Client

RequestHandlers

Enums

Payload

The Payload defines the request method. Body and Empty sets method to POST, None uses GET.