Postmodern is an interface to PostgreSQL SQL databases. Features:
Efficient communication with the database server without need for foreign libraries.
Support for UTF-8 on Lisp implementations with Unicode support
A lispy syntax for expressing SQL queries
Convenient support for prepared statements and stored procedures
Defclass-like definition of tables and associated accessor classes
It supports PostgreSQL versions up from 7.4, and is theoretically portable across Lisp implementations, though not much testing has been done yet.License: BSD-styleHomepage: http://marijn.haverbeke.nl/postmodern/
CL-DBI is intended to provide the same SQL interface for each database.Not only, you don't have to learn each API of databases anymore, but this layer is especially convenient when you want to use the different database by environment.For example, your application had better to use efficient database such as MySQL on the production environment, but you may want to use SQLite3 on your machine. In that case, all what you have to do is only to rewrite calling "dbi:connect".Homepage: fukamachi.github.com/cl-dbiLicense: LLGPL
cl-fbclient is an interface to Firebird SQL databases. Source: https://github.com/klimenko-serj/cl-fbclientWiki: http://github.com/klimenko-serj/cl-fbclient/wiki
(cl-fbclient:fb-with-database (DB :path "/path-to-db/db-file.fdb")
(cl-fbclient:fb-query "SELECT * FROM T1" :db DB)
(cl-fbclient:fb-query "INSERT INTO T1(A1,A2) VALUES(121, 42)" :db DB)
(cl-fbclient:fb-query "SELECT * FROM T1" :db DB))
cl-migrations is a port of Ruby on Rails migrations feature to CL. It provides a simple way to version-control your database changes. As a web project grows, it's database will go through numerous structural changes, but if things go wrong with a new version, there should be a proper way to disable new changes to database and bring it back to a previously known good position. Rails has a very simple and neat way of doing this, so I have ported the feature to CL. Homepage: http://common-lisp.net/project/cl-migrations/.Author: Vamsee KanakalaLicence: MIT
cl-mssql is an interface to Microsoft SQL Server databases.License: MITHomepage: http://code.google.com/p/cl-mssql/
Common Lisp MySQL library bindings
CL-SQLITE package is an interface to the SQLite embedded relational database engine.
Common Lisp SQL Interface library
Pg is a socket-level interface to the PostgreSQL object-relational Database.
Pg implements the client part of the frontend/backend
protocol, so does not require interfacing with the libpq library. SQL
types are converted to the equivalent Common Lisp types where
possible. Supports large objects (BLOBs).
Postmodern is a newer and much-much cleaner library. Its cl-postgres asdf system implements the same functionality as Pg -- Attila Lendvai
The only non portable code is the use of SOCKET-CONNECT. Versions are
provided for CMU Common Lisp (CMUCL), SBCL, OpenMCL, CLISP, LispWorks and Allegro Common Lisp (ACL). Corman CL doesn't support binary I/O on socket streams, so it doesn't work there.Pg is available under the GNU LGPL licence from www.chez.com/emarsden/downloads.
There are also Emacs Lisp and scsh versions of the library.This is a snapshot of the CVS repository at common-lisp.net/project/pg and it is not GPG signed.Here is the last released version, but it's quite old:http://www.chez.com/emarsden/downloads/pg-dot-lisp-0.19.tar.gzSample code:
(with-pg-connection (conn "testdb" "login" :host "dbhost" :password "secret")
(when (member "test_date" (pg-tables conn) :test #'string=)
(pg-exec conn "DROP TABLE test_date"))
(pg-exec conn "CREATE TABLE test_date(a timestamp, b abstime, c time, d date)")
(pg-exec conn "INSERT INTO test_date VALUES "
"(current_timestamp, 'now', 'now', 'now')")))
Stargreen Box Office uses Pg for its database glue layer; it's respectably fast, simple enough to see what it's doing, and impervious to PostgreSQL shared library versioning issues (because it doesn't use them). I'm very happy with it -- Daniel Barlow
You must set unix_socket_directory in your postgresql.conf to /var/run/postgresql
pg doesn't use the default path for the unix domain socket. See Socket Path.
Plain-odbc is a simple, yet powerful Common Lisp ODBC interface.
It is possible to use parameterized queries with in and out parameters and call stored procedures.
In principle it should be possible to use any database which offers an ODBC interface (even MS Excel and MS Access).The primary development platform is CLISP on win32, but plain-odbc is also usable with CLISP on Linux with unixODBC. High level features such as a special reader syntax for sql or mapping of CLOS objects to database tables are not part of plain-odbc.The low level parts of the system consist of code from Paul Meurers sqlodbc module.
The system uses now CFFI to interface to the ODBC C functions.More Information can be found at the project page.
Submarine is a Common Lisp library that's somewhere between a PostgreSQL library an an object persistency system. It uses Postmodern to communicate with the database. The basic idea is that you create your classes in the metaclass DB-CLASS and submarine cares about creating SQL tables or, if the tables already exist, checking if they conform to the provided specification. Moreover, Submarine supports an intuitive way of expressing both one-to-many and many-to-many relations.The author of Submarine is Ryszard Szopa.The common-lisp.net webpage of the project is http://common-lisp.net/project/submarine/.
Common Lisp SQL Fluid Connection Pools
A library providing a clutch of utilities to make working with clsql easier
Allows the use of local-time:timestamp objects in CLSQL models and queries
CLSQL-ORM is an library to generate clsql view-classes from existing databases, by introspecting on the "information_schema" of the running database.For more info see: Git Hub: https://github.com/AccelerationNet/CLSQL-ORM
Extension for iterate to support iterate over clsql queries
Facilities for reading and writing CSV format files
Password management for Common Lisp (web) applications. cl-password-store provides a light-weight and extendible solution to
safe password storage:
cleartext-free, using your choice of hash algorithm through
storage in an SQL database through
clsql, in a database your application
already uses anyway, or in a separate one, and using any backend
supported by clsql,
password reset mechanism with one-time tokens (suitable for mailing
to users for confirmation),
user creation optionally with confirmation tokens (suitable for
mailing to users),
(obviously) user authentication.
Users can be identified by strings or by subclassing
user-token-mixin. The code is available under LLGPL at github. For documentation check out the