Struct geekorm::QueryBuilder

pub struct QueryBuilder { /* private fields */ }

The QueryBuilder is how you can build dynamically queries using the builder pattern.

Features

There is a number a features that are supported by the QueryBuilder:

• All Major Query Types
  • Select: Build a select query
  • Insert: Build an insert query
  • Update: Build an update query
  • Delete: Build a delete query
• Conditions: Build a query with conditions
  • Where: Build a query with where conditions
  • Order By: Build a query with order by conditions
  • Limit: Build a query with a limit
• Joins: Build a query with joins 2 tables
  • Only Inner Joins are supported currently

Example

use geekorm::{QueryOrder, PrimaryKeyInteger};
use geekorm::prelude::*;

#[derive(Table, Debug, Default, Clone)]
pub struct Users {
    pub id: PrimaryKeyInteger,
    pub username: String,
    pub age: i32,
    pub postcode: Option<String>,
}

// Build a query to create a new table
let create_query = Users::query_create().build()
    .expect("Failed to build create query");
println!("Create Query :: {}", create_query);

// Build a query to select rows from the table
let select_query = Users::query_select()
    .where_eq("username", "geekmasher")
    .order_by("age", QueryOrder::Asc)
    .build()
    .expect("Failed to build select query");
println!("Select Query :: {}", select_query);
// Output:
// SELECT (...) FROM User WHERE username = ? ORDER BY age ASC;

Implementations

impl QueryBuilder

pub fn new() -> QueryBuilder

Create a new QueryBuilder

pub fn select() -> QueryBuilder

Build a select query

pub fn create() -> QueryBuilder

Build a create query

pub fn all() -> Query

Build a “get all rows” query

pub fn insert() -> QueryBuilder

Build an insert query

pub fn update() -> QueryBuilder

Build an update query

pub fn table(self, table: Table) -> QueryBuilder

Set the table for the query builder

pub fn columns(self, columns: Vec<&str>) -> QueryBuilder

Set the columns for the query builder

pub fn add_value(self, column: &str, value: impl Into<Value>) -> QueryBuilder

Add a value to the list of values for parameterized queries

pub fn and(self) -> QueryBuilder

Add an AND condition to the where clause

pub fn or(self) -> QueryBuilder

Add an OR condition to the where clause

pub fn where_eq(self, column: &str, value: impl Into<Value>) -> QueryBuilder

Where clause for equals

pub fn where_ne(self, column: &str, value: impl Into<Value>) -> QueryBuilder

Where clause for not equals

pub fn where_like(self, column: &str, value: impl Into<Value>) -> QueryBuilder

Where clause for like

pub fn where_gt(self, column: &str, value: impl Into<Value>) -> QueryBuilder

Where clause for greater than

pub fn where_lt(self, column: &str, value: impl Into<Value>) -> QueryBuilder

Where clause for less than

pub fn where_gte(self, column: &str, value: impl Into<Value>) -> QueryBuilder

Where clause for greater than or equal to

pub fn where_lte(self, column: &str, value: impl Into<Value>) -> QueryBuilder

Where clause for less than or equal to

pub fn order_by(self, column: &str, order: QueryOrder) -> QueryBuilder

Order the query by a particular column

pub fn join(self, table: Table) -> QueryBuilder

Adds a table to join with the current table

Note: GeekOrm only joins tables with the INNER JOIN clause and primary keys

pub fn count(self) -> QueryBuilder

Count the number of rows in the query

pub fn limit(self, limit: usize) -> QueryBuilder

Add a limit to the query

pub fn offset(self, offset: usize) -> QueryBuilder

Add an offset to the query

pub fn build(&self) -> Result<Query, Error>

Build a Query from the QueryBuilder and perform some checks

Trait Implementations

impl Clone for QueryBuilder

fn clone(&self) -> QueryBuilder

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QueryBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for QueryBuilder

fn default() -> QueryBuilder

Returns the “default value” for a type.