tests: add engine `nitg-sg` for --semi-global

[nit.git] / lib / sqlite3 / sqlite3.nit

diff --git a/lib/sqlite3/sqlite3.nit b/lib/sqlite3/sqlite3.nit
index 94d6e7c..a187c3a 100644 (file)
--- a/lib/sqlite3/sqlite3.nit
+++ b/lib/sqlite3/sqlite3.nit
@@ -15,15 +15,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-module sqlite3
+module sqlite3 is pkgconfig("sqlite3")
 
 in "C header" `{
-       #include "sqlite3.h"
-       struct Data{
-               sqlite3 *ppDb;
-               sqlite3_stmt * stmt;
-       };
-
+       #include <sqlite3.h>
 `}
 
 extern class Sqlite3Code `{int`}
@@ -64,70 +59,55 @@ extern class Sqlite3Code `{int`}
 
        new done `{ return SQLITE_DONE; `} #       101  /* sqlite3_step() has finished executing */
        fun is_done: Bool `{ return recv == SQLITE_DONE; `}
-end
-
-extern Sqlite3 `{struct Data*`}
-       new `{
-               struct Data* data = malloc(sizeof(data));
-               return data;
-       `}
-
-       fun destroy do close
 
-       fun open(filename : String) import String::to_cstring`{ 
-               sqlite3_open(String_to_cstring(filename), &recv->ppDb);
-       `}
-
-       fun close `{
-               sqlite3_close(recv->ppDb);
-               free(recv);
-       `}
-
-       fun exec(sql : String): Sqlite3Code import String::to_cstring `{
-               struct Data * data = recv;
-               return sqlite3_exec(data->ppDb, String_to_cstring(sql), 0, 0, 0);
+       redef fun to_s: String import NativeString.to_s `{
+#if SQLITE_VERSION_NUMBER >= 3007015
+               char *err = (char *)sqlite3_errstr(recv);
+#else
+               char *err = "sqlite3_errstr supported only by version >= 3.7.15";
+#endif
+               if (err == NULL) err = "";
+               return NativeString_to_s(err);
        `}
+end
 
-       fun prepare(sql : String): Sqlite3Code import String::to_cstring `{
-               struct Data * data = recv;
-               return sqlite3_prepare_v2(data->ppDb, String_to_cstring(sql), -1, &(data->stmt), 0);
-       `}
+extern class Statement `{sqlite3_stmt*`}
 
        fun step: Sqlite3Code `{
-               return sqlite3_step(recv->stmt);
+               return sqlite3_step(recv);
        `}
 
-       fun column_name(i: Int) : String import String::from_cstring `{
-               const char * name = (sqlite3_column_name(recv->stmt, i));
+       fun column_name(i: Int) : String import NativeString.to_s `{
+               const char * name = (sqlite3_column_name(recv, i));
                if(name == NULL){
                        name = "";
                }
                char * ret = (char *) name;
-               return new_String_from_cstring(ret);
+               return NativeString_to_s(ret);
        `}
 
        fun column_bytes(i: Int) : Int `{
-               return sqlite3_column_bytes(recv->stmt, i);
+               return sqlite3_column_bytes(recv, i);
        `}
 
        fun column_double(i: Int) : Float `{
-               return sqlite3_column_double(recv->stmt, i);
+               return sqlite3_column_double(recv, i);
        `}
 
        fun column_int(i: Int) : Int `{
-               return sqlite3_column_int(recv->stmt, i);
+               return sqlite3_column_int(recv, i);
        `}
 
-       fun column_text(i: Int) : String import String::from_cstring `{
-               char * ret = (char *) sqlite3_column_text(recv->stmt, i);
+       fun column_text(i: Int) : String import NativeString.to_s `{
+               char * ret = (char *) sqlite3_column_text(recv, i);
                if( ret == NULL ){
                        ret = "";
                }
-               return new_String_from_cstring(ret);
+               return NativeString_to_s(ret);
        `}
 
        fun column_type(i: Int) : Int `{
-               return sqlite3_column_type(recv->stmt, i);
+               return sqlite3_column_type(recv, i);
        `}
 
        #       fun column_blob(i : Int) : String `{
@@ -135,22 +115,39 @@ extern Sqlite3 `{struct Data*`}
        #       `}
 
        fun column_count: Int `{
-               return sqlite3_column_count(recv->stmt);
+               return sqlite3_column_count(recv);
        `}
+end
 
-       fun last_insert_rowid: Int `{
-               return sqlite3_last_insert_rowid(recv->ppDb);
+extern class Sqlite3 `{sqlite3 *`}
+       new open(filename: String) import String.to_cstring `{
+               sqlite3 *self;
+               sqlite3_open(String_to_cstring(filename), &self);
+               return self;
        `}
 
-       fun get_error : Int import String::from_cstring `{
-               return sqlite3_errcode(recv->ppDb);
+       fun destroy do close
+
+       fun close `{ sqlite3_close(recv); `}
+
+       fun exec(sql : String): Sqlite3Code import String.to_cstring `{
+               return sqlite3_exec(recv, String_to_cstring(sql), 0, 0, 0);
        `}
 
-       fun get_error_str : String import String::from_cstring `{
-               char * err =(char *) sqlite3_errmsg(recv->ppDb);
-               if(err == NULL){
-                       err = "";
-               }
-               return new_String_from_cstring(err);
+       fun prepare(sql: String): nullable Statement import String.to_cstring, Statement.as nullable `{
+               sqlite3_stmt *stmt;
+               int res = sqlite3_prepare_v2(recv, String_to_cstring(sql), -1, &stmt, 0);
+               if (res == SQLITE_OK)
+                       return Statement_as_nullable(stmt);
+               else
+                       return null_Statement();
+       `}
+
+       fun last_insert_rowid: Int `{
+               return sqlite3_last_insert_rowid(recv);
+       `}
+
+       fun error: Sqlite3Code `{
+               return sqlite3_errcode(recv);
        `}
 end