mssql 2.0.3 · OCaml Package

module Error : sig ... end

module Param : sig ... end

module Row : sig ... end

type t

val with_conn : 
  host:string ->
  db:string ->
  user:string ->
  password:string ->
  ?port:int ->
  (t -> 'a Async_kernel.Deferred.t) ->
  'a Async_kernel.Deferred.t

Opens a connection, runs the callback, then closes the connection. Don't try to use the DB handle outside of the callback, since it will have been closed automatically.

val execute : 
  ?params:Mssql__.Db_field.t option list ->
  t ->
  string ->
  Row.t list Async_kernel.Deferred.t

Executes an SQL query, handling parameter quoting for you. Do not use sprintf to generate queries; instead pass parameters like this:

let params = [ Some (Mssql.Param.String "look no ' sql injection\x00!") ] in
Mssql.execute ~params "SELECT $1"

Returns a single result set and throws an exception if the result has more than one result set.

val execute_map : 
  ?params:Mssql__.Db_field.t option list ->
  f:(Row.t -> 'a) ->
  t ->
  string ->
  'a list Async_kernel.Deferred.t

val execute_iter : 
  ?params:Mssql__.Db_field.t option list ->
  f:(Row.t -> unit) ->
  t ->
  string ->
  unit Async_kernel.Deferred.t

val execute_fold : 
  ?params:Mssql__.Db_field.t option list ->
  init:'a ->
  f:('a -> Row.t -> 'a) ->
  t ->
  string ->
  'a Async_kernel.Deferred.t

val execute_pipe : 
  ?params:Mssql__.Db_field.t option list ->
  t ->
  string ->
  Row.t Async_kernel.Pipe.Reader.t

val execute_unit : 
  ?params:Mssql__.Db_field.t option list ->
  t ->
  string ->
  unit Async_kernel.Deferred.t

Like execute but asserts that the result set will be empty.

val execute_single : 
  ?params:Mssql__.Db_field.t option list ->
  t ->
  string ->
  Row.t option Async_kernel.Deferred.t

Like execute but asserts that the result set will return a maximum of 1 row.

val execute_multi_result : 
  ?params:Mssql__.Db_field.t option list ->
  t ->
  string ->
  Row.t list list Async_kernel.Deferred.t

Like execute but returns all result sets. Useful for running multiple queries at once.

val execute_many : 
  params:Mssql__.Db_field.t option list list ->
  t ->
  string ->
  Row.t list list Async_kernel.Deferred.t

List execute except runs multiple identical queries at the same time, with different parameters. Takes a list of param lists and returns a list of results sets, as if you called List.map params ~f:(fun params -> execute ~params db query)

val begin_transaction : t -> unit Async_kernel.Deferred.t

Begin a transaction

val commit : t -> unit Async_kernel.Deferred.t

Commit the current transaction

val rollback : t -> unit Async_kernel.Deferred.t

Rollback the current transaction

val with_transaction : 
  t ->
  (t -> 'a Async_kernel.Deferred.t) ->
  'a Async_kernel.Deferred.t

with_transaction t f runs f in a transaction. If the function returns normally, the transaction will be commited. If the function throws an exception, the transaction will be rolled back and the exception will be re-raised.

Note regarding the t argument to the callback: There is logic to ensure that queries outside of the transaction are blocked until the transaction finishes, so you *must* use the t passed in the callback, not the original handle inside of the transaction. To prevent deadlocks, an exception will be thrown if you use the external DB handle inside of with_transaction.

val with_transaction_or_error : 
  t ->
  (t -> 'a Async_kernel.Deferred.Or_error.t) ->
  'a Async_kernel.Deferred.Or_error.t

Like with_transaction but also rolls back the transaction on Error

exception Error of Error.t

package mssql