Struct surreal_simple_querybuilder::querybuilder::QueryBuilder

pub struct QueryBuilder<'a> { /* private fields */ }

Implementations

impl<'a> QueryBuilder<'a>

pub fn new() -> Self

pub fn create<T: Into<Cow<'a, str>>>(self, node: T) -> Self

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new().create("Person:ee").build();

assert_eq!(query, "CREATE Person:ee")

pub fn update<T: Into<Cow<'a, str>>>(self, node: T) -> Self

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new().update("Person:ee").build();

assert_eq!(query, "UPDATE Person:ee")

pub fn select<T: Into<Cow<'a, str>>>(self, node: T) -> Self

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new().select("ee:Person").build();

assert_eq!(query, "SELECT ee:Person")

pub fn delete<T: Into<Cow<'a, str>>>(self, node: T) -> Self

Start a DELETE statement:

DELETE user:John

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new().delete("ee:Person").build();

assert_eq!(query, "DELETE ee:Person");

pub fn relate<T: Into<Cow<'a, str>>>(self, node: T) -> Self

Start a RELATE statement:

RELATE user:tobie->write->article:surreal SET time.written = time::now();

Note: the SET or anything after it in the example above should be added manually using the QueryBuilder::set() method.

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new().relate("user:John->likes->user:Mark").build();

assert_eq!(query, "RELATE user:John->likes->user:Mark");

pub fn content<T: Into<Cow<'a, str>>>(self, json_content: T) -> Self

Start a CONTENT statement. Content statements often follow RELATE statements:

RELATE user:tobie->write->article:surreal CONTENT {
  source: 'Apple notes',
  tags: ['notes', 'markdown'],
  time: {
    written: time::now(),
  },
};

Note: Anything before the CONTENT in the example above should be added manually using the QueryBuilder::relate() method.

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new().content("{ creation_time: time::now() }").build();

assert_eq!(query, "CONTENT { creation_time: time::now() }");

pub fn from<T: Into<Cow<'a, str>>>(self, node: T) -> Self

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new().from("Person").build();

assert_eq!(query, "FROM Person")

pub fn select_many<T: Into<Cow<'a, str>>>(self, nodes: &[T]) -> Selfwhere
    T: Copy,

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new().select_many(&["ee:Person", "o:Order"]).build();

assert_eq!(query, "SELECT ee:Person , o:Order")

pub fn also<T: Into<Cow<'a, str>>>(self, query: T) -> Self

Adds the supplied query with a comma in front of it

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new().also("ee").build();

assert_eq!(query, ", ee")

pub fn filter<T: Into<Cow<'a, str>>>(self, condition: T) -> Self

Starts a WHERE clause.

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .filter("handle = ?1")
  .build();

assert_eq!(query, "WHERE handle = ?1");

pub fn and_where<T: Into<Cow<'a, str>>>(self, condition: T) -> Self

An alias for QueryBuilder::filter

pub fn or<T: Into<Cow<'a, str>>>(self, condition: T) -> Self

Writes a OR followed by the supplied condition

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .or("handle = ?1")
  .build();

assert_eq!(query, "OR handle = ?1");

pub fn and<T: Into<Cow<'a, str>>>(self, condition: T) -> Self

Starts an AND followed by the supplied condition.

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .and("handle = ?1")
  .build();

assert_eq!(query, "AND handle = ?1");

pub fn set<T: Into<Cow<'a, str>>>(self, update: T) -> Self

Starts a SET clause.

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .set("handle = ?1")
  .build();

assert_eq!(query, "SET handle = ?1");

pub fn set_many<T: Into<Cow<'a, str>>>(self, updates: &[T]) -> Selfwhere
    T: Copy,

Starts a SET clause with many fields.

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .set_many(&["handle = $1", "password = $2"])
  .build();

assert_eq!(query, "SET handle = $1 , password = $2");

pub fn fetch<T: Into<Cow<'a, str>>>(self, field: T) -> Self

Starts a FETCH clause,

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .fetch("author")
  .build();

assert_eq!(query, "FETCH author");

pub fn fetch_many<T: Into<Cow<'a, str>>>(self, fields: &[T]) -> Selfwhere
    T: Copy,

Starts a FETCH clause with zero or more fields,

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .fetch_many(&["author", "projects"])
  .build();

assert_eq!(query, "FETCH author , projects");

pub fn group_by<T: Into<Cow<'a, str>>>(self, field: T) -> Self

Starts a GROUP BY clause,

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .group_by("author")
  .build();

assert_eq!(query, "GROUP BY author");

pub fn group_by_many<T: Into<Cow<'a, str>>>(self, fields: &[T]) -> Selfwhere
    T: Copy,

Starts a GROUP BY clause with zero or more fields,

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .group_by_many(&["author", "projects"])
  .build();

assert_eq!(query, "GROUP BY author , projects");

pub fn order_by_asc<T: Into<Cow<'a, str>>>(self, field: T) -> Self

Starts a ORDER BY ASC clause,

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .order_by_asc("author")
  .build();

assert_eq!(query, "ORDER BY author ASC");

pub fn order_by_asc_many<T: Into<Cow<'a, str>>>(self, fields: &[T]) -> Selfwhere
    T: Copy,

Starts a ORDER BY ASC clause with zero or more fields,

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .order_by_asc_many(&["author", "projects"])
  .build();

assert_eq!(query, "ORDER BY author ASC , projects ASC");

pub fn order_by_desc<T: Into<Cow<'a, str>>>(self, field: T) -> Self

Starts a ORDER BY DESC clause,

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .order_by_desc("author")
  .build();

assert_eq!(query, "ORDER BY author DESC");

pub fn order_by_desc_many<T: Into<Cow<'a, str>>>(self, fields: &[T]) -> Selfwhere
    T: Copy,

Starts a ORDER BY DESC clause with zero or more fields,

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .order_by_desc_many(&["author", "projects"])
  .build();

assert_eq!(query, "ORDER BY author DESC , projects DESC");

pub fn if_then<F>(self, condition: bool, action: F) -> Selfwhere
    F: Fn(Self) -> Self,

Queues a condition which allows the next statement to be ignored if condition is false.

Conditions can be nested, the queue works as a LIFO queue.

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .select_many(&["1", "2"])
  .if_then(false, |query| query
    .select_many(&["3", "4"])
    // will not run:
    .if_then(true, |query| query
      .select_many(&["5", "6"])
    )
  )
  .if_then(true, |query| query
    .select_many(&["7", "8"])
  )
  .build();

assert_eq!(query, "SELECT 1 , 2 SELECT 7 , 8");

pub fn and_group<F, T: Into<Cow<'a, str>>>(
    self,
    first_condition: T,
    action: F
) -> Selfwhere
    F: Fn(Self) -> Self,

Writes an AND followed by the supplied first_condition and any other statement added to the querybuilder in the action closure surrounded by parenthesis.

Can be used to compose boolean expressions with grouped OR statements like so:

WHERE name contains 'John' AND (name contains 'Doe' OR name contains 'Eod')

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .select("*")
  .from("user")
  .filter("name contains 'John'")
  .and_group("name contains 'Doe'", |q| {
    q.or("name contains 'Eod'")
  })
  .build();

assert_eq!(query, "SELECT * FROM user WHERE name contains 'John' AND ( name contains 'Doe' OR name contains 'Eod' )");

pub fn raw(self, text: &'a str) -> Self

Pushes raw text to the buffer

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .raw("foo bar")
  .build();

assert_eq!(query, "foo bar");

pub fn commas(self, action: fn(_: Self) -> Self) -> Self

Start a queue where all of the new pushed actions are separated by commas.

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .commas(|query| query
    .raw("foo")
    .raw("bar")
  ).build();

assert_eq!(query, "foo , bar");

pub fn limit<T: Into<Cow<'a, str>>>(self, limit: T) -> Self

Start a LIMIT clause.

Example

use surreal_simple_querybuilder::prelude::*;


let page_size = 10.to_string();
let query = QueryBuilder::new()
  .limit(&page_size)
  .build();

assert_eq!(query, "LIMIT 10")

pub fn start_at<T: Into<Cow<'a, str>>>(self, offset: T) -> Self

Start a START AT clause.

Example

use surreal_simple_querybuilder::prelude::*;


let page_size = 10.to_string();
let query = QueryBuilder::new()
  .start_at(&page_size)
  .build();

assert_eq!(query, "START AT 10")

pub fn add_segment<T: Into<Cow<'a, str>>>(&mut self, segment: T) -> &mut Self

Add the given segment to the internal buffer. This is a rather internal method that is set public for special cases, you should prefer using the raw method instead.

pub fn param(self, key: &'a str, value: &'a str) -> Self

Add a parameter and its value to the query that will be used to replace all occurences of key into value when the build method is called.

IMPORTANT Do not use this for user provided data, the input is not sanitized

Example

use surreal_simple_querybuilder::prelude::*;

let query = QueryBuilder::new()
  .select("{{field}}")
  .from("Account")
  .param("{{field}}", "id")
  .build();

assert_eq!("SELECT id FROM Account", query);

pub fn build(self) -> String

pub fn set_model<T: Serialize>(self, model: &T) -> SqlSerializeResult<Self>

Start a SET statement with all the public fields in the supplied T using the [SqlFieldSerializer] and Serde to list all the serializable fields in order to get a statement like the following:

SET field_one = $field_one , field_two = $field_two

The function is meant to be used with the models generated by the [model] macro.

pub fn update_model<T: Serialize>(self, model: &T) -> SqlSerializeResult<Self>

Start an UPDATE statement with all the public fields in the supplied T using the [SqlFieldSerializer] and Serde to list all the serializable fields in order to get a statement like the following:

UPDATE field_one = $field_one , field_two = $field_two

The function is meant to be used with the models generated by the [model] macro.