sqlite 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ace8345c8af9cd81314bed02337bb2572f5922ad
+  data.tar.gz: de1ed790c836c7dc9b9e4a3d08fc299eb3529cbc
+SHA512:
+  metadata.gz: 40ce43c0b2abdc3c73bde7e7d72b059cd114f5a58e95f9e1c36a3f727498de6732c315c7d1c8df29aedc8bf3d9158d8af80ba229bd929ab005f43913cae48247
+  data.tar.gz: e8a255e05717d7dd918f37a3e30ff64b05765bf3a3f48673b3765b68d86a9e73242c0b7a6911c1ce5b8220687d498ec83ea4f85506fcc5f70ba0c58de7c7208c

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) RubyGems.org
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rake/extensiontask'
+require 'rubygems/package_task'
+
+Rake::ExtensionTask.new 'sqlite' do |ext|
+
+  # This causes the shared object to be placed in lib/sqlite/sqlite.so
+  #
+  # It allows lib/sqlite.rb to load different versions if you ship a
+  # precompiled extension that supports multiple ruby versions.
+
+  ext.lib_dir = 'lib/sqlite'
+end
+
+s = Gem::Specification.new 'sqlite', '1.0.2' do |s|
+  s.summary = 'Small, Simple SQLite extension'
+  s.authors = %w[mikeowens@gmail.com]
+
+  # This tells RubyGems to build an extension upon install
+
+  s.extensions = %w[ext/sqlite/extconf.rb]
+
+  # naturally you must include the extension source in the gem
+
+  s.files = %w[
+    MIT-LICENSE
+    Rakefile
+    ext/sqlite/extconf.rb
+    ext/sqlite/main.c
+    ext/sqlite/sqlite3_dist.c
+    ext/sqlite/ruby_sqlite3.c
+    ext/sqlite/ruby_sqlite3.h
+    ext/sqlite/ruby_sqlite3_stmt.c
+    ext/sqlite/ruby_sqlite3_stmt.h
+    lib/sqlite.rb
+  ]
+end
+
+# The package task builds the gem in pkg/sqlite-1.0.gem so you can test
+# installing it.
+
+Gem::PackageTask.new s do end
+
+# This isn't a good test, but does provide a sanity check
+
+task test: %w[compile] do
+  ruby '-Ilib', '-rsqlite', '-e', 'p SQLite::Database.new()'
+end
+
+task default: :test
+

data/ext/sqlite/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+# have_func returns false if a C function cannot be found.  Sometimes this
+# will be OK (the function changed names between versions) and sometimes it is
+# not so you need to exit without creating the Makefile.
+
+abort 'missing malloc()' unless have_func 'malloc'
+abort 'missing free()'   unless have_func 'free'
+
+# Now we create the Makefile that will install the extension as
+# lib/sqlite/sqlite.so.
+
+create_makefile 'sqlite/sqlite'
+

data/ext/sqlite/main.c

@@ -0,0 +1,12 @@
+#include <ruby.h>
+
+#include "ruby_sqlite3.h"
+#include "ruby_sqlite3_stmt.h"
+
+void Init_sqlite()
+{
+    VALUE mod = rb_define_module("SQLite");
+
+    init_sqlite3(mod);
+    init_sqlite3_stmt(mod);
+}

data/ext/sqlite/ruby_sqlite3.c

@@ -0,0 +1,368 @@
+#include <stdbool.h>
+#include <ruby.h>
+
+#include "sqlite3.h"
+#include "ruby_sqlite3.h"
+#include "ruby_sqlite3_stmt.h"
+
+#define CLASS_NAME "Database"
+
+static VALUE m_aborted(VALUE self);
+static VALUE m_init(VALUE self);
+static VALUE m_open(VALUE self, VALUE db);
+static VALUE m_close(VALUE self);
+static VALUE m_prepare(VALUE self, VALUE sql);
+static VALUE m_finalize(VALUE self, VALUE stmt);
+static VALUE m_errno(VALUE self);
+static VALUE m_error(VALUE self);
+static VALUE m_begin(VALUE self);
+static VALUE m_commit(VALUE self);
+static VALUE m_rollback(VALUE self);
+static VALUE m_exec(VALUE self, VALUE sql);
+static VALUE m_insert_id(VALUE self);
+
+typedef struct connection
+{
+    sqlite3* handle;
+    int rc;
+    bool dont_delete;
+} connection;
+
+static connection* get_object(VALUE self);
+
+static void deallocator(void* x)
+{
+    if (x != NULL)
+    {
+        connection* c = (connection*)x;
+
+        if (c->handle != NULL)
+        {
+            if (c->dont_delete == false)
+            {
+                sqlite3_close(c->handle);
+            }
+
+            c->handle = NULL;
+        }
+
+        free(x);
+    }
+}
+
+static VALUE allocator(VALUE cls)
+{
+    connection* c = (connection*)malloc(sizeof(connection));
+
+    // Set dont_delete to false -- we have to clean this up as we allocated it.
+    c->dont_delete == false;
+
+    return Data_Wrap_Struct(cls, NULL, deallocator, c);
+}
+
+static VALUE cls;
+
+VALUE make_sqlite3_object(sqlite3* handle)
+{
+    connection* c = (connection*)malloc(sizeof(connection));
+
+    // Store the handle
+    c->handle = handle;
+
+    // Set dont_delete to true -- we don't clean it up as we did not allocate
+    // it.
+    c->dont_delete == true;
+
+    return Data_Wrap_Struct(cls, NULL, deallocator, c);
+}
+
+void init_sqlite3(VALUE module)
+{
+    cls = rb_define_class_under(module, CLASS_NAME, rb_cObject);
+    rb_define_alloc_func(cls, allocator);
+
+    rb_define_method(cls, "initialize",  m_init, 0);
+    rb_define_method(cls, "open",        m_open, 1);
+    rb_define_method(cls, "close",       m_close, 0);
+    rb_define_method(cls, "prepare",     m_prepare, 1);
+    rb_define_method(cls, "errno",       m_errno, 0);
+    rb_define_method(cls, "error",       m_error, 0);
+    rb_define_method(cls, "finalize",    m_finalize, 1);
+    rb_define_method(cls, "begin",       m_begin, 0);
+    rb_define_method(cls, "commit",      m_commit, 0);
+    rb_define_method(cls, "rollback",    m_rollback, 0);
+    rb_define_method(cls, "exec",        m_exec, 1);
+    rb_define_method(cls, "insertId",    m_insert_id, 0);
+
+    // SQLite constants
+    rb_define_global_const("SQLITE_OK",         INT2NUM(SQLITE_OK));
+    rb_define_global_const("SQLITE_ERROR",      INT2NUM(SQLITE_ERROR));
+    rb_define_global_const("SQLITE_INTERNAL",   INT2NUM(SQLITE_INTERNAL));
+    rb_define_global_const("SQLITE_PERM",       INT2NUM(SQLITE_PERM));
+    rb_define_global_const("SQLITE_ABORT",      INT2NUM(SQLITE_ABORT));
+    rb_define_global_const("SQLITE_BUSY",       INT2NUM(SQLITE_BUSY));
+    rb_define_global_const("SQLITE_LOCKED",     INT2NUM(SQLITE_LOCKED));
+    rb_define_global_const("SQLITE_NOMEM",      INT2NUM(SQLITE_NOMEM));
+    rb_define_global_const("SQLITE_READONLY",   INT2NUM(SQLITE_READONLY));
+    rb_define_global_const("SQLITE_INTERRUPT",  INT2NUM(SQLITE_INTERRUPT));
+    rb_define_global_const("SQLITE_IOERR",      INT2NUM(SQLITE_IOERR));
+    rb_define_global_const("SQLITE_CORRUPT",    INT2NUM(SQLITE_CORRUPT));
+    rb_define_global_const("SQLITE_NOTFOUND",   INT2NUM(SQLITE_NOTFOUND));
+    rb_define_global_const("SQLITE_FULL",       INT2NUM(SQLITE_FULL));
+    rb_define_global_const("SQLITE_CANTOPEN",   INT2NUM(SQLITE_CANTOPEN));
+    rb_define_global_const("SQLITE_PROTOCOL",   INT2NUM(SQLITE_PROTOCOL));
+    rb_define_global_const("SQLITE_EMPTY",      INT2NUM(SQLITE_EMPTY));
+    rb_define_global_const("SQLITE_SCHEMA",     INT2NUM(SQLITE_SCHEMA));
+    rb_define_global_const("SQLITE_TOOBIG",     INT2NUM(SQLITE_TOOBIG));
+    rb_define_global_const("SQLITE_CONSTRAINT", INT2NUM(SQLITE_CONSTRAINT));
+    rb_define_global_const("SQLITE_MISMATCH",   INT2NUM(SQLITE_MISMATCH));
+    rb_define_global_const("SQLITE_MISUSE",     INT2NUM(SQLITE_MISUSE));
+    rb_define_global_const("SQLITE_NOLFS",      INT2NUM(SQLITE_NOLFS));
+    rb_define_global_const("SQLITE_AUTH",       INT2NUM(SQLITE_AUTH));
+    rb_define_global_const("SQLITE_ROW",        INT2NUM(SQLITE_ROW));
+    rb_define_global_const("SQLITE_DONE",       INT2NUM(SQLITE_DONE));
+
+    // SQLite storage classes
+    rb_define_global_const("SQLITE_INTEGER",    INT2NUM(SQLITE_INTEGER));
+    rb_define_global_const("SQLITE_FLOAT",      INT2NUM(SQLITE_FLOAT));
+    rb_define_global_const("SQLITE_BLOB",       INT2NUM(SQLITE_BLOB));
+    rb_define_global_const("SQLITE_NULL",       INT2NUM(SQLITE_NULL));
+    rb_define_global_const("SQLITE_TEXT",       INT2NUM(SQLITE_TEXT));
+}
+
+VALUE m_init(VALUE self)
+{
+    return self;
+}
+
+VALUE sqlite3_class()
+{
+    return cls;
+}
+
+connection* get_object(VALUE self)
+{
+    connection* c;
+    Data_Get_Struct(self, connection, c);
+
+    return c;
+}
+
+#define ENSURE_CONNECTION(x)                              \
+    if(x->handle == NULL)                                 \
+    {                                                     \
+        rb_raise( rb_eRuntimeError, "Invalid db handle"); \
+    }
+
+sqlite3* get_sqlite3_handle(VALUE self)
+{
+    connection* c;
+    Data_Get_Struct(self, connection, c);
+
+    return c->handle;
+}
+
+VALUE m_errno(VALUE self)
+{
+    connection* c = get_object(self);
+
+    return INT2FIX(c->rc);
+}
+
+VALUE m_error(VALUE self)
+{
+    connection* c = get_object(self);
+
+    ENSURE_CONNECTION(c)
+
+    return rb_str_new2(sqlite3_errmsg(c->handle));
+}
+
+VALUE m_open(VALUE self, VALUE db)
+{
+    connection* c = get_object(self);
+
+    bool file_exists = (access(StringValuePtr(db), R_OK) == 0);
+
+    c->rc = SQLITE_OK;
+    c->rc = sqlite3_open(StringValuePtr(db), &c->handle);
+
+    //register_sql_functions(c->handle);
+
+    // If the file already exists
+    if (file_exists)
+    {
+        // sqlite3_open() will open anything and not complain. It does not check to
+        // see if the file is a valid SQLite database. We need to know this now. So
+        // we check to see if this is in fact a valid SQLite database file by
+        // compiling a simple statement. The compilation alone will force SQLite to
+        // go the the file for inforamtion, which will determine its validity. If
+        // this statement does not compile, we don't have a valid database.
+
+        const char* sql = "select count(*) from sqlite_master";
+        sqlite3_stmt* stmt;
+        c->rc = sqlite3_prepare(c->handle, sql, strlen(sql), &stmt, NULL);
+        sqlite3_finalize(stmt);
+    }
+
+    return INT2FIX(c->rc);
+}
+
+VALUE m_close(VALUE self)
+{
+    connection* c = get_object(self);
+
+    ENSURE_CONNECTION(c)
+
+    if (c->handle != NULL)
+    {
+        c->rc = sqlite3_close(c->handle);
+
+        // If rc != SQLITE_OK, then there is an unfinalized statement, and the
+        // connection was not closed. We return c->rc to indicate this, so
+        // caller at least can check for this condition.
+        if (c->rc == SQLITE_OK)
+        {
+            // Closed. Set handle to NULL to indiciate this
+            c->handle = NULL;
+        }
+    }
+    else
+    {
+        c->rc = SQLITE_OK;
+    }
+
+    return INT2FIX(c->rc);
+}
+
+VALUE m_prepare(VALUE self, VALUE sql)
+{
+    connection* c = get_object(self);
+
+    ENSURE_CONNECTION(c)
+
+    if (c->handle == NULL)
+    {
+        c->rc = SQLITE_ERROR;
+
+        return Qnil;
+    }
+
+    return make_sqlite3_stmt(self, c->handle, sql);
+}
+
+VALUE m_finalize(VALUE self, VALUE stmt_object)
+{
+    Check_Type(stmt_object, T_DATA);
+
+    // Require that db be a C ext type
+    Check_Type(stmt_object, T_DATA);
+
+    // Require that db be of SQLite class
+    if (rb_obj_is_instance_of(stmt_object, sqlite3_stmt_class()) == Qfalse)
+    {
+        rb_raise( rb_eRuntimeError,
+                  "wrong argument type %s (expected %s)",
+                  rb_obj_classname(stmt_object),
+                  rb_class2name(cls)
+                );
+    }
+
+    connection* c = get_object(self);
+    c->rc = SQLITE_OK;
+
+    statement* stmt;
+    Data_Get_Struct(stmt_object, statement, stmt);
+
+    c->rc = sqlite3_finalize(stmt->handle);
+
+    // Set to NULL so it won't be finalized by destructor
+    stmt->handle = NULL;
+
+    return INT2FIX(c->rc);
+}
+
+VALUE m_begin(VALUE self)
+{
+    connection* c = get_object(self);
+
+    ENSURE_CONNECTION(c)
+
+    if (c->handle == NULL)
+    {
+        c->rc = SQLITE_ERROR;
+
+        return Qnil;
+    }
+
+    c->rc = sqlite3_exec(c->handle, "BEGIN", NULL, NULL, NULL);
+
+    return INT2FIX(c->rc);
+}
+
+VALUE m_commit(VALUE self)
+{
+    connection* c = get_object(self);
+
+    ENSURE_CONNECTION(c)
+
+    if (c->handle == NULL)
+    {
+        c->rc = SQLITE_ERROR;
+
+        return Qnil;
+    }
+
+    c->rc = sqlite3_exec(c->handle, "COMMIT", NULL, NULL, NULL);
+
+    return INT2FIX(c->rc);
+}
+
+VALUE m_rollback(VALUE self)
+{
+    connection* c = get_object(self);
+
+    ENSURE_CONNECTION(c)
+
+    if (c->handle == NULL)
+    {
+        c->rc = SQLITE_ERROR;
+
+        return Qnil;
+    }
+
+    c->rc = sqlite3_exec(c->handle, "ROLLBACK", NULL, NULL, NULL);
+
+    return INT2FIX(c->rc);
+}
+
+VALUE m_exec(VALUE self, VALUE sql)
+{
+    connection* c = get_object(self);
+
+    ENSURE_CONNECTION(c)
+
+    if (c->handle == NULL)
+    {
+        c->rc = SQLITE_ERROR;
+
+        return Qnil;
+    }
+
+    Check_Type(sql, T_STRING);
+
+    const char* zSQL = StringValuePtr(sql);
+
+    c->rc = sqlite3_exec(c->handle, zSQL, NULL, NULL, NULL);
+
+    return INT2FIX(c->rc);
+}
+
+VALUE m_insert_id(VALUE self)
+{
+    connection* c = get_object(self);
+
+    ENSURE_CONNECTION(c)
+
+    return INT2NUM(sqlite3_last_insert_rowid(c->handle));
+}