agpl_1.0.0_b5da3320/src/agpl-db/gnu-db-sqlite3.adb

-------------------------------------------------------------------------------
--									                                                  --
--  Filename        : $Source: /cvsroot/gnade/gnade/dbi/sqlite3/gnu-db-sqlite3.ads,v $
--  Description     : SQLite Base Package                                    --
--  Author          : Ching Bon Lam                                          --
--  Created         : 26.7.2003                                              --
--  Last Modified By: $Author: merdmann $				                             --
--  Last Modified On: $Date: 2004/12/28 21:31:38 $		                       --
--  Status          : $State: Exp $					                             --
--									                                                  --
--  Copyright (C) 2003 Ching Bon Lam                                         --
--                                                                           --
--  GNADE is free software;  you can redistribute it  and/or modify it under --
--  terms of the  GNU General Public License as published  by the Free Soft- --
--  ware  Foundation;  either version 2,  or (at your option) any later ver- --
--  sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
--  OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
--  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
--  for  more details.  You should have  received  a copy of the GNU General --
--  Public License  distributed with GNAT;  see file COPYING.  If not, write --
--  to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
--  MA 02111-1307, USA.                                                      --
--                                                                           --
--  As a special exception,  if other files  instantiate  generics from this --
--  unit, or you link  this unit with other files  to produce an executable, --
--  this  unit  does not  by itself cause  the resulting  executable  to  be --
--  covered  by the  GNU  General  Public  License.  This exception does not --
--  however invalidate  any other reasons why  the executable file  might be --
--  covered by the  GNU Public License.                                      --
--                                                                           --
--  Functional Description                                                   --
--  ======================                                                   --
--  Thick binding to sqlite (http://www.sqlite.org).                         --
--                                                                           --
--  Restrictions                                                             --
--  ============                                                             --
--  None                                                                     --
--                                                                           --
--  References                                                               --
--  ==========                                                               --
--  Sqlite homepage : http://www.sqlite.org                                  --
--                                                                           --
--  Contact                                                                  --
--  =======                                                                  --
--  Error reports shall be handled via http://gnade.sourceforge.net          --
--  Features and ideas via: gnade-develop@lists.sourceforge.net              --
--                                                                           --
--  Author contact:                                                          --
--    Ching Bon Lam  <cblam@gmx.net>                                         --
--									                                                  --
-------------------------------------------------------------------------------

with Ada.Unchecked_Deallocation;
with Ada.Text_IO;

with Interfaces.C;
with Interfaces.C.Strings;
with Interfaces.C.Pointers;

with System;

package body GNU.DB.SQLite3 is

   pragma Linker_Options("-lsqlite3");

   package C   renames Interfaces.C;
   package CS  renames Interfaces.C.Strings;

   ----------------------------------------------------------------------------
   -- local support -----------------------------------------------------------
   ----------------------------------------------------------------------------

   package C_Wide_Strings is
      new C.Pointers( C.size_T,
                      C.WChar_T,
                      C.WChar_Array,
                      C.Wide_Nul );
   package CWS renames C_Wide_Strings;

   function To_Ada
     (Thing : CWS.Pointer)
      return wide_string
   is
   begin
      return C.To_Ada(CWS.Value(Thing));
   end To_Ada;
   pragma Inline(To_Ada);

   function To_Ada
     (Thing : CS.chars_ptr)
      return string
   is
      use type CS.chars_ptr;
   begin
      if Thing = CS.Null_Ptr then
         return "";
      else
         return CS.Value (Thing);
      end if;
   end To_Ada;
   pragma Inline(To_Ada);


   function To_C
     (Thing : wide_string)
      return C.wchar_array
   is
   begin
      return C.To_C(Thing)(0 .. C.Size_T(Thing'Length));
   end To_C;
   pragma Inline(To_C);

   function int_to_ret_val
     (rc : integer)
      return Return_Value
   is
   begin
      case rc is
         when  0 => return SQLITE_OK;
         when  1 => return SQLITE_ERROR;
         when  2 => return SQLITE_INTERNAL;
         when  3 => return SQLITE_PERM;
         when  4 => return SQLITE_ABORT;
         when  5 => return SQLITE_BUSY;
         when  6 => return SQLITE_LOCKED;
         when  7 => return SQLITE_NOMEM;
         when  8 => return SQLITE_READONLY;
         when  9 => return SQLITE_INTERRUPT;
         when 10 => return SQLITE_IOERR;
         when 11 => return SQLITE_CORRUPT;
         when 12 => return SQLITE_NOTFOUND;
         when 13 => return SQLITE_FULL;
         when 14 => return SQLITE_CANTOPEN;
         when 15 => return SQLITE_PROTOCOL;
         when 16 => return SQLITE_EMPTY;
         when 17 => return SQLITE_SCHEMA;
         when 18 => return SQLITE_TOOBIG;
         when 19 => return SQLITE_CONSTRAINT;
         when 20 => return SQLITE_MISMATCH;
         when 21 => return SQLITE_MISUSE;
         when 22 => return SQLITE_NOLFS;
         when 23 => return SQLITE_AUTH;
         when 24 => return SQLITE_FORMAT;
         when 25 => return SQLITE_RANGE;
         when 26 => return SQLITE_NOTADB;
         when 100 => return SQLITE_ROW;
         when 101 => return SQLITE_DONE;
         when others => return UNDEFINED_ERROR;
      end case;
   end int_to_ret_val;

   function int_to_ret_val
     (int : C.int)
      return Return_Value
   is
   begin
      return int_to_ret_val(integer(int));
   end int_to_ret_val;

   -- pragma Import(C, SQLITE_STATIC, "SQLITE_STATIC");

   ----------------------------------------------------------------------------
   -- body --------------------------------------------------------------------
   ----------------------------------------------------------------------------

   -----------------
   -- bind_double --
   -----------------

   function bind_double
     (Stmt : Statement_Reference;
      N    : integer;
      D    : long_float)
      return Return_Value
   is

      function sqlite3_bind_double
        (stmt : Stmt_Access;
         N    : C.int;
         D    : C.double)
         return C.int;
      pragma Import(C, sqlite3_bind_double, "sqlite3_bind_double");
      -- sqlite3.h:627
      -- int sqlite3_bind_double(sqlite3_stmt*, int, double);

   begin

      return int_to_ret_val(sqlite3_bind_double(Stmt.stmt, C.int(N), C.double(D)));

   end bind_double;

   --------------
   -- bind_int --
   --------------

   function bind_int
     (stmt : Statement_Reference;
      N    : integer;
      I    : integer)
      return Return_Value
   is

      function sqlite3_bind_int
        (stmt : Stmt_Access;
         N    : C.int;
         I    : C.int)
         return C.int;
      pragma Import(C, sqlite3_bind_int, "sqlite3_bind_int");
      -- sqlite3.h:628
      -- int sqlite3_bind_int(sqlite3_stmt*, int, int);

   begin

      return int_to_ret_val(sqlite3_bind_int(Stmt.stmt, C.int(N), C.int(I)));

   end bind_int;

   ----------------
   -- bind_int64 --
   ----------------

   function bind_int64
     (stmt : Statement_Reference;
      N    : integer;
      I    : int64)
      return Return_Value
   is

      function sqlite3_bind_int64
        (stmt : Stmt_Access;
         N    : C.int;
         I    : int64)
         return C.int;
      pragma Import(C, sqlite3_bind_int64, "sqlite3_bind_int64");
      -- sqlite3.h:629
      -- int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite_int64);

   begin

      return int_to_ret_val(sqlite3_bind_int64(Stmt.stmt, C.int(N), I));

   end bind_int64;

   ---------------
   -- bind_null --
   ---------------

   function bind_null
     (stmt : Statement_Reference;
      N    : integer)
      return Return_Value
   is

      function sqlite3_bind_null
        (stmt : Stmt_Access;
         N    : C.int)
         return C.int;
      pragma Import(C, sqlite3_bind_null, "sqlite3_bind_null");
      -- sqlite3.h:630
      -- int sqlite3_bind_null(sqlite3_stmt*, int);

   begin

      return int_to_ret_val(sqlite3_bind_null(Stmt.stmt, C.int(N)));

   end bind_null;

   ---------------
   -- bind_text --
   ---------------

   function bind_text
     (stmt : Statement_Reference;
      N    : integer;
      T    : string)
      return Return_Value
   is

      function sqlite3_bind_text
        (stmt : Stmt_Access;
         N    : C.int;
         T    : C.char_array;
         N2   : C.int;
         A    : System.Address)
         return C.int;
      pragma Import(C, sqlite3_bind_text, "sqlite3_bind_text");
      -- sqlite3.h:631
      -- int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));

   begin

      return int_to_ret_val(sqlite3_bind_text(
         Stmt.stmt,
         C.int(N),
         C.To_C(T),
         0,
         System.Null_Address --SQLITE_STATIC
         ));

   end bind_text;

   -----------------
   -- bind_text16 --
   -----------------

   function bind_text16
     (stmt : Statement_Reference;
      N    : integer;
      T    : wide_string)
      return Return_Value
   is

      function sqlite3_bind_text16
        (stmt : Stmt_Access;
         N    : C.int;
         T    : C.wchar_array;
         N2   : C.int;
         A    : System.Address)
         return C.int;
      pragma Import(C, sqlite3_bind_text16, "sqlite3_bind_text16");
      -- sqlite3.h:632
      -- int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));

   begin

      return int_to_ret_val(sqlite3_bind_text16(
         Stmt.stmt,
         C.int(N),
         To_C(T),
         0,
         System.Null_Address
         ));

   end bind_text16;

   -----------
   -- close --
   -----------

   function close
     (Self : Handle)
      return Return_Value
   is

   	function sqlite3_close
         (db : DB_Access)
          return C.int;
      pragma Import(C, sqlite3_close, "sqlite3_close");
      -- sqlite3.h:75
      -- int sqlite3_close(sqlite3 *);

      Return_Code : Return_Value;

   begin

      Return_Code := int_to_ret_val(sqlite3_close(Self.db));

     	if (Return_Code = SQLITE_OK) then
      	self.db := null;
     	end if;

     	return Return_Code;

   end close;

   -------------
   -- Changes --
   -------------

   function Changes
     (Self : Handle)
      return integer
   is

   	function sqlite3_changes
         (db : DB_Access)
          return C.int;
      pragma Import(C, sqlite3_changes, "sqlite3_changes");
      -- sqlite3.h:194
      -- int sqlite3_changes(sqlite3*);

   begin

      return integer(sqlite3_changes(Self.db));

   end Changes;

   ------------------
   -- column_count --
   ------------------

   function column_count
     (stmt : Statement_Reference)
      return integer
   is

      function sqlite3_column_count
        (stmt : Stmt_Access)
         return C.int;
      pragma Import(C, sqlite3_column_count, "sqlite3_column_count");
      -- sqlite3.h:661
      -- int sqlite3_column_count(sqlite3_stmt *pStmt);

   begin

      return integer(sqlite3_column_count(stmt.stmt));

   end column_count;

   ------------------
   -- column_count --
   ------------------

   function Column_Count
     (Self : Table_Reference;
      Row  : natural)
      return natural
   is

      use String_Vectors;
      use String_Tables;

   begin

      if Row <= Row_Count(Self) then
         return natural(Length(Element(Self.all, Row)));
      end if;

      return 0;

   end Column_Count;

   ---------------------
   -- column_decltype --
   ---------------------

   function column_decltype
     (stmt : Statement_Reference;
      iCol : integer)
      return string
   is
      function sqlite3_column_decltype
        (stmt : Stmt_Access;
         iCol : C.int)
         return CS.Chars_Ptr;
      pragma Import(C, sqlite3_column_decltype, "sqlite3_column_decltype");
      -- sqlite3.h:690
      -- const char *sqlite3_column_decltype(sqlite3_stmt *, int i);

   begin

      return To_Ada(sqlite3_column_decltype(stmt.stmt, C.int(iCol)));

   end column_decltype;

   -----------------------
   -- column_decltype16 --
   -----------------------

   function column_decltype16
     (stmt : Statement_Reference;
      iCol : integer)
      return wide_string
   is

      function sqlite3_column_decltype16
        (stmt : Stmt_Access;
         iCol : C.int)
         return CWS.Pointer;
      pragma Import(C, sqlite3_column_decltype16, "sqlite3_column_decltype16");
      -- sqlite3.h:710
      -- const void *sqlite3_column_decltype16(sqlite3_stmt*,int);

   begin

      return To_Ada(sqlite3_column_decltype16(stmt.stmt, C.int(iCol)));

   end column_decltype16;

   ----------------
   -- column_int --
   ----------------

   function column_int
     (stmt : Statement_Reference;
      iCol : integer)
      return integer
   is

      function sqlite3_column_int
        (stmt : Stmt_Access;
         iCol : C.int)
         return C.int;
      pragma Import(C, sqlite3_column_int, "sqlite3_column_int");
      -- sqlite3.h:828
      -- int sqlite3_column_int(sqlite3_stmt*, int iCol);

   begin

      return integer(sqlite3_column_int(stmt.stmt, C.int(iCol)));

   end column_int;

   -----------------
   -- column_text --
   -----------------

   function column_text
     (stmt : Statement_Reference;
      iCol : integer)
      return string
   is

      function sqlite3_column_text
        (stmt : Stmt_Access;
         iCol : C.int)
         return CS.Chars_Ptr;
      pragma Import(C, sqlite3_column_text, "sqlite3_column_text");
      -- sqlite3.h:830
      -- const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);

   begin

      return To_Ada(sqlite3_column_text(stmt.stmt, C.int(iCol)));

   end column_text;

   -------------------
   -- column_text16 --
   -------------------

   function column_text16
     (stmt : Statement_Reference;
      iCol : integer)
      return wide_string
   is

      function sqlite3_column_text16
        (stmt : Stmt_Access;
         iCol : C.int)
         return CWS.Pointer;
      pragma Import(C, sqlite3_column_text16, "sqlite3_column_text16");
      -- sqlite3.h:831
      -- const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);

   begin

      return To_Ada(sqlite3_column_text16(stmt.stmt, C.int(iCol)));

   end column_text16;

   -----------------
   -- column_name --
   -----------------

   function column_name
     (stmt : Statement_Reference;
      iCol : integer)
      return string
   is

      function sqlite3_column_name
        (stmt : Stmt_Access;
         iCol : C.int)
         return CS.Chars_Ptr;
      pragma Import(C, sqlite3_column_name, "sqlite3_column_name");
      -- sqlite3.h:669
      -- const char *sqlite3_column_name(sqlite3_stmt*,int);

   begin

      return To_Ada(sqlite3_column_name(stmt.stmt, C.int(iCol)));

   end column_name;

   -------------------
   -- column_name16 --
   -------------------

   function column_name16
     (stmt : Statement_Reference;
      iCol : integer)
      return wide_string
   is

      function sqlite3_column_name16
        (stmt : Stmt_Access;
         iCol : C.int)
         return CWS.Pointer;
      pragma Import(C, sqlite3_column_name16, "sqlite3_column_name16");
      -- sqlite3.h:670
      -- const void *sqlite3_column_name16(sqlite3_stmt*,int);

   begin

      return To_Ada(sqlite3_column_name16(stmt.stmt, C.int(iCol)));

   end column_name16;

   -----------------
   -- column_type --
   -----------------

   function column_type
     (stmt : Statement_Reference;
      iCol : integer)
      return integer
   is

      function sqlite3_column_type
        (stmt : Stmt_Access;
         iCol : C.int)
         return C.int;
      pragma Import(C, sqlite3_column_type, "sqlite3_column_type");
      -- sqlite3.h:832
      -- int sqlite3_column_type(sqlite3_stmt*, int iCol);

   begin

      return integer(sqlite3_column_type(stmt.stmt, C.int(iCol)));

   end column_type;

   --------------
   -- Complete --
   --------------

   function Complete
     (sql : string)
      return boolean
   is

      function sqlite3_complete
        (sql : C.char_array)
         return C.int;
      pragma Import(C, sqlite3_complete, "sqlite3_complete");
      -- sqlite3.h:233
      -- int sqlite3_complete(const char *sql);

   begin

      if ( integer(sqlite3_complete(C.To_C(sql))) = 0 ) then
         return FALSE;
      else
         return TRUE;
      end if;

   end Complete;

   ----------------
   -- Complete16 --
   ----------------

   function Complete16
     (sql : wide_string)
      return boolean
   is

      function sqlite3_complete16
        (sql : C.wchar_array)
         return C.int;
      pragma Import(C, sqlite3_complete16, "sqlite3_complete16");
      -- sqlite3.h:234
      -- int sqlite3_complete16(const void *sql);

   begin

      if ( integer(sqlite3_complete16(C.To_C(sql))) = 0 ) then
         return FALSE;
      else
         return TRUE;
      end if;

   end Complete16;

   ----------------
   -- data_count --
   ----------------

   function data_count
     (stmt : Statement_Reference)
      return integer
   is

      function sqlite3_data_count
        (stmt : Stmt_Access)
         return C.int;
      pragma Import(C, sqlite3_data_count, "sqlite3_data_count");
      -- sqlite3.h:755
      -- int sqlite3_data_count(sqlite3_stmt *pStmt);

   begin

      return integer(sqlite3_data_count(stmt.stmt));

   end data_count;

   -------------
   -- element --
   -------------

   function Element
     (Self : Table_Reference;
      row  : natural;
      col  : natural)
      return string
   is

      use String_Tables;
      use String_Vectors;

   begin

      return Element(Element(Self.all, row), col);

   end Element;

   ---------------
   -- element16 --
   ---------------

   function Element16
     (Self : Table16_Reference;
      row  : natural;
      col  : natural)
      return wide_string
   is

      use Wide_String_Tables;
      use Wide_String_Vectors;

   begin

      return Element(Element(Self.all, row), col);

   end Element16;

   -------------
   -- errcode --
   -------------

   function errcode
     (Self : Handle)
      return integer
   is

      function sqlite3_errcode
        (db : DB_Access)
         return C.int;
      pragma Import(C, sqlite3_errcode, "sqlite3_errcode");
      -- sqlite3.h:528
      -- int sqlite3_errcode(sqlite3 *db);

   begin

      return integer(sqlite3_errcode(Self.db));

   end errcode;

   ------------
   -- errmsg --
   ------------

   function errmsg
     (self : Handle)
      return string
   is

     function sqlite3_errmsg
       (db : DB_Access)
        return CS.Chars_Ptr;
     pragma Import(C, sqlite3_errmsg, "sqlite3_errmsg");
     -- sqlite3.h:538
     -- const char *sqlite3_errmsg(sqlite3*);

   begin

      return To_Ada(sqlite3_errmsg(Self.db));

   end errmsg;

   --------------
   -- errmsg16 --
   --------------

   function errmsg16
     (self : Handle)
      return wide_string
   is

     function sqlite3_errmsg16
       (db : DB_Access)
        return CWS.Pointer;
     pragma Import(C, sqlite3_errmsg16, "sqlite3_errmsg16");
      -- sqlite3.h:548
      -- const void *sqlite3_errmsg16(sqlite3*);

   begin

      return To_Ada(sqlite3_errmsg16(Self.db));

   end errmsg16;

   ----------
   -- exec --
   ----------

   function Exec
     (Self : Handle;
      sql  : string;
      cb   : Callback)
      return Return_Value
   is

      function Proxy
        (pArg        : Handle;
         argc        : integer;
         argv        : String_Vectors.Vector;
         columnNames : String_Vectors.Vector)
         return Return_Value
      is
      begin
         return cb(argc, argv, columnNames);
      end Proxy;
      pragma Inline(Proxy);

      package Real_Exec
         is new Generic_Exec(Object, Handle);

   begin

      return Real_Exec.Exec(Self, sql, Proxy'Access, null);

   end Exec;

   ------------
   -- exec16 --
   ------------

   function Exec16
     (Self : Handle;
      sql  : wide_string;
      cb   : Callback16)
      return Return_Value
   is

      function Proxy
        (pArg        : Handle;
         argc        : integer;
         argv        : Wide_String_Vectors.Vector;
         columnNames : Wide_String_Vectors.Vector)
         return Return_Value
      is
      begin
         return cb(argc, argv, columnNames);
      end Proxy;
      pragma Inline(Proxy);

      package Real_Exec16
         is new Generic_Exec16(Object, Handle);

   begin

      return Real_Exec16.Exec16(Self, sql, Proxy'Access, null);

   end Exec16;

   ----------
   -- exec --
   ----------

   function Exec
     (Self : Handle;
      sql  : string)
      return Return_Value
   is

      function Nothing
        (argc        : integer;
         argv        : String_Vectors.Vector;
         columnNames : String_Vectors.Vector)
         return Return_Value
      is
      begin
         return SQLITE_OK;
      end Nothing;
      pragma Inline(Nothing);

   begin

      return Exec(Self, sql, Nothing'Unrestricted_Access);

   end Exec;

   ------------
   -- exec16 --
   ------------

   function Exec16
     (Self : Handle;
      sql  : wide_string)
      return Return_Value
   is

      function Nothing
        (argc        : integer;
         argv        : Wide_String_Vectors.Vector;
         columnNames : Wide_String_Vectors.Vector)
         return Return_Value
      is
      begin
         return SQLITE_OK;
      end Nothing;
      pragma Inline(Nothing);

   begin

      return Exec16(Self, sql, Nothing'Unrestricted_Access);

   end Exec16;

   --------------
   -- finalize --
   --------------

   function finalize
     (stmt : Statement_Reference)
      return Return_Value
   is

      function sqlite3_finalize
        (stmt : Stmt_Access)
         return C.int;
      pragma Import(C, sqlite3_finalize, "sqlite3_finalize");
      -- sqlite3.h:848
      -- int sqlite3_finalize(sqlite3_stmt *pStmt);

   begin

      return int_to_ret_val(sqlite3_finalize(stmt.stmt));

   end finalize;

   ------------------
   -- Generic_Exec --
   ------------------

   package body Generic_Exec is

      use String_Vectors;

      function Exec
        (Self    : Handle;
         sql     : string;
         cb      : Callback;
         arg     : Data_Handle)
         return Return_Value
      is

         St  : aliased Statement;
         rSt : Statement_Reference := St'Unrestricted_Access;
         rc  : Return_Value;

         vals      : String_Vectors.Vector;
         cols      : String_Vectors.Vector;
         nCol      : integer;
         cols_done : boolean := FALSE;

      begin

         rc := Prepare(Self, sql, rSt);
         if not (rc = SQLITE_OK) then
            return rc;
         end if;

         nCol := column_count(rSt);

         loop

            rc := Step(rSt);

            if ( rc = SQLITE_ROW ) then

               Clear(vals);

               if not Cols_done then
                  for I in 0 .. (nCol - 1) loop
                     Append(cols, column_name(rSt, I));
                  end loop;

                  Cols_Done := TRUE;
               end if;

               for I in 0 .. (nCol - 1) loop
                  Append(vals, column_text(rSt, I));
               end loop;

               rc := cb(arg, nCol, vals, cols);
               if not ( rc = SQLITE_OK ) then
                  rc := Finalize(rSt);
                  rc := SQLITE_ABORT;
                  exit;
               end if;

            else

               rc := Finalize(rSt);
               exit;

            end if;

         end loop;

         return rc;

      end Exec;

   end Generic_Exec;

   --------------------
   -- Generic_Exec16 --
   --------------------

   package body Generic_Exec16 is

      use Wide_String_Vectors;

      function Exec16
        (Self    : Handle;
         sql     : wide_string;
         cb      : Callback16;
         arg     : Data_Handle)
         return Return_Value
      is

         St  : aliased Statement;
         rSt : Statement_Reference := St'Unrestricted_Access;
         rc  : Return_Value;

         vals      : Wide_String_Vectors.Vector;
         cols      : Wide_String_Vectors.Vector;
         nCol      : integer;
         cols_done : boolean := FALSE;

      begin

         rc := Prepare16(Self, sql, rSt);
         if not (rc = SQLITE_OK) then
            return rc;
         end if;

         nCol := column_count(rSt);

         loop

            rc := Step(rSt);

            if ( rc = SQLITE_ROW ) then

               Clear(vals);

               if not Cols_done then
                  for I in 0 .. (nCol - 1) loop
                     Append(cols, column_name16(rSt, I));
                  end loop;

                  Cols_Done := TRUE;
               end if;

               for I in 0 .. (nCol - 1) loop
                  Append(vals, column_text16(rSt, I));
               end loop;

               rc := cb(arg, nCol, vals, cols);
               if not ( rc = SQLITE_OK ) then
                  rc := Finalize(rSt);
                  rc := SQLITE_ABORT;
                  exit;
               end if;

            else

               rc := Finalize(rSt);
               exit;

            end if;

         end loop;

         return rc;

      end Exec16;

   end Generic_Exec16;

   ---------------
   -- Get_Table --
   ---------------

   function Get_Table
     (Self  : Handle;
      Sql   : string;
      table : Table_Reference)
      return Return_Value
   is

      use String_Tables;
      use String_Vectors;

      package Tables_Exec
         is new Generic_Exec(String_Tables.Vector, Table_Reference);

      function Build_Table
        (pArg        : Table_Reference;
         argc        : integer;
         argv        : String_Vectors.Vector;
         columnNames : String_Vectors.Vector)
         return Return_Value
      is
      begin


         if Is_Empty(pArg.all) then
            Append(pArg.all, columnNames);
         end if;

         Append(pArg.all, argv);

         return SQLITE_OK;

      end Build_Table;

   begin

      Clear(Table.all);
      return Tables_Exec.Exec(Self, sql, Build_Table'Unrestricted_Access, table);

   end Get_Table;

   -----------------
   -- Get_Table16 --
   -----------------

   function Get_Table16
     (Self  : Handle;
      Sql   : wide_string;
      table : Table16_Reference)
      return Return_Value
   is

      use Wide_String_Tables;
      use Wide_String_Vectors;

      package Tables16_Exec16
         is new Generic_Exec16(Wide_String_Tables.Vector, Table16_Reference);

      function Build_Table16
        (pArg        : Table16_Reference;
         argc        : integer;
         argv        : Wide_String_Vectors.Vector;
         columnNames : Wide_String_Vectors.Vector)
         return Return_Value
      is
      begin


         if Is_Empty(pArg.all) then
            Append(pArg.all, columnNames);
         end if;

         Append(pArg.all, argv);

         return SQLITE_OK;

      end Build_Table16;

   begin

      Clear(Table.all);
      return Tables16_Exec16.Exec16(Self,
                                    sql,
                                    Build_Table16'Unrestricted_Access,
                                    table);

   end Get_Table16;

   ---------------
   -- Interrupt --
   ---------------

   procedure Interrupt
     (Self : Handle)
   is

      procedure sqlite3_interrupt
        (db : DB_Access);
      pragma Import(C, sqlite3_interrupt, "sqlite3_interrupt");
      -- sqlite3.h:220
      -- void sqlite3_interrupt(sqlite3*);

   begin

      sqlite3_interrupt(Self.db);

   end Interrupt;

   -----------------------
   -- Last_Insert_Rowid --
   -----------------------

   function Last_Insert_Rowid
     (Self : Handle)
      return uint64
   is

      function sqlite3_last_insert_rowid
        (db : DB_Access)
         return uint64;
      pragma Import(C, sqlite3_last_insert_rowid, "sqlite3_last_insert_rowid");
      -- sqlite3.h:172
      -- sqlite_int64 sqlite3_last_insert_rowid(sqlite3*);

   begin

      return sqlite3_last_insert_rowid(Self.db);

   end Last_Insert_Rowid;

   ----------
   -- open --
   ----------

   function Open
     (Self     : Handle;
      Filename : string)
      return Return_Value
   is

      function sqlite3_open
        (filename  : C.char_array;
         DB_handle : access DB_Access)
         return C.int;
      pragma Import(C, sqlite3_open, "sqlite3_open");
      -- sqlite3.h:504
      -- int sqlite3_open(
      --   const char *filename,   /* Database filename (UTF-8) */
      --   sqlite3 **ppDb          /* OUT: SQLite db handle */
      -- );

   begin
      return int_to_ret_val(sqlite3_open(C.To_C (Filename), Self.db'Access));

   end open;

   ------------
   -- open16 --
   ------------

   function open16
     (Self     : Handle;
      Filename : wide_string)
      return Return_Value
   is

      function sqlite3_open16
        (filename  : C.wchar_array;
         DB_handle : access DB_Access)
         return C.int;
      pragma Import(C, sqlite3_open16, "sqlite3_open16");
      -- sqlite3.h:508
      -- int sqlite3_open16(
      --   const void *filename,   /* Database filename (UTF-16) */
      --   sqlite3 **ppDb          /* OUT: SQLite db handle */
      -- );

   begin

      return int_to_ret_val(sqlite3_open16(To_C(Filename), Self.db'Access));

   end open16;


   -------------
   -- prepare --
   -------------

   function prepare
     (self : Handle;
      sql  : string;
      stmt : Statement_Reference)
      return Return_Value
   is

      function sqlite3_prepare
        (db     : DB_Access;
         zSql   : C.char_array;
         nBytes : C.int;
         ppStmt : access Stmt_Access;
         pzTail : System.Address)
         return C.int;
      pragma Import(C, sqlite3_prepare, "sqlite3_prepare");
      -- sqlite3.h:581
      -- int sqlite3_prepare(
      --   sqlite3 *db,            /* Database handle */
      --   const char *zSql,       /* SQL statement, UTF-8 encoded */
      --   int nBytes,             /* Length of zSql in bytes. */
      --   sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
      --   const char **pzTail     /* OUT: Pointer to unused portion of zSql */
      -- );

   begin

      return int_to_ret_val(sqlite3_prepare(Self.db,
                                            C.To_C(sql),
                                            C.int(-1),
                                            stmt.stmt'Access,
                                            System.Null_Address)
                    );

   end prepare;

   ---------------
   -- prepare16 --
   ---------------

   function prepare16
     (self : Handle;
      sql  : wide_string;
      stmt : Statement_Reference)
      return Return_Value
   is

      function sqlite3_prepare16
        (db     : DB_Access;
         zSql   : C.wchar_array;
         nBytes : C.int;
         ppStmt : access Stmt_Access;
         pzTail : System.Address)
         return C.int;
      pragma Import(C, sqlite3_prepare16, "sqlite3_prepare16");
      -- sqlite3.h:588
      -- int sqlite3_prepare16(
      --   sqlite3 *db,            /* Database handle */
      --   const void *zSql,       /* SQL statement, UTF-16 encoded */
      --   int nBytes,             /* Length of zSql in bytes. */
      --   sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
      --   const void **pzTail     /* OUT: Pointer to unused portion of zSql */
      -- );

   begin

      return int_to_ret_val(sqlite3_prepare16(Self.db,
                                              To_C(sql),
                                              C.int(-1),
                                              stmt.stmt'Access,
                                              System.Null_Address)
                    );

   end prepare16;

   -----------
   -- Reset --
   -----------

   function reset
     (stmt : Statement_Reference)
      return Return_Value
   is

      function sqlite3_reset
        (stmt : Stmt_Access)
         return C.int;
      pragma Import(C, sqlite3_reset, "sqlite3_reset");
      -- sqlite3.h:857
      -- int sqlite3_reset(sqlite3_stmt *pStmt);

   begin

      return int_to_ret_val(sqlite3_reset(stmt.stmt));

   end reset;

   ---------------
   -- Row_Count --
   ---------------

   function Row_Count
     (Self : Table_Reference)
      return natural
   is

      use String_Tables;

   begin

      return natural(Length(Self.all));

   end Row_Count;

   ----------
   -- Step --
   ----------

   function step
     (stmt : Statement_Reference)
      return Return_Value
   is

      function sqlite3_step
        (stmt : Stmt_Access)
         return C.int;
      pragma Import(C, sqlite3_step, "sqlite3_step");
      -- sqlite3.h:744
      -- int sqlite3_step(sqlite3_stmt*);

   begin

      return int_to_ret_val(sqlite3_step(stmt.stmt));

   end step;

   -------------
   -- Total_Changes --
   -------------

   function Total_Changes
     (Self : Handle)
      return integer
   is

   	function sqlite3_total_changes
         (db : DB_Access)
          return C.int;
      pragma Import(C, sqlite3_total_changes, "sqlite3_total_changes");
      -- sqlite3.h:212
      -- int sqlite3_total_changes(sqlite3*);

   begin

      return integer(sqlite3_total_changes(Self.db));

   end Total_Changes;

end GNU.DB.SQLite3;