+27 Mar 2002 Kevin Rosenberg (kevin@rosenberg.net)
+ * interfaces/postgresql-socket/postgresql-socket-api.cl:
+ Fixes to read-double-from-socket. Added 64-bit integer support.
+
+ * test-suite/xptest-clsql.cl
+ Added testint for 64-bit integers
+
26 Mar 2002 Kevin Rosenberg (kevin@rosenberg.net)
* interfaces/postgresql-socket/postgresql-socket-api.cl:
Implemented direct socket reading for field type :double
read-double-from-socket function.
* test-suite/xptest-clsql.cl
- Start testing using XPTest package
+ Started work on test suite
25 Mar 2002 Kevin Rosenberg (kevin@rosenberg.net)
# Programer: Kevin M. Rosenberg
# Date Started: Mar 2002
#
-# CVS Id: $Id: Makefile,v 1.4 2002/03/27 09:03:47 kevin Exp $
+# CVS Id: $Id: Makefile,v 1.5 2002/03/27 12:09:39 kevin Exp $
#
# This file, part of CLSQL, is Copyright (c) 2002 by Kevin M. Rosenberg
#
DIST_ZIP=$(DISTDIR).zip
SOURCE_FILES=interfaces sql cmucl-compat doc test-suite Makefile VERSION \
COPYING.CLSQL COPYING.MaiSQL README INSTALL ChangeLog NEWS TODO \
- set-logical.cl test-clsql.cl \
+ set-logical.cl clsql-uffi.system \
clsql.system clsql-aodbc.system clsql-mysql.system \
clsql-postgresql.system clsql-postgresql-socket.system
<sect2>
<title>&uffi;</title>
- <para>
&clsql; uses <ulink
+ <para>&clsql; uses <ulink
url="http://uffi.med-info.com/"><citetitle>&uffi;</citetitle></ulink>
as a <emphasis>Foreign Function Interface</emphasis> (<glossterm
linkend="gloss-ffi">FFI</glossterm>) to support multiple &cl;
other systems.</para>
</sect2>
+ <sect2>
+ <title>XPTest (optional)</title>
+ <para>The test suite for &clsql; uses the onShore Development's
+XPTest package. onShore has graciously put the package in the public
+domain. You can download the package from onShore's web <ulink
+url="http://alpha.onshored.com/lisp-software/"><citetitle>site</citetitle></ulink>.
+This package is not required except if you wish to run the &clsql;
+test suite.</para>
+ </sect2>
+
<sect2>
<title>Supported Common Lisp Implementation</title>
<para>
</sect2>
<sect2>
- <title>Build <filename>clsql-mysql</filename> helper library</title>
- <para>&mysql; uses functions that require 64-bit integer
+ <title>Build &c; helper libraries</title>
+ <para>&clsql; uses functions that require 64-bit integer
parameters and return values. The &ffi; in most &clsql;
-implementations do not support 64-bit integers. Thus, a C helper
-library is required to break these 64-bit integers into two compatible
+implementations do not support 64-bit integers. Thus, C helper
+libraries are required to break these 64-bit integers into two compatible
32-bit integers.</para>
-<para><filename>Makefile</filename>'s for Microsoft Windows and GNU/Solaris systems
-are supplied to build this library. In addition, the <type>DLL</type> and <type>LIB</type>
+<para>Makefiles for Microsoft Windows and GNU/Solaris systems
+are supplied to build the libraries. Since many Microsoft Windows
+users don't have access to a compiler, the <type>DLL</type> and <type>LIB</type>
files for Microsoft Windows are supplied with the distribution.</para>
-<para>To build the library, first move to the directory
-<filename>interfaces/mysql</filename> directory. You may need to
-edit <filename>Makefile</filename> or <filename>Makefile.msvc</filename> to
-correctly specify the location of your &mysql; installation. On UNIX systems, use
-the command:
- <programlisting>make</programlisting>
-On a Microsoft Windows system,
-use the command:
- <programlisting>
-nmake /f
-Makefile.msvc
- </programlisting></para>
+<para>To build the libraries on a GNU or Solaris, use the shell and
+change to the root directory of &clsql;. You may need to edit the file
+<filename>interfaces/mysql/Makefile</filename> to specify the location of your
+MySQL installation. Then, you can give the command
+<programlisting>
+make libs
+</programlisting>
+in the root directory of &clsql; to build the libraries
+<filename>interfaces/mysql/clsql-mysql.so</filename> and
+<filename>interfaces/clsql-uffi/clsql-uffi.so</filename>.
+</para>
</sect2>
<sect2>
ignored.
<simplelist type="vert">
<member><symbol>:int</symbol> Field is imported as a
- 32-bit signed integer.
- </member>
- <member><symbol>:longlong</symbol> Field is imported as a
- 64-bit signed integer.
+ signed integer, from 8-bits to 64-bits depending
+ upon the field type.
</member>
<member><symbol>:double</symbol> Field is imported as a
double-float number.
;;;; Programmers: Kevin M. Rosenberg
;;;; Date Started: Mar 2002
;;;;
-;;;; $Id: clsql-uffi.cl,v 1.1 2002/03/27 07:58:42 kevin Exp $
+;;;; $Id: clsql-uffi.cl,v 1.2 2002/03/27 12:09:39 kevin Exp $
;;;;
;;;; This file, part of CLSQL, is Copyright (c) 2002 by Kevin M. Rosenberg
;;;;
(in-package :clsql-uffi)
-(defun canonicalize-type-list (types num-fields)
+(defun canonicalize-type-list (types auto-list)
"Ensure a field type list meets expectations"
(let ((length-types (length types))
(new-types '()))
- (loop for i from 0 below num-fields
+ (loop for i from 0 below (length auto-list)
do
(if (>= i length-types)
(push t new-types) ;; types is shorted than num-fields
(push
(case (nth i types)
- ((:int :long :double :longlong t)
- (nth i types))
+ (:int
+ (case (nth i auto-list)
+ (:int32
+ :int32)
+ (:int64
+ :int64)
+ (t
+ t)))
+ (:double
+ (case (nth i auto-list)
+ (:double
+ :double)
+ (t
+ t)))
(t
t))
new-types)))
(nth index types)
types)))
(case type
- (:int
- (atoi char-ptr))
- (:long
- (atol char-ptr))
(:double
(atof char-ptr))
- (:longlong
+ (:int32
+ (atoi char-ptr))
+ (:int64
(uffi:with-foreign-object (high32-ptr :int)
(let ((low32 (atol64 char-ptr high32-ptr))
(high32 (uffi:deref-pointer high32-ptr :int)))
(if (zerop high32)
low32
(make-64-bit-integer high32 low32)))))
- (otherwise
+ (t
(uffi:convert-from-foreign-string char-ptr)))))
;;;; Original code by Pierre R. Mai
;;;; Date Started: Feb 2002
;;;;
-;;;; $Id: mysql-sql.cl,v 1.14 2002/03/27 08:09:25 kevin Exp $
+;;;; $Id: mysql-sql.cl,v 1.15 2002/03/27 12:09:39 kevin Exp $
;;;;
;;;; This file, part of CLSQL, is Copyright (c) 2002 by Kevin M. Rosenberg
;;;; and Copyright (c) 1999-2001 by Pierre R. Mai
;;; Field conversion functions
+(defun make-type-list-for-auto (num-fields res-ptr)
+ (let ((new-types '())
+ #+ignore (field-vec (mysql-fetch-fields res-ptr)))
+ (dotimes (i num-fields)
+ (declare (fixnum i))
+ (let* ( (field (mysql-fetch-field-direct res-ptr i))
+ #+ignore (field (uffi:deref-array field-vec 'mysql-field-vector i))
+ (type (uffi:get-slot-value field 'mysql-field 'type)))
+ (push
+ (case type
+ ((#.mysql-field-types#tiny
+ #.mysql-field-types#short
+ #.mysql-field-types#int24
+ #.mysql-field-types#long)
+ :int32)
+ (#.mysql-field-types#longlong
+ :int64)
+ ((#.mysql-field-types#double
+ #.mysql-field-types#float
+ #.mysql-field-types#decimal)
+ :double)
+ (otherwise
+ t))
+ new-types)))
+ (nreverse new-types)))
+
(defun canonicalize-types (types num-fields res-ptr)
- (cond
- ((listp types)
- (canonicalize-type-list types num-fields))
- ((eq types :auto)
- (let ((new-types '())
- #+ignore (field-vec (mysql-fetch-fields res-ptr)))
- (dotimes (i num-fields)
- (declare (fixnum i))
- (let* ( (field (mysql-fetch-field-direct res-ptr i))
- #+ignore (field (uffi:deref-array field-vec 'mysql-field-vector i))
- (type (uffi:get-slot-value field 'mysql-field 'type)))
- (push
- (case type
- ((#.mysql-field-types#tiny
- #.mysql-field-types#short
- #.mysql-field-types#int24
- #.mysql-field-types#long)
- :int)
- (#.mysql-field-types#longlong
- :longlong)
- ((#.mysql-field-types#double
- #.mysql-field-types#float
- #.mysql-field-types#decimal)
- :double)
- (otherwise
- t))
- new-types)))
- (nreverse new-types)))
- (t
- nil)))
+ (let ((auto-list (make-type-list-for-auto num-fields res-ptr)))
+ (cond
+ ((listp types)
+ (canonicalize-type-list types auto-list))
+ ((eq types :auto)
+ auto-list)
+ (t
+ nil))))
(defmethod database-initialize-database-type ((database-type (eql :mysql)))
t)
;;;;
;;;; Date Started: Feb 2002
;;;;
-;;;; $Id: postgresql-socket-api.cl,v 1.11 2002/03/27 11:13:27 kevin Exp $
+;;;; $Id: postgresql-socket-api.cl,v 1.12 2002/03/27 12:09:39 kevin Exp $
;;;;
;;;; This file, part of CLSQL, is Copyright (c) 2002 by Kevin M. Rosenberg
;;;; and Copyright (c) 1999-2001 by Pierre R. Mai
(defun read-field (socket type)
(let ((length (- (read-socket-value 'int32 socket) 4)))
(case type
- ((:int :long :longlong)
+ ((:int32 :int64)
(read-integer-from-socket socket length))
(:double
(read-double-from-socket socket length))
;;;; Original code by Pierre R. Mai
;;;; Date Started: Feb 2002
;;;;
-;;;; $Id: postgresql-socket-sql.cl,v 1.7 2002/03/27 08:09:25 kevin Exp $
+;;;; $Id: postgresql-socket-sql.cl,v 1.8 2002/03/27 12:09:39 kevin Exp $
;;;;
;;;; This file, part of CLSQL, is Copyright (c) 2002 by Kevin M. Rosenberg
;;;; and Copyright (c) 1999-2001 by Pierre R. Mai
;; Field type conversion
+(defun make-type-list-for-auto (cursor)
+ (let* ((fields (postgresql-cursor-fields cursor))
+ (num-fields (length fields))
+ (new-types '()))
+ (dotimes (i num-fields)
+ (declare (fixnum i))
+ (push (canonical-field-type fields i) new-types))
+ (nreverse new-types)))
+
(defun canonical-field-type (fields index)
"Extracts canonical field type from fields list"
(let ((oid (cadr (nth index fields))))
((#.pgsql-ftype#bytea
#.pgsql-ftype#int2
#.pgsql-ftype#int4)
- :int)
+ :int32)
(#.pgsql-ftype#int8
- :longlong)
+ :int64)
((#.pgsql-ftype#float4
#.pgsql-ftype#float8)
:double)
(otherwise
t))))
+(defun canonicalize-types (types cursor)
+ (let ((auto-list (make-type-list-for-auto cursor)))
+ (cond
+ ((listp types)
+ (canonicalize-type-list types auto-list))
+ ((eq types :auto)
+ auto-list)
+ (t
+ nil))))
-(defun canonicalize-type-list (types num-fields)
+(defun canonicalize-type-list (types auto-list)
"Ensure a field type list meets expectations.
Duplicated from clsql-uffi package so that this interface
doesn't depend on UFFI."
(let ((length-types (length types))
(new-types '()))
- (loop for i from 0 below num-fields
+ (loop for i from 0 below (length auto-list)
do
(if (>= i length-types)
(push t new-types) ;; types is shorted than num-fields
(push
(case (nth i types)
- ((:int :long :double :longlong t)
- (nth i types))
+ (:int
+ (case (nth i auto-list)
+ (:int32
+ :int32)
+ (:int64
+ :int64)
+ (t
+ t)))
+ (:double
+ (case (nth i auto-list)
+ (:double
+ :double)
+ (t
+ t)))
(t
t))
new-types)))
(nreverse new-types)))
-(defun canonicalize-types (types cursor)
- (let* ((fields (postgresql-cursor-fields cursor))
- (num-fields (length fields)))
- (cond
- ((listp types)
- (canonicalize-type-list types num-fields))
- ((eq types :auto)
- (let ((new-types '()))
- (dotimes (i num-fields)
- (declare (fixnum i))
- (push (canonical-field-type fields i) new-types))
- (nreverse new-types)))
- (t
- nil))))
(defun convert-to-clsql-warning (database condition)
(warn 'clsql-database-warning :database database
;;;; Original code by Pierre R. Mai
;;;; Date Started: Feb 2002
;;;;
-;;;; $Id: postgresql-sql.cl,v 1.10 2002/03/27 08:09:25 kevin Exp $
+;;;; $Id: postgresql-sql.cl,v 1.11 2002/03/27 12:09:39 kevin Exp $
;;;;
;;;; This file, part of CLSQL, is Copyright (c) 2002 by Kevin M. Rosenberg
;;;; and Copyright (c) 1999-2001 by Pierre R. Mai
;;; Field conversion functions
-(defun canonicalize-types (types num-fields res-ptr)
- (cond
- ((listp types)
- (canonicalize-type-list types num-fields))
- ((eq types :auto)
- (let ((new-types '()))
- (dotimes (i num-fields)
- (declare (fixnum i))
- (let* ((type (PQftype res-ptr i)))
- (push
- (case type
- ((#.pgsql-ftype#bytea
- #.pgsql-ftype#int2
- #.pgsql-ftype#int4)
- :int)
- (#.pgsql-ftype#int8
- :longlong)
- ((#.pgsql-ftype#float4
- #.pgsql-ftype#float8)
- :double)
- (otherwise
- t))
- new-types)))
+(defun make-type-list-for-auto (num-fields res-ptr)
+ (let ((new-types '()))
+ (dotimes (i num-fields)
+ (declare (fixnum i))
+ (let* ((type (PQftype res-ptr i)))
+ (push
+ (case type
+ ((#.pgsql-ftype#bytea
+ #.pgsql-ftype#int2
+ #.pgsql-ftype#int4)
+ :int32)
+ (#.pgsql-ftype#int8
+ :int64)
+ ((#.pgsql-ftype#float4
+ #.pgsql-ftype#float8)
+ :double)
+ (otherwise
+ t))
+ new-types)))
(nreverse new-types)))
- (t
- nil)))
+(defun canonicalize-types (types num-fields res-ptr)
+ (let ((auto-list (make-type-list-for-auto num-fields res-ptr)))
+ (cond
+ ((listp types)
+ (canonicalize-type-list types auto-list))
+ ((eq types :auto)
+ auto-list)
+ (t
+ nil))))
(defun tidy-error-message (message)
(unless (stringp message)
;;;; Programmer: Kevin M. Rosenberg
;;;; Date Started: Mar 2002
;;;;
-;;;; $Id: xptest-clsql.cl,v 1.6 2002/03/27 11:13:27 kevin Exp $
+;;;; $Id: xptest-clsql.cl,v 1.7 2002/03/27 12:09:39 kevin Exp $
;;;;
;;;; The XPTest package can be downloaded from
;;;; http://alpha.onshored.com/lisp-software/
;;;; (http://opensource.franz.com/preamble.html), also known as the LLGPL.
;;;; *************************************************************************
+
+;;; This test suite looks for a configuration file named "test.config"
+;;; This file contains a single a-list that specifies the connection
+;;; specs for each database type to be tested. For example, to test all
+;;; platforms, a sample "test.config" may look like:
+;;;
+;;; ((:mysql ("localhost" "a-mysql-db" "user1" "secret"))
+;;; (:aodbc ("my-dsn" "a-user" "pass"))
+;;; (:paostgresql ("localhost" "another-db" "user2" "dont-tell"))
+;;; (:postgresql-socket ("pg-server" "a-db-name" "user" "secret-password")))
+
(declaim (optimize (debug 3) (speed 3) (safety 1) (compilation-speed 0)))
(in-package :cl-user)
(mk:load-system "XPTest")
(when (map-query nil #'list "select * from test_clsql"
:database db :types :auto)
(failure "Expected NIL result from map-query nil"))
- (do-query ((int float str) "select * from test_clsql")
- (test-table-row (list int float str) nil))
- (do-query ((int float str) "select * from test_clsql" :types :auto)
- (test-table-row (list int float str) :auto))
+ (do-query ((int float bigint str) "select * from test_clsql")
+ (test-table-row (list int float bigint str) nil))
+ (do-query ((int float bigint str) "select * from test_clsql" :types :auto)
+ (test-table-row (list int float bigint str) :auto))
(drop-test-table db)
)
(disconnect :database db)))))
(dotimes (i 10)
(clsql-mysql::database-execute-command
(format nil "INSERT INTO test_clsql VALUES (~d,~d,'~a')"
- i (sqrt i) (format nil "~d" (sqrt i)))
+ i (number-to-sql-string (sqrt i))
+ (number-to-sql-string (sqrt i)))
db))
(let ((res (clsql-mysql::database-query-result-set "select * from test_clsql" db :full-set t :types nil)))
(unless (= 10 (mysql:mysql-num-rows (clsql-mysql::mysql-result-set-res-ptr res)))
(make-test-suite
"CLSQL Test Suite"
"Basic test suite for database operations."
- ("MySQL Low Level Interface Test" 'clsql-fixture
+ ("MySQL Low Level Interface" 'clsql-fixture
:test-thunk 'mysql-low-level
:description "A test of MySQL low-level interface")
- ("MySQL Test" 'clsql-fixture
+ ("MySQL Table" 'clsql-fixture
:test-thunk 'mysql-table-test
:description "A test of MySQL")
- ("PostgreSQL Test" 'clsql-fixture
+ ("PostgreSQL Table" 'clsql-fixture
:test-thunk 'pgsql-table-test
:description "A test of PostgreSQL tables")
- ("PostgreSQL Socket Table Test" 'clsql-fixture
+ ("PostgreSQL Socket Table" 'clsql-fixture
:test-thunk 'pgsql-socket-table-test
:description "A test of PostgreSQL Socket tables")
))
;;;; Testing functions
-(defun transform1 (i)
+(defun transform-float-1 (i)
(* i (abs (/ i 2)) (expt 10 (* 2 i))))
+(defun transform-bigint-1 (i)
+ (* i (expt 10 (* 3 (abs i)))))
+
(defun create-test-table (db)
(ignore-errors
(clsql:execute-command
"DROP TABLE test_clsql" :database db))
(clsql:execute-command
- "CREATE TABLE test_clsql (t_int integer, t_float float, t_str CHAR(20))"
+ "CREATE TABLE test_clsql (t_int integer, t_float float, t_bigint BIGINT, t_str CHAR(20))"
:database db)
(dotimes (i 11)
(let* ((test-int (- i 5))
- (test-flt (transform1 test-int)))
+ (test-flt (transform-float-1 test-int)))
(clsql:execute-command
- (format nil "INSERT INTO test_clsql VALUES (~a,~a,'~a')"
+ (format nil "INSERT INTO test_clsql VALUES (~a,~a,~a,'~a')"
test-int
(number-to-sql-string test-flt)
- (number-to-sql-string test-flt))
+ (transform-bigint-1 test-int)
+ (number-to-sql-string test-flt)
+ )
:database db))))
(defun parse-double (num-str)
(defun test-table-row (row types)
(unless (and (listp row)
- (= 3 (length row)))
+ (= 4 (length row)))
(failure "Row ~S is incorrect format" row))
- (destructuring-bind (int float str) row
+ (destructuring-bind (int float bigint str) row
(cond
((eq types :auto)
(unless (and (integerp int)
(typep float 'double-float)
+ (integerp bigint)
(stringp str))
(failure "Incorrect field type for row ~S" row)))
((null types)
(unless (and (stringp int)
(stringp float)
+ (stringp bigint)
(stringp str))
(failure "Incorrect field type for row ~S" row))
- (setq int (parse-integer int))
- (setq float (parse-double float)))
+ (setq int (parse-integer int))
+ (setq bigint (parse-integer bigint))
+ (setq float (parse-double float)))
((listp types)
+ (error "NYI")
)
(t
(failure "Invalid types field (~S) passed to test-table-row" types)))
-#+ignore
- (unless (= float (transform1 int))
+ (unless (= float (transform-float-1 int))
(failure "Wrong float value ~A for int ~A (row ~S)" float int row))
-#+ignore
(unless (= float (parse-double str))
(failure "Wrong string value ~A" str))))
projects / clsql.git / commitdiff