# `Exqlite.Sqlite3NIF`
[🔗](https://github.com/elixir-sqlite/exqlite/blob/v0.36.0/lib/exqlite/sqlite3_nif.ex#L1)

This is the module where all of the NIF entry points reside. Calling this directly
should be avoided unless you are aware of what you are doing.

# `db`

```elixir
@type db() :: reference()
```

# `reason`

```elixir
@type reason() :: :atom | String.Chars.t()
```

# `row`

```elixir
@type row() :: list()
```

# `statement`

```elixir
@type statement() :: reference()
```

# `bind_blob`

```elixir
@spec bind_blob(statement(), non_neg_integer(), binary()) :: integer()
```

# `bind_float`

```elixir
@spec bind_float(statement(), non_neg_integer(), float()) :: integer()
```

# `bind_integer`

```elixir
@spec bind_integer(statement(), non_neg_integer(), integer()) :: integer()
```

# `bind_null`

```elixir
@spec bind_null(statement(), non_neg_integer()) :: integer()
```

# `bind_parameter_count`

```elixir
@spec bind_parameter_count(statement()) :: integer()
```

# `bind_parameter_index`

```elixir
@spec bind_parameter_index(statement(), String.t()) :: integer()
```

# `bind_text`

```elixir
@spec bind_text(statement(), non_neg_integer(), String.t()) :: integer()
```

# `changes`

```elixir
@spec changes(db()) :: {:ok, integer()} | {:error, reason()}
```

# `close`

```elixir
@spec close(db()) :: :ok | {:error, reason()}
```

# `columns`

```elixir
@spec columns(db(), statement()) :: {:ok, [binary()]} | {:error, reason()}
```

# `deserialize`

```elixir
@spec deserialize(db(), String.t(), binary()) :: :ok | {:error, reason()}
```

# `enable_load_extension`

```elixir
@spec enable_load_extension(db(), integer()) :: :ok | {:error, reason()}
```

# `errmsg`

```elixir
@spec errmsg(db() | statement()) :: String.t() | nil
```

# `errstr`

```elixir
@spec errstr(integer()) :: String.t()
```

# `execute`

```elixir
@spec execute(db(), String.t()) :: :ok | {:error, reason()}
```

# `interrupt`

```elixir
@spec interrupt(db()) :: :ok | {:error, reason()}
```

# `last_insert_rowid`

```elixir
@spec last_insert_rowid(db()) :: {:ok, integer()}
```

# `load_nif`

# `multi_step`

```elixir
@spec multi_step(db(), statement(), integer()) ::
  :busy | {:rows, [row()]} | {:done, [row()]} | {:error, reason()}
```

# `open`

```elixir
@spec open(String.t(), integer()) :: {:ok, db()} | {:error, reason()}
```

# `prepare`

```elixir
@spec prepare(db(), String.t()) :: {:ok, statement()} | {:error, reason()}
```

# `release`

```elixir
@spec release(db(), statement()) :: :ok | {:error, reason()}
```

# `reset`

```elixir
@spec reset(statement()) :: :ok
```

# `serialize`

```elixir
@spec serialize(db(), String.t()) :: {:ok, binary()} | {:error, reason()}
```

# `set_authorizer`

```elixir
@spec set_authorizer(db(), [atom()]) :: :ok | {:error, reason()}
```

# `set_log_hook`

```elixir
@spec set_log_hook(pid()) :: :ok | {:error, reason()}
```

# `set_update_hook`

```elixir
@spec set_update_hook(db(), pid()) :: :ok | {:error, reason()}
```

# `step`

```elixir
@spec step(db(), statement()) :: :done | :busy | {:row, row()} | {:error, reason()}
```

# `transaction_status`

```elixir
@spec transaction_status(db()) :: {:ok, :idle | :transaction}
```

---

*Consult [api-reference.md](api-reference.md) for complete listing*