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: IntoQueryBuilderSegment + 'a>(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: IntoQueryBuilderSegment + 'a>(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: IntoQueryBuilderSegment + 'a>(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 from<T>(self, node: T) -> Selfwhere
    T: IntoQueryBuilderSegment + 'a,

Example

use surreal_simple_querybuilder::prelude::*;

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

assert_eq!(query, "FROM Person")

pub fn select_many<T: IntoQueryBuilderSegment + 'a>(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: IntoQueryBuilderSegment + 'a>(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: IntoQueryBuilderSegment + 'a>(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: IntoQueryBuilderSegment + 'a>(self, condition: T) -> Self

An alias for QueryBuilder::filter

pub fn and<T: IntoQueryBuilderSegment + 'a>(self, condition: T) -> Self

Starts a WHERE clause.

Example

use surreal_simple_querybuilder::prelude::*;

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

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

pub fn set<T: IntoQueryBuilderSegment + 'a>(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: IntoQueryBuilderSegment + 'a>(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: IntoQueryBuilderSegment + 'a>(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: IntoQueryBuilderSegment + 'a>(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 if_then(self, condition: bool, action: fn(_: Self) -> 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 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: IntoQueryBuilderSegment + 'a>(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: IntoQueryBuilderSegment + 'a>(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: IntoQueryBuilderSegment + 'a>(
    &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_object<T: QueryBuilderSetObject>(self) -> Selfwhere
    T: 'a,

Tell the current query builder to execute the QueryBuilderSetObject trait for the given T generic type.

pub fn hold(&mut self, string: String) -> QueryBuilderSegment<'a>

Tell the current querybuilder to hold the given string into its internal buffer and to return a reference to the newly held value a QueryBuilder can use.

This function is particularely useful if some of your code is inside a short-lived scope such as a closure but you still need to add segments to the querybuilder. However the fact the querybuilder initially holds series of &'a str makes it impossible, this is where you can tell the builder to hold the given string for you.