gmysql

Types

Config

pub type Config {
  Config(
    host: String,
    port: Int,
    user: Option(String),
    password: Option(String),
    database: String,
    connection_mode: ConnectionMode,
    connection_timeout: Timeout,
    keep_alive: Int,
  )
}

Constructors

Config(
  host: String,
  port: Int,
  user: Option(String),
  password: Option(String),
  database: String,
  connection_mode: ConnectionMode,
  connection_timeout: Timeout,
  keep_alive: Int,
)

Connection

</>

pub type Connection

ConnectionMode

</>

pub type ConnectionMode {
  Synchronous
  Asynchronous
  Lazy
}

Constructors

```
Synchronous
```
```
Asynchronous
```
```
Lazy
```

Error

</>

pub type Error {
  ServerError(Int, BitArray)
  UnknownError(Dynamic)
  DecodeError(dynamic.DecodeErrors)
}

Constructors

```
ServerError(Int, BitArray)
```
```
UnknownError(Dynamic)
```
```
DecodeError(dynamic.DecodeErrors)
```

Param

</>

pub type Param

Timeout

</>

pub type Timeout {
  Infinity
  Ms(Int)
}

Constructors

```
Infinity
```
```
Ms(Int)
```

TransactionError

</>

pub type TransactionError(a) {
  FunctionError(a)
  OtherError(Dynamic)
}

Constructors

```
FunctionError(a)
```
```
OtherError(Dynamic)
```

Functions

connect

</>

pub fn connect(config: Config) -> Result(Connection, Dynamic)

default_config

</>

pub fn default_config() -> Config

disconnect

</>

pub fn disconnect(connection: Connection) -> Nil

exec

</>

pub fn exec(
  sql: String,
  on connection: Connection,
) -> Result(Nil, Error)

exec_with_timeout

</>

pub fn exec_with_timeout(
  sql: String,
  on connection: Connection,
  until timeout: Timeout,
) -> Result(Nil, Error)

from_pid

</>

pub fn from_pid(connection: Pid) -> Connection

Danger, this is primarily for internal use, do not pass in pids that you did not get from the to_pid/1 function.

null_param

</>

pub fn null_param() -> Param

query

</>

pub fn query(
  sql: String,
  on connection: Connection,
  with arguments: List(Param),
  expecting decoder: fn(Dynamic) -> Result(a, List(DecodeError)),
) -> Result(List(a), Error)

query_with_timeout

</>

pub fn query_with_timeout(
  sql: String,
  on connection: Connection,
  with arguments: List(Param),
  expecting decoder: fn(Dynamic) -> Result(a, List(DecodeError)),
  until timeout: Timeout,
) -> Result(List(a), Error)

to_param

</>

pub fn to_param(param: a) -> Param

to_pid

</>

pub fn to_pid(connection: Connection) -> Pid

with_connection

</>

pub fn with_connection(
  config: Config,
  with function: fn(Connection) -> a,
) -> Result(a, Dynamic)

with_transaction

</>

pub fn with_transaction(
  connection: Connection,
  retry retries: Int,
  with function: fn(Connection) -> Result(a, b),
) -> Result(a, TransactionError(b))

Execute a function within a transaction. If the function throws or returns an error, it will rollback. You can nest this function, which will create a savepoint.