lib/sqlite3.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2013 Guillaume Auger <jeho@resist.ca>
   4 # Copyright 2013-2014 Alexis Laferrière <alexis.laf@xymus.net>
   5 #
   6 # Licensed under the Apache License, Version 2.0 (the "License");
   7 # you may not use this file except in compliance with the License.
   8 # You may obtain a copy of the License at
   9 #
  10 #     http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 # Unless required by applicable law or agreed to in writing, software
  13 # distributed under the License is distributed on an "AS IS" BASIS,
  14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 # See the License for the specific language governing permissions and
  16 # limitations under the License.
  17
  18 # Low-level Sqlite3 features
  19 module sqlite3 is pkgconfig("sqlite3")
  20
  21 in "C header" `{
  22         #include <sqlite3.h>
  23 `}
  24
  25 extern class Sqlite3Code `{int`}
  26         new ok `{ return SQLITE_OK; `} #         0   /* Successful result */
  27         fun is_ok: Bool `{ return recv == SQLITE_OK; `}
  28
  29         # new  `{ return SQLITE_ERROR; `} #      1   /* SQL error or missing database */
  30         # new  `{ return SQLITE_INTERNAL; `} #    2   /* Internal logic error in SQLite */
  31         # new  `{ return SQLITE_PERM; `} #        3   /* Access permission denied */
  32         # new  `{ return SQLITE_ABORT; `} #       4   /* Callback routine requested an abort */
  33         # new  `{ return SQLITE_BUSY; `} #        5   /* The database file is locked */
  34         # new  `{ return SQLITE_LOCKED; `} #      6   /* A table in the database is locked */
  35         # new  `{ return SQLITE_NOMEM; `} #       7   /* A malloc() failed */
  36         # new  `{ return SQLITE_READONLY; `} #    8   /* Attempt to write a readonly database */
  37         # new  `{ return SQLITE_INTERRUPT; `} #   9   /* Operation terminated by sqlite3_interrupt()*/
  38         # new  `{ return SQLITE_IOERR; `} #      10   /* Some kind of disk I/O error occurred */
  39         # new  `{ return SQLITE_CORRUPT; `} #    11   /* The database disk image is malformed */
  40         # new  `{ return SQLITE_NOTFOUND; `} #   12   /* Unknown opcode in sqlite3_file_control() */
  41         # new  `{ return SQLITE_FULL; `} #       13   /* Insertion failed because database is full */
  42         # new  `{ return SQLITE_CANTOPEN; `} #   14   /* Unable to open the database file */
  43         # new  `{ return SQLITE_PROTOCOL; `} #   15   /* Database lock protocol error */
  44         # new  `{ return SQLITE_EMPTY; `} #      16   /* Database is empty */
  45         # new  `{ return SQLITE_SCHEMA; `} #     17   /* The database schema changed */
  46         # new  `{ return SQLITE_TOOBIG; `} #     18   /* String or BLOB exceeds size limit */
  47         # new  `{ return SQLITE_CONSTRAINT; `} # 19   /* Abort due to constraint violation */
  48         # new  `{ return SQLITE_MISMATCH; `} #   20   /* Data type mismatch */
  49         # new  `{ return SQLITE_MISUSE; `} #     21   /* Library used incorrectly */
  50         # new  `{ return SQLITE_NOLFS; `} #      22   /* Uses OS features not supported on host */
  51         # new  `{ return SQLITE_AUTH; `} #       23   /* Authorization denied */
  52         # new  `{ return SQLITE_FORMAT; `} #     24   /* Auxiliary database format error */
  53         # new  `{ return SQLITE_RANGE; `} #      25   /* 2nd parameter to sqlite3_bind out of range */
  54         # new  `{ return SQLITE_NOTADB; `} #     26   /* File opened that is not a database file */
  55         # new  `{ return SQLITE_NOTICE; `} #     27   /* Notifications from sqlite3_log() */
  56         # new  `{ return SQLITE_WARNING; `} #    28   /* Warnings from sqlite3_log() */
  57
  58         new row `{ return SQLITE_ROW; `} #        100  /* sqlite3_step() has another row ready */
  59         fun is_row: Bool `{ return recv == SQLITE_ROW; `}
  60
  61         new done `{ return SQLITE_DONE; `} #       101  /* sqlite3_step() has finished executing */
  62         fun is_done: Bool `{ return recv == SQLITE_DONE; `}
  63
  64         redef fun to_s: String import NativeString.to_s `{
  65 #if SQLITE_VERSION_NUMBER >= 3007015
  66                 char *err = (char *)sqlite3_errstr(recv);
  67 #else
  68                 char *err = "sqlite3_errstr supported only by version >= 3.7.15";
  69 #endif
  70                 if (err == NULL) err = "";
  71                 return NativeString_to_s(err);
  72         `}
  73 end
  74
  75 # A prepared statement
  76 extern class Statement `{sqlite3_stmt*`}
  77
  78         # Evaluate the statement
  79         fun step: Sqlite3Code `{
  80                 return sqlite3_step(recv);
  81         `}
  82
  83         fun column_name(i: Int) : String import NativeString.to_s `{
  84                 const char * name = (sqlite3_column_name(recv, i));
  85                 if(name == NULL){
  86                         name = "";
  87                 }
  88                 char * ret = (char *) name;
  89                 return NativeString_to_s(ret);
  90         `}
  91
  92         fun column_bytes(i: Int) : Int `{
  93                 return sqlite3_column_bytes(recv, i);
  94         `}
  95
  96         fun column_double(i: Int) : Float `{
  97                 return sqlite3_column_double(recv, i);
  98         `}
  99
 100         fun column_int(i: Int) : Int `{
 101                 return sqlite3_column_int(recv, i);
 102         `}
 103
 104         fun column_text(i: Int) : String import NativeString.to_s `{
 105                 char * ret = (char *) sqlite3_column_text(recv, i);
 106                 if( ret == NULL ){
 107                         ret = "";
 108                 }
 109                 return NativeString_to_s(ret);
 110         `}
 111
 112         fun column_type(i: Int) : Int `{
 113                 return sqlite3_column_type(recv, i);
 114         `}
 115
 116         fun column_blob(i: Int): Pointer `{ return (void*)sqlite3_column_blob(recv, i); `}
 117
 118         fun column_count: Int `{
 119                 return sqlite3_column_count(recv);
 120         `}
 121
 122         # Reset this statement to its original state, to be reexecuted
 123         fun reset: Sqlite3Code `{ return sqlite3_reset(recv); `}
 124
 125         # Delete this statement
 126         fun finalize: Sqlite3Code `{ return sqlite3_finalize(recv); `}
 127 end
 128
 129 # A database connection
 130 extern class Sqlite3 `{sqlite3 *`}
 131
 132         # Open a connection to a database in UTF-8
 133         new open(filename: String) import String.to_cstring `{
 134                 sqlite3 *self = NULL;
 135                 sqlite3_open(String_to_cstring(filename), &self);
 136                 return self;
 137         `}
 138
 139         # Has this DB been correctly opened?
 140         #
 141         # To know if it has been closed or interrupted, you must check for errors with `error`.
 142         fun is_valid: Bool do return not address_is_null
 143
 144         fun destroy do close
 145
 146         # Close this connection
 147         fun close `{ sqlite3_close_v2(recv); `}
 148
 149         # Execute a SQL statement
 150         fun exec(sql: String): Sqlite3Code import String.to_cstring `{
 151                 return sqlite3_exec(recv, String_to_cstring(sql), 0, 0, 0);
 152         `}
 153
 154         # Prepare a SQL statement
 155         fun prepare(sql: String): nullable Statement import String.to_cstring, Statement.as nullable `{
 156                 sqlite3_stmt *stmt;
 157                 int res = sqlite3_prepare_v2(recv, String_to_cstring(sql), -1, &stmt, 0);
 158                 if (res == SQLITE_OK)
 159                         return Statement_as_nullable(stmt);
 160                 else
 161                         return null_Statement();
 162         `}
 163
 164         fun last_insert_rowid: Int `{
 165                 return sqlite3_last_insert_rowid(recv);
 166         `}
 167
 168         fun error: Sqlite3Code `{
 169                 return sqlite3_errcode(recv);
 170         `}
 171 end