Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the cl-dbi-connection-pool Reference Manual, version 0.1, generated automatically by Declt version 2.4 patchlevel 1 "Will Decker" on Mon Apr 08 13:14:12 2019 GMT+0.
| • Introduction | What cl-dbi-connection-pool is all about | |
| • Systems | The systems documentation | |
| • Modules | The modules documentation | |
| • Files | The files documentation | |
| • Packages | The packages documentation | |
| • Definitions | The symbols documentation | |
| • Indexes | Concepts, functions, variables and data types |
This library provides connection pool for CL-DBI.
make connection pool.
(dbi-cp:make-db-connection-pool driver-name &key database-name username password (initial-size 10) (max-size 10)) ;; => dbi-cp:<dbi-connection-pool>
:sqlite, :mysql, :postgresql (same as CL-DBI)CL-DBI)CL-DBI)CL-DBI)(defparameter *CONNECTION-POOL*
(dbi-cp:make-dbi-connection-pool :mysql :database-name "dbi-cp" :username "root" :password "password"))
get database connection from connection pool.
(dbi-cp:get-connection connection-pool) ;; => dbi-cp.proxy:<dbi-connection-proxy>
(setf conn (dbi-cp:get-connection *CONNECTION-POOL*))
prepare SQL statement.
(dbi-cp:prepare connection sql) ;; => dbi.driver:<dbi-query>
this function is based on CL-DBI
execute SQL.
(dbi-cp:execute query &rest params) ;; => dbi.driver:<dbi-query>
prepare)this function is based on CL-DBI
fetch first row from query which is returned by execute.
(dbi-cp:fetch query) ;; => result
executethis function is based on CL-DBI
fetch all ret row from query.
(dbi-cp:fetch-all query) ;; => result
executethis function is based on CL-DBI
return the number of counts modified by last execute INSERT/UPDATE/DELETE query.
(dbi-cp:row-count connection) ;; => number
this function is based on CL-DBI
do preparation and execution at once for INSERT, UPDATE, DELETE or DDL.
(dbi-cp:do-sql connection sql &rest params)
this function is based on CL-DBI
start a transaction.
(dbi-cp:begin-transaction connection)
this function is based on CL-DBI
start a transaction and commit at the end of this block.
if the evaluation body is interrupted, the transaction is rolled back automatically.
(dbi-cp:with-transaction connection &body body)
this function is based on CL-DBI
(dbi-cp:commit connection)
this function is based on CL-DBI
(dbi-cp:rollback connection)
this function is based on CL-DBI
set a named transaction savepoint with a name of identifier.
(dbi-cp:savepoint connection identifier)
this function is based on CL-DBI
rollback a transaction to the named savepoint.
(dbi-cp:rollback-savepoint connection &optional identifier)
this function is based on CL-DBI
remove the named savepoint. no commit or rollback occurs.
(dbi-cp:release-savepoint connection &optional identifier)
this function is based on CL-DBI
;;;
;;; create connection pool
;;;
CL-USER> (defparameter *pool*
(dbi-cp:make-dbi-connection-pool :mysql
:database-name "test"
:username "root"
:password "password"))
*POOL*
;;;
;;; get database connection
;;;
CL-USER> (defparameter connection (dbi-cp:get-connection *pool*))
CONNECTION
CL-USER> connection
#<DBI-CP.PROXY:<DBI-CONNECTION-PROXY> {1002E23973}>
;;;
;;; execute DDL
;;;
CL-USER> (dbi-cp:do-sql connection "create table person (id integer primary key, name varchar(24) not null)")
; No value
;;;
;;; select
;;;
CL-USER> (let* ((query (dbi-cp:prepare connection "select count(*) from person"))
(result (dbi-cp:execute query)))
(format T "~A" (dbi-cp:fetch result)))
(count(*) 0)
NIL
;;;
;;; insert
;;;
CL-USER> (dbi-cp:begin-transaction connection)
; No value
CL-USER> (let* ((query (dbi-cp:prepare connection "insert into person (id, name) values (?, ?)")))
(dbi-cp:execute query 1 "user1")
(dbi-cp:execute query 2 "user2")
(dbi-cp:execute query 3 "user3"))
#<DBD.MYSQL:<DBD-MYSQL-QUERY> {1004B671F3}>
;;;
;;; select
;;;
CL-USER> (let* ((query (dbi-cp:prepare connection "select * from person"))
(result (dbi-cp:execute query)))
(dbi-cp:fetch-all result))
((:|id| 1 :|name| "user1") (:|id| 2 :|name| "user2") (:|id| 3 :|name| "user3"))
;;;
;;; rollback
;;;
CL-USER> (dbi-cp:rollback connection)
; No value
CL-USER> (let* ((query (dbi-cp:prepare connection "select count(*) from person"))
(result (dbi-cp:execute query)))
(format T "~A" (dbi-cp:fetch result)))
(count(*) 0)
NIL
This library is available on Quicklisp.
(ql:quickload :cl-dbi-connection-pool)
Copyright (c) 2017 tamura shingo (tamura.shingo@gmail.com)
Licensed under the LLGPL License.
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The cl-dbi-connection-pool system | ||
| • The dbi-cp system |
Next: The dbi-cp system, Previous: Systems, Up: Systems [Contents][Index]
tamura shingo
LLGPL
0.1
dbi-cp (system)
cl-dbi-connection-pool.asd (file)
Previous: The cl-dbi-connection-pool system, Up: Systems [Contents][Index]
tamura shingo
LLGPL
connection pool for CL-DBI
# CL-DBI-Connection-Pool - connection pool for CL-DBI
[](https://travis-ci.org/tamurashingo/cl-dbi-connection-pool)
This library provides connection pool for CL-DBI.
## Usage
### Create connection pool
make connection pool.
“‘common-lisp
(dbi-cp:make-db-connection-pool driver-name &key database-name username password (initial-size 10) (max-size 10)) ;; => dbi-cp:<dbi-connection-pool>
“‘
- driver-name
- ‘:sqlite‘, ‘:mysql‘, ‘:postgresql‘ (same as ‘CL-DBI‘)
- database-name
- database name (same as ‘CL-DBI‘)
- username
- username (same as ‘CL-DBI‘)
- password
- password (same as ‘CL-DBI‘)
- initial-size
- initial number of connections that are created when the pool is started
- max-size
- maximum number of connections
“‘common-lisp
(defparameter *CONNECTION-POOL*
(dbi-cp:make-dbi-connection-pool :mysql :database-name "dbi-cp" :username "root" :password "password"))
“‘
### Get connection
get database connection from connection pool.
“‘common-lisp
(dbi-cp:get-connection connection-pool) ;; => dbi-cp.proxy:<dbi-connection-proxy>
“‘
- connection-pool (dbi-cp:<dbi-connection-pool>)
- connection pool
“‘common-lisp
(setf conn (dbi-cp:get-connection *CONNECTION-POOL*))
“‘
### prepare, execute, fetch ...
#### Prepare
prepare SQL statement.
“‘common-lisp
(dbi-cp:prepare connection sql) ;; => dbi.driver:<dbi-query>
“‘
- connection (dbi-cp.proxy:<dbi-connection-proxy>)
- database connection
- sql
- SQL statement
this function is based on ‘CL-DBI‘
#### Execute
execute SQL.
“‘common-lisp
(dbi-cp:execute query &rest params) ;; => dbi.driver:<dbi-query>
“‘
- query (dbi.driver:<dbi-query>)
- precompiled query (returned by ‘prepare‘)
- params
- SQL parameters
this function is based on ‘CL-DBI‘
#### Fetch
fetch first row from ‘query‘ which is returned by ‘execute‘.
“‘common-lisp
(dbi-cp:fetch query) ;; => result
“‘
- query (dbi.driver:<dbi-query>)
- returned by ‘execute‘
this function is based on ‘CL-DBI‘
### Fetch all
fetch all ret row from ‘query‘.
“‘common-lisp
(dbi-cp:fetch-all query) ;; => result
“‘
- query (dbi.driver:<dbi-query>)
- returned by ‘execute‘
this function is based on ‘CL-DBI‘
#### row count
return the number of counts modified by last execute INSERT/UPDATE/DELETE query.
“‘common-lisp
(dbi-cp:row-count connection) ;; => number
“‘
- connection (dbi-cp.proxy:<dbi-connection-proxy>)
- database connection
this function is based on ‘CL-DBI‘
#### do sql
do preparation and execution at once for INSERT, UPDATE, DELETE or DDL.
“‘common-lisp
(dbi-cp:do-sql connection sql &rest params)
“‘
- connection (dbi-cp.proxy:<dbi-connection-proxy>)
- database connection
- sql
- SQL statement
- params
- SQL parameters
this function is based on ‘CL-DBI‘
### Transaction
#### Start transaction
start a transaction.
“‘common-lisp
(dbi-cp:begin-transaction connection)
“‘
- connection (dbi-cp.proxy:<dbi-connection-proxy>)
- database connection
this function is based on ‘CL-DBI‘
#### create transaction block
start a transaction and commit at the end of this block.
if the evaluation ‘body‘ is interrupted, the transaction is rolled back automatically.
“‘common-lisp
(dbi-cp:with-transaction connection &body body)
“‘
- connection (dbi-cp.proxy:<dbi-connection-proxy>)
- database connection
- body
- body
this function is based on ‘CL-DBI‘
#### commit
“‘common-lisp
(dbi-cp:commit connection)
“‘
- connection (dbi-cp.proxy:<dbi-connection-proxy>)
- database connection
this function is based on ‘CL-DBI‘
#### rollback
“‘common-lisp
(dbi-cp:rollback connection)
“‘
- connection (dbi-cp.proxy:<dbi-connection-proxy>)
- database connection
this function is based on ‘CL-DBI‘
#### savepoint
set a named transaction savepoint with a name of ‘identifier‘.
“‘common-lisp
(dbi-cp:savepoint connection identifier)
“‘
- connection (dbi-cp.proxy:<dbi-connection-proxy>)
- database connection
- identifier
- name of transaction savepoint
this function is based on ‘CL-DBI‘
#### rollback savepoint
rollback a transaction to the named savepoint.
“‘common-lisp
(dbi-cp:rollback-savepoint connection &optional identifier)
“‘
- connection (dbi-cp.proxy:<dbi-connection-proxy>)
- database connection
- identifier
- name of transaction savepoint
this function is based on ‘CL-DBI‘
#### release savepoint
remove the named savepoint. no commit or rollback occurs.
“‘common-lisp
(dbi-cp:release-savepoint connection &optional identifier)
“‘
- connection (dbi-cp.proxy:<dbi-connection-proxy>)
- database connection
- identifier
- name of transaction savepoint
this function is based on ‘CL-DBI‘
## Example
“‘common-lisp
;;;
;;; create connection pool
;;;
CL-USER> (defparameter *pool*
(dbi-cp:make-dbi-connection-pool :mysql
:database-name "test"
:username "root"
:password "password"))
*POOL*
;;;
;;; get database connection
;;;
CL-USER> (defparameter connection (dbi-cp:get-connection *pool*))
CONNECTION
CL-USER> connection
#<DBI-CP.PROXY:<DBI-CONNECTION-PROXY> {1002E23973}>
;;;
;;; execute DDL
;;;
CL-USER> (dbi-cp:do-sql connection "create table person (id integer primary key, name varchar(24) not null)")
; No value
;;;
;;; select
;;;
CL-USER> (let* ((query (dbi-cp:prepare connection "select count(*) from person"))
(result (dbi-cp:execute query)))
(format T "~A" (dbi-cp:fetch result)))
(count(*) 0)
NIL
;;;
;;; insert
;;;
CL-USER> (dbi-cp:begin-transaction connection)
; No value
CL-USER> (let* ((query (dbi-cp:prepare connection "insert into person (id, name) values (?, ?)")))
(dbi-cp:execute query 1 "user1")
(dbi-cp:execute query 2 "user2")
(dbi-cp:execute query 3 "user3"))
#<DBD.MYSQL:<DBD-MYSQL-QUERY> {1004B671F3}>
;;;
;;; select
;;;
CL-USER> (let* ((query (dbi-cp:prepare connection "select * from person"))
(result (dbi-cp:execute query)))
(dbi-cp:fetch-all result))
((:|id| 1 :|name| "user1") (:|id| 2 :|name| "user2") (:|id| 3 :|name| "user3"))
;;;
;;; rollback
;;;
CL-USER> (dbi-cp:rollback connection)
; No value
CL-USER> (let* ((query (dbi-cp:prepare connection "select count(*) from person"))
(result (dbi-cp:execute query)))
(format T "~A" (dbi-cp:fetch result)))
(count(*) 0)
NIL
“‘
## Installation
This library is available on Quicklisp.
“‘commonlisp
(ql:quickload :cl-dbi-connection-pool)
“‘
## Author
* tamura shingo (tamura.shingo@gmail.com)
## Copyright
Copyright (c) 2017 tamura shingo (tamura.shingo@gmail.com)
## License
Licensed under the LLGPL License.
0.1
dbi-cp.asd (file)
src (module)
Modules are listed depth-first from the system components tree.
| • The dbi-cp/src module |
dbi-cp (system)
src/
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files |
Next: The dbi-cp<dot>asd file, Previous: Lisp files, Up: Lisp files [Contents][Index]
cl-dbi-connection-pool.asd
cl-dbi-connection-pool (system)
Next: The dbi-cp/src/dbi-cp<dot>lisp file, Previous: The cl-dbi-connection-pool<dot>asd file, Up: Lisp files [Contents][Index]
dbi-cp.asd
dbi-cp (system)
Next: The dbi-cp/src/connectionpool<dot>lisp file, Previous: The dbi-cp<dot>asd file, Up: Lisp files [Contents][Index]
connectionpool.lisp (file)
src (module)
src/dbi-cp.lisp
show-connection-pool (function)
Next: The dbi-cp/src/proxy<dot>lisp file, Previous: The dbi-cp/src/dbi-cp<dot>lisp file, Up: Lisp files [Contents][Index]
src (module)
src/connectionpool.lisp
Next: The dbi-cp/src/error<dot>lisp file, Previous: The dbi-cp/src/connectionpool<dot>lisp file, Up: Lisp files [Contents][Index]
src (module)
src/proxy.lisp
proxy (macro)
Previous: The dbi-cp/src/proxy<dot>lisp file, Up: Lisp files [Contents][Index]
src (module)
src/error.lisp
<dbi-cp-no-connection> (condition)
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The cl-dbi-connection-pool-asd package | ||
| • The dbi-cp-asd package | ||
| • The dbi-cp package | ||
| • The dbi-cp.connectionpool package | ||
| • The dbi-cp.proxy package | ||
| • The dbi-cp.error package |
Next: The dbi-cp-asd package, Previous: Packages, Up: Packages [Contents][Index]
cl-dbi-connection-pool.asd
Next: The dbi-cp package, Previous: The cl-dbi-connection-pool-asd package, Up: Packages [Contents][Index]
dbi-cp.asd
Next: The dbi-cp<dot>connectionpool package, Previous: The dbi-cp-asd package, Up: Packages [Contents][Index]
dbi-cp.lisp (file)
cl-dbi-connection-pool
common-lisp
show-connection-pool (function)
Next: The dbi-cp<dot>proxy package, Previous: The dbi-cp package, Up: Packages [Contents][Index]
connectionpool.lisp (file)
common-lisp
Next: The dbi-cp<dot>error package, Previous: The dbi-cp<dot>connectionpool package, Up: Packages [Contents][Index]
proxy.lisp (file)
proxy (macro)
Previous: The dbi-cp<dot>proxy package, Up: Packages [Contents][Index]
error.lisp (file)
common-lisp
<dbi-cp-no-connection> (condition)
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions | ||
| • Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported functions | ||
| • Exported generic functions | ||
| • Exported conditions | ||
| • Exported classes |
Next: Exported generic functions, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
make connection pool
Example
(make-dbi-connection-pool :mysql :database-name "dbicp" :username "root" :password "password")
connectionpool.lisp (file)
Next: Exported conditions, Previous: Exported functions, Up: Exported definitions [Contents][Index]
automatically generated reader method
proxy.lisp (file)
automatically generated writer method
proxy.lisp (file)
automatically generated reader method
proxy.lisp (file)
automatically generated writer method
proxy.lisp (file)
get <dbi-connection-proxy> from connection pool
connectionpool.lisp (file)
disconnect all connections
connectionpool.lisp (file)
Next: Exported classes, Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
Exception raised when no connection found on connection pool
error.lisp (file)
simple-error (condition)
Previous: Exported conditions, Up: Exported definitions [Contents][Index]
connectionpool.lisp (file)
standard-object (class)
array of <pooled-connection>
array
:pool
function what connecto to database
function
:connect-fn
proxy.lisp (file)
standard-object (class)
dbi-cp.proxy::<dbi-connection>
:dbi-connection
dbi-connection (generic function)
(setf dbi-connection) (generic function)
0
function
:disconnect-fn
disconnect-fn (generic function)
(setf disconnect-fn) (generic function)
Previous: Exported definitions, Up: Definitions [Contents][Index]
| • Internal macros | ||
| • Internal functions | ||
| • Internal generic functions | ||
| • Internal classes |
Next: Internal functions, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
just a mark
proxy.lisp (file)
Next: Internal generic functions, Previous: Internal macros, Up: Internal definitions [Contents][Index]
connect database and set parameters
connectionpool.lisp (file)
create connection array
connectionpool.lisp (file)
create <pooled-connection> instance
connectionpool.lisp (file)
for debug
dbi-cp.lisp (file)
Next: Internal classes, Previous: Internal functions, Up: Internal definitions [Contents][Index]
T when already connected database
connectionpool.lisp (file)
automatically generated reader method
connectionpool.lisp (file)
automatically generated writer method
connectionpool.lisp (file)
automatically generated reader method
connectionpool.lisp (file)
automatically generated writer method
connectionpool.lisp (file)
Previous: Internal generic functions, Up: Internal definitions [Contents][Index]
connectionpool.lisp (file)
standard-object (class)
T when already connected database
boolean
connect-p (generic function)
(setf connect-p) (generic function)
(bt-semaphore:make-semaphore :count 1)
semaphore (generic function)
(setf semaphore) (generic function)
dbi-cp.proxy:<dbi-connection-proxy>
:dbi-connection-proxy
dbi-connection-proxy (generic function)
(setf dbi-connection-proxy) (generic function)
Previous: Definitions, Up: Top [Contents][Index]
| • Concept index | ||
| • Function index | ||
| • Variable index | ||
| • Data type index |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
| Jump to: | C D F L M |
|---|
| Jump to: | C D F L M |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | %
(
C D F G M P S |
|---|
| Jump to: | %
(
C D F G M P S |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
| Jump to: | C D I P S |
|---|
| Jump to: | C D I P S |
|---|
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | <
C D P S |
|---|
| Jump to: | <
C D P S |
|---|