yummy

Types

Eq

pub type Eq {
  Equals(col: String, value: Value)
  Not(Eq)
  Or(Eq, Eq)
  And(Eq, Eq)
}

Constructors

```
Equals(col: String, value: Value)
```
```
Not(Eq)
```
```
Or(Eq, Eq)
```
```
And(Eq, Eq)
```

QueryBuilder

</>

pub type QueryBuilder {
  QueryBuilder(
    table: schema.Table,
    select_columns: List(String),
    where_clauses: List(Eq),
    order_by_clauses: List(String),
  )
}

Constructors

QueryBuilder(
  table: schema.Table,
  select_columns: List(String),
  where_clauses: List(Eq),
  order_by_clauses: List(String),
)

Value

</>

pub type Value {
  IntValue(Int)
  StringValue(String)
  BoolValue(Bool)
  ErrorValue(String)
}

Constructors

```
IntValue(Int)
```
```
StringValue(String)
```
```
BoolValue(Bool)
```
```
ErrorValue(String)
```

WhereBuilder

</>

pub type WhereBuilder {
  WhereBuilder(table: schema.Table, clauses: List(Eq))
}

Constructors

WhereBuilder(table: schema.Table, clauses: List(Eq))

Functions

and

</>

pub fn and(builder: WhereBuilder) -> WhereBuilder

equals

</>

pub fn equals(
  builder: WhereBuilder,
  col: String,
  value: a,
) -> WhereBuilder

new

</>

pub fn new(table: Table) -> QueryBuilder

not

</>

pub fn not(builder: WhereBuilder) -> WhereBuilder

or

</>

pub fn or(builder: WhereBuilder) -> WhereBuilder

order_by

</>

pub fn order_by(
  builder: QueryBuilder,
  column: String,
  direction: String,
) -> QueryBuilder

select

</>

pub fn select(builder: QueryBuilder) -> QueryBuilder

to_sql

</>

pub fn to_sql(builder: QueryBuilder) -> Result(String, String)

wb

</>

pub fn wb(table: Table) -> WhereBuilder

where

</>

pub fn where(
  builder: QueryBuilder,
  condition: WhereBuilder,
) -> QueryBuilder