package caqti

You can search for identifiers within the package.

in-package search v0.2.0

package caqti

caqti
- Caqti_common
- Caqti_common_priv
  - Alog
  - List
  - Option
  - Result
- Caqti_connect
  - Make_unix
    
    CONNECTION
    
    Response
    
    Pool
    
    System
    
    Log
    
    Mvar
    
    Preemptive
    
    Stream
    
    Unix
- Caqti_connection
  - Make_convenience
    
    C
    
    Response
    
    Sys
    
    Log
    
    Mvar
    
    Stream
  - Make_helpers
    
    Sys
    
    Log
    
    Mvar
    
    Stream
  - Make_populate
    
    C
    
    Response
    
    Sys
    
    Log
    
    Mvar
    
    Stream
- Caqti_driver_info
- Caqti_driver_lib
- Caqti_error
- Caqti_heap
  - Make
  - S
- Caqti_mult
- Caqti_pool
  - Make
    
    System
    
    Log
    
    Mvar
    
    Stream
- Caqti_query
- Caqti_request
  - Infix
- Caqti_sql
- Caqti_sql_io
  - MONAD
  - Make
    
    Io
  - S
- Caqti_stream
  - FUTURE
  - Make
    
    X
  - S
- Caqti_type
  - Field
  - Std
caqti.blocking
- Caqti_blocking
  - CONNECTION
    
    Response
  - Pool
  - Stream
- Caqti_blocking_sql_io

Legend:
Library
Module
Module type
Parameter
Class
Class type

The connection API specialized for the current concurrency library.

val driver_info : Caqti_driver_info.t

Information about the driver providing this connection module.

val driver_connection : Caqti_connection_sig.driver_connection option

The underlying connection object of the driver if available. The open variant constructor is defined in the driver library. This is currently only implemented for caqti-driver-sqlite3 for the purpose of defining custom functions.

include Caqti_connection_sig.Base
  with type 'a future := 'a future
  with type ('a, 'err) stream := ('a, 'err) Stream.t

Query

module Response : 
  Caqti_response_sig.S
    with type 'a future := 'a future
     and type ('a, 'err) stream := ('a, 'err) Stream.t

val call : 
  f:(('b, 'm) Response.t -> ('c, 'e) Stdlib.result future) ->
  ('a, 'b, 'm) Caqti_request.t ->
  'a ->
  ('c, [> Caqti_error.call ] as 'e) Stdlib.result future

call ~f request params performs request with parameters params invoking f to process the result. The argument of f is only valid during the call to f, and must not be returned or operated on by other threads.

val set_statement_timeout : 
  float option ->
  (unit, [> Caqti_error.call ]) Stdlib.result future

Set or clear the timeout after which a running SQL statement will be terminated if supported by the driver. This is currently supported for MariaDB (using max_statement_time) and PostgreSQL (using statement_timeout) and has no effect for SQLite3.

Transactions

val start : unit -> (unit, [> Caqti_error.transact ]) Stdlib.result future

Starts a transaction if supported by the underlying database, otherwise does nothing.

val commit : unit -> (unit, [> Caqti_error.transact ]) Stdlib.result future

Commits the current transaction if supported by the underlying database, otherwise does nothing.

val rollback : unit -> (unit, [> Caqti_error.transact ]) Stdlib.result future

Rolls back a transaction if supported by the underlying database, otherwise does nothing.

Disconnection and Reuse

val deallocate : 
  ('a, 'b, 'm) Caqti_request.t ->
  (unit, [> Caqti_error.call ]) Stdlib.result future

deallocate req deallocates the prepared query for req if it was allocated. The request must not be oneshot.

val disconnect : unit -> unit future

Calling disconnect () closes the connection to the database and frees up related resources.

val validate : unit -> bool future

For internal use by Caqti_pool. Tries to ensure the validity of the connection and must return false if unsuccessful.

val check : (bool -> unit) -> unit

For internal use by Caqti_pool. Called after a connection has been used. check f must call f () exactly once with an argument indicating whether to keep the connection in the pool or discard it.

include Caqti_connection_sig.Convenience with type 'a future := 'a future

Retrieval Convenience

These are shortcuts for call combined with retrieval functions from Caqti_response_sig.S of the same name.

val exec : 
  ('a, unit, [< `Zero ]) Caqti_request.t ->
  'a ->
  (unit, [> Caqti_error.call_or_retrieve ] as 'e) Stdlib.result future

Combining call with Response.exec, this sends a request to the database and checks that no rows are returned.

val exec_with_affected_count : 
  ('a, unit, [< `Zero ]) Caqti_request.t ->
  'a ->
  (int, [> Caqti_error.call_or_retrieve ] as 'e) Stdlib.result future

Combining call with Response.exec and Response.affected_count, this sends a request to the database, checks that no rows are returned and returns the number of affected rows.

val find : 
  ('a, 'b, [< `One ]) Caqti_request.t ->
  'a ->
  ('b, [> Caqti_error.call_or_retrieve ] as 'e) Stdlib.result future

Combining call with Response.find, this sends a request to the database, checks that a single row is returned, and extracts it.

val find_opt : 
  ('a, 'b, [< `Zero | `One ]) Caqti_request.t ->
  'a ->
  ('b option, [> Caqti_error.call_or_retrieve ] as 'e) Stdlib.result future

Combining call with Response.find_opt, this sends a request to the database, checks that at most one row is returned, and extracts it if present.

val fold : 
  ('a, 'b, [< `Zero | `One | `Many ]) Caqti_request.t ->
  ('b -> 'c -> 'c) ->
  'a ->
  'c ->
  ('c, [> Caqti_error.call_or_retrieve ] as 'e) Stdlib.result future

Combining call with Response.fold, this sends a request to the database and folds over the result rows.

val fold_s : 
  ('a, 'b, [< `Zero | `One | `Many ]) Caqti_request.t ->
  ('b -> 'c -> ('c, 'e) Stdlib.result future) ->
  'a ->
  'c ->
  ('c, [> Caqti_error.call_or_retrieve ] as 'e) Stdlib.result future

Combining call with Response.fold_s, this sends a request to the database and folds sequentially over the result rows in a non-blocking manner.

Please be aware of possible deadlocks when using resources from the callback. In particular, if the same connection pool is invoked as the one used to obtain the current connection, it will deadlock if the pool has just run out of connections. An alternative is to collect the rows first e.g. with fold and do the nested queries after exiting.

val iter_s : 
  ('a, 'b, [< `Zero | `One | `Many ]) Caqti_request.t ->
  ('b -> (unit, 'e) Stdlib.result future) ->
  'a ->
  (unit, [> Caqti_error.call_or_retrieve ] as 'e) Stdlib.result future

Combining call with Response.iter_s, this sends a request to the database and iterates sequentially over the result rows in a non-blocking manner. Please see the warning in fold_s about resource usage in the callback.

val collect_list : 
  ('a, 'b, [< `Zero | `One | `Many ]) Caqti_request.t ->
  'a ->
  ('b list, [> Caqti_error.call_or_retrieve ] as 'e) Stdlib.result future

collect_list request param performs a call on request, extracting the result as a list.

val rev_collect_list : 
  ('a, 'b, [< `Zero | `One | `Many ]) Caqti_request.t ->
  'a ->
  ('b list, [> Caqti_error.call_or_retrieve ] as 'e) Stdlib.result future

rev_collect_list request param performs a call on request, extracting the result as a reversed list. This is more efficient than collect_list and fits well with a subsequent List.rev_map, though it may not matter much in practise.

Transactions

val with_transaction : 
  (unit -> ('a, 'e) Stdlib.result future) ->
  ('a, [> Caqti_error.transact ] as 'e) Stdlib.result future

with_transaction f wraps f in a transaction which is committed iff f returns Ok _.

include Caqti_connection_sig.Populate
  with type 'a future := 'a future
   and type ('a, 'err) stream := ('a, 'err) Stream.t

Insertion

val populate : 
  table:string ->
  columns:string list ->
  'a Caqti_type.t ->
  ('a, 'err) Stream.t ->
  (unit, [> Caqti_error.call_or_retrieve | `Congested of 'err ]) Stdlib.result
    future

populate table columns row_type seq inputs the contents of seq into the database in whatever manner is most efficient as decided by the driver.