unqlite 0.0.1 → 0.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDBhZTE1YWRhMTE2ZDA5ZmFkY2IxNjdhNTk3MDFmZDFhNzFjNWZkNw==
+    MDc2MzhlMjEzMDdmYWZhOWQ0N2EwM2FjNjBjYjE5MzU4MzBkOGNlMA==
   data.tar.gz: !binary |-
-    MWVjY2FhZmIwNzAyNjIwNjY1YTc2ODY1ZTliMjY5MWRmNmJiYTM1Mg==
+    OTlmOWViMzNkNWViNjgwY2I3NGE5OGE5NGM4YjY3NGMxODdlY2U4MA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    YzliODY1OWNlOThlNmU4YWUxZjAzYmY4YWIxYzdmZGVjNzI4YTc1ZDM2MDJl
-    ZjE4MDUzMWNkOTUzYTFlM2U3YmEwZjdlNTYwZWY0MzQxYThiNWM1Mzg3ZThl
-    Mjg0ZGNjZTdhZjczN2M3ZDBiZTNmNDlhNzljYTJiNjZmYmZlNjI=
+    ZTlkODc5NTc2OTA4ZGRjZWNlZWQ3MjhlZWQwMjYyOGJhZTg2MWQxZTk4NjBk
+    OWY3YjBmM2NiYjQ3Y2Y4M2VmNGQ4MWU3ZDZjYjQxM2RkMjg4ODBlODQwMDI3
+    NDRkNjZjNDdmMzI0ZWE2YmVmOWUwOGZlMmM3ZTZhYzRlOWQ3MTA=
   data.tar.gz: !binary |-
-    MjUxYzhhZTZiNzkwYzgyNzY0ZjM3NDRkMDg1NjE4OTIwZTM4Mjc5NmIyOTcw
-    ODllMWZjODlmOTVkZTI4ZjA1NzhmMTY5YzRkNDEyMTUyYzM3ZjlhNGM1NzQ1
-    MWQ1ZDk3MzBkZTg5NWE2ZjI3ZTMxODAyNmFlNmZiZmQwYTY1YWQ=
+    ZTJhODNhMTI4ZDlkZTdlYjhjMjAyOWJiZTg4ZGUyNDBjM2Q4YzBhMzNkZWFi
+    MGNkYWU0MWI1N2EzYzg0MzNmNzc4OGZmYjkxODVmODBlOTE0MTFmMTJkYzU1
+    MTYyMzJiYzRlYmZiMTVkYWM5M2EzNGRhNDRjM2FmNjU2YzgxNGI=

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+=== 0.1.0 / 08 Jun 2013
+
+* Database file support (readonly not supported yet)
+* Exception handling
+* Transaction support
+* API change:
+    * Database#store doesn't return an unqlite_return_code anymore (but still a truthy value).
+
+=== 0.0.1 / 02 Jun 2013
+
+* First version
+* Only basic methods implemented (#new #store #fetch)
+* Only in-memory database support

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in unqlite.gemspec
 gemspec
+
+gem 'pry'

data/README.md

@@ -12,8 +12,9 @@ UnQLite doesn't have a Makefile (or something like that) to automate that step.
 linux, you can check [this gist](https://gist.github.com/danieltdt/5693070) and compile it using gcc.
 
 After installing UnQLite, add this line to your application's Gemfile:
-
-    gem 'unqlite'
+```ruby
+gem 'unqlite'
+```
 
 And then execute:
 
@@ -25,9 +26,26 @@ Or install it yourself as:
 
 ## Usage
 
-    db = UnQLite::Database.new(":mem:")
-    db.store("key", "wabba")
-    db.fetch("key") # => "wabba"
+For in-memory databases
+```ruby
+db = UnQLite::Database.new(":mem:")
+db.store("key", "wabba")
+db.fetch("key") # => "wabba"
+db.close
+```
+
+For regular databases
+```ruby
+db = UnQLite::Database.new("database.db") # You may also give a full path
+db.store("key", "wabba")
+db.fetch("key") # => "wabba"
+
+# Now you have to commit your changes or close your database
+db.commit
+
+db.store("key2", "wabba2")
+db.close # Will automatically commit
+```
 
 ## Contributing
 

data/ext/unqlite/unqlite_codes.c

@@ -20,15 +20,15 @@ void Init_unqlite_codes()
   rb_define_const(mUnQLiteCodes, "PERM",            INT2FIX(UNQLITE_PERM));
   rb_define_const(mUnQLiteCodes, "NOTIMPLEMENTED",  INT2FIX(UNQLITE_NOTIMPLEMENTED));
   rb_define_const(mUnQLiteCodes, "NOTFOUND",        INT2FIX(UNQLITE_NOTFOUND));
-  rb_define_const(mUnQLiteCodes, "NOOP",            INT2FIX(UNQLITE_NOOP));
+  rb_define_const(mUnQLiteCodes, "NOOP",            INT2FIX(UNQLITE_NOOP)); // Used only for jx9 (unqlite v1.1.6)
   rb_define_const(mUnQLiteCodes, "INVALID",         INT2FIX(UNQLITE_INVALID));
   rb_define_const(mUnQLiteCodes, "EOF",             INT2FIX(UNQLITE_EOF));
   rb_define_const(mUnQLiteCodes, "UNKNOWN",         INT2FIX(UNQLITE_UNKNOWN));
   rb_define_const(mUnQLiteCodes, "LIMIT",           INT2FIX(UNQLITE_LIMIT));
   rb_define_const(mUnQLiteCodes, "EXISTS",          INT2FIX(UNQLITE_EXISTS));
   rb_define_const(mUnQLiteCodes, "EMPTY",           INT2FIX(UNQLITE_EMPTY));
-  rb_define_const(mUnQLiteCodes, "COMPILE_ERR",     INT2FIX(UNQLITE_COMPILE_ERR));
-  rb_define_const(mUnQLiteCodes, "VM_ERR",          INT2FIX(UNQLITE_VM_ERR));
+  rb_define_const(mUnQLiteCodes, "COMPILE_ERR",     INT2FIX(UNQLITE_COMPILE_ERR)); // Used only for jx9 (unqlite v1.1.6)
+  rb_define_const(mUnQLiteCodes, "VM_ERR",          INT2FIX(UNQLITE_VM_ERR)); // Used only for jx9 (unqlite v1.1.6)
   rb_define_const(mUnQLiteCodes, "FULL",            INT2FIX(UNQLITE_FULL));
   rb_define_const(mUnQLiteCodes, "CANTOPEN",        INT2FIX(UNQLITE_CANTOPEN));
   rb_define_const(mUnQLiteCodes, "READ_ONLY",       INT2FIX(UNQLITE_READ_ONLY));

data/ext/unqlite/unqlite_database.c

@@ -36,20 +36,33 @@ static VALUE initialize(VALUE self, VALUE rb_string)
   memcpy(c_string, StringValuePtr(rb_string), RSTRING_LEN(rb_string));
 
   // Open database
-  // TODO: Always opening as a memory database. It should be a parameter.
-  rc = unqlite_open(&ctx->pDb, c_string, UNQLITE_OPEN_IN_MEMORY);
+  // TODO: Accept others open mode (read-only + mmap, etc. Check http://unqlite.org/c_api/unqlite_open.html)
+  rc = unqlite_open(&ctx->pDb, c_string, UNQLITE_OPEN_CREATE);
 
-  // Verify if is everything ok
-  if( rc != UNQLITE_OK ){
-    // TODO: Return error code with a better message raising a UnQLite exception.
-    rb_raise(rb_eRuntimeError, "Couldn't open database");
-
-    return self;
-  }
+  // Check if any exception should be raised
+  CHECK(ctx->pDb, rc);
 
   return self;
 }
 
+static VALUE unqlite_database_close(VALUE self)
+{
+  int rc;
+  unqliteRubyPtr ctx;
+
+  // Get class context
+  Data_Get_Struct(self, unqliteRuby, ctx);
+
+  // Close database
+  rc = unqlite_close(ctx->pDb);
+
+  // Check for errors
+  CHECK(ctx->pDb, rc);
+
+  return Qtrue;
+}
+
+
 static VALUE unqlite_database_store(VALUE self, VALUE key, VALUE value)
 {
   void *c_key;
@@ -71,15 +84,13 @@ static VALUE unqlite_database_store(VALUE self, VALUE key, VALUE value)
   c_value = calloc(RSTRING_LEN(value), sizeof(char));
   memcpy(c_value, StringValuePtr(value), RSTRING_LEN(value));
 
+  // Store it
   rc = unqlite_kv_store(ctx->pDb, c_key, -1, c_value, sizeof(c_value));
 
-  if( rc != UNQLITE_OK ) {
-    if( rc != UNQLITE_BUSY && rc != UNQLITE_NOTIMPLEMENTED ) {
-      unqlite_rollback(ctx->pDb);
-    }
-  }
+  // Check for errors
+  CHECK(ctx->pDb, rc);
 
-  return INT2FIX(rc);
+  return Qtrue;
 }
 
 static VALUE unqlite_database_fetch(VALUE self, VALUE collection_name)
@@ -100,16 +111,71 @@ static VALUE unqlite_database_fetch(VALUE self, VALUE collection_name)
   c_collection_name = calloc(RSTRING_LEN(collection_name), sizeof(char));
   memcpy(c_collection_name, StringValuePtr(collection_name), RSTRING_LEN(collection_name));
 
+  // Extract the data size, check for errors and return if any
   rc = unqlite_kv_fetch(ctx->pDb, c_collection_name, -1, NULL, &n_bytes);
-  if( rc != UNQLITE_OK ) { return INT2FIX(rc); }
+  CHECK(ctx->pDb, rc);
+  if( rc != UNQLITE_OK ) { return Qnil; }
 
+  // Data is empty
   fetched_data = (char *)malloc(n_bytes);
-  if( fetched_data == NULL ) { return INT2FIX(UNQLITE_EMPTY); }
+  if( fetched_data == NULL ) { return rb_str_new2(""); }
 
+  // Now, fetch the data
   rc = unqlite_kv_fetch(ctx->pDb, c_collection_name, -1, fetched_data, &n_bytes);
-  if( rc == UNQLITE_OK ) { return rb_str_new2((char *)fetched_data); }
+  CHECK(ctx->pDb, rc);
+
+  return rb_str_new2((char *)fetched_data);
+}
+
+static VALUE unqlite_database_begin_transaction(VALUE self)
+{
+  int rc;
+  unqliteRubyPtr ctx;
+
+  // Get class context
+  Data_Get_Struct(self, unqliteRuby, ctx);
+
+  // Begin write-transaction manually
+  rc = unqlite_begin(ctx->pDb);
+
+  // Check for errors
+  CHECK(ctx->pDb, rc);
 
-  return INT2FIX(rc);
+  return Qtrue;
+}
+
+static VALUE unqlite_database_commit(VALUE self)
+{
+  int rc;
+  unqliteRubyPtr ctx;
+
+  // Get class context
+  Data_Get_Struct(self, unqliteRuby, ctx);
+
+  // Commit transaction
+  rc = unqlite_commit(ctx->pDb);
+
+  // Check for errors
+  CHECK(ctx->pDb, rc);
+
+  return Qtrue;
+}
+
+static VALUE unqlite_database_rollback(VALUE self)
+{
+  int rc;
+  unqliteRubyPtr ctx;
+
+  // Get class context
+  Data_Get_Struct(self, unqliteRuby, ctx);
+
+  // Rollback transaction
+  rc = unqlite_rollback(ctx->pDb);
+
+  // Check for errors
+  CHECK(ctx->pDb, rc);
+
+  return Qtrue;
 }
 
 void Init_unqlite_database()
@@ -126,5 +192,10 @@ void Init_unqlite_database()
   rb_define_method(cUnQLiteDatabase, "store", unqlite_database_store, 2);
   rb_define_method(cUnQLiteDatabase, "fetch", unqlite_database_fetch, 1);
 
+  rb_define_method(cUnQLiteDatabase, "begin_transaction", unqlite_database_begin_transaction, 0);
+  rb_define_method(cUnQLiteDatabase, "commit", unqlite_database_commit, 0);
+  rb_define_method(cUnQLiteDatabase, "rollback", unqlite_database_rollback, 0);
+
   rb_define_method(cUnQLiteDatabase, "initialize", initialize, 1);
+  rb_define_method(cUnQLiteDatabase, "close", unqlite_database_close, 0);
 }

data/ext/unqlite/unqlite_exception.c

@@ -0,0 +1,87 @@
+#include <unqlite_exception.h>
+
+void rb_unqlite_raise(unqlite *db, int rc)
+{
+  VALUE klass = Qnil;
+
+  switch(rc) {
+    case UNQLITE_NOMEM:
+      klass = rb_path2class("UnQLite::MemoryException");
+      break;
+    case UNQLITE_ABORT:
+      klass = rb_path2class("UnQLite::AbortException");
+      break;
+    case UNQLITE_IOERR:
+      klass = rb_path2class("UnQLite::IOException");
+      break;
+    case UNQLITE_CORRUPT:
+      klass = rb_path2class("UnQLite::CorruptException");
+      break;
+    case UNQLITE_LOCKED:
+      klass = rb_path2class("UnQLite::LockedException");
+      break;
+    case UNQLITE_BUSY:
+      klass = rb_path2class("UnQLite::BusyException");
+      break;
+/* Not sure if it is an error or not (check lib/unqlite/errors.rb)
+    case UNQLITE_DONE:
+      klass = rb_path2class("UnQLite::DoneException");
+      break;
+*/
+    case UNQLITE_PERM:
+      klass = rb_path2class("UnQLite::PermissionException");
+      break;
+    case UNQLITE_NOTIMPLEMENTED:
+      klass = rb_path2class("UnQLite::NotImplementedException");
+      break;
+    case UNQLITE_NOTFOUND:
+      klass = rb_path2class("UnQLite::NotFoundException");
+      break;
+    case UNQLITE_EMPTY:
+      klass = rb_path2class("UnQLite::EmptyException");
+      break;
+    case UNQLITE_INVALID:
+      klass = rb_path2class("UnQLite::InvalidParameterException");
+      break;
+    case UNQLITE_EOF:
+      klass = rb_path2class("UnQLite::EOFException");
+      break;
+    case UNQLITE_UNKNOWN:
+      klass = rb_path2class("UnQLite::UnknownConfigurationException");
+      break;
+    case UNQLITE_LIMIT:
+      klass = rb_path2class("UnQLite::LimitReachedException");
+      break;
+    case UNQLITE_FULL:
+      klass = rb_path2class("UnQLite::FullDatabaseException");
+      break;
+    case UNQLITE_CANTOPEN:
+      klass = rb_path2class("UnQLite::CantOpenDatabaseException");
+      break;
+    case UNQLITE_READ_ONLY:
+      klass = rb_path2class("UnQLite::ReadOnlyException");
+      break;
+    case UNQLITE_LOCKERR:
+      klass = rb_path2class("UnQLite::LockProtocolException");
+      break;
+  }
+
+  if( !NIL_P(klass) ) { // Is really an error?
+    const char *buffer;
+    int length;
+
+    // Rollback, please.
+    if( rc != UNQLITE_BUSY && rc != UNQLITE_NOTIMPLEMENTED ) {
+      unqlite_rollback(db);
+    }
+
+    /* Get error from log */
+    unqlite_config(db, UNQLITE_CONFIG_ERR_LOG, &buffer, &length);
+
+    // Raise it!
+    if( length > 0 )
+      rb_raise(klass, "%s", buffer);
+    else
+      rb_raise(klass, "(couldn't retrieve the error message)");
+  }
+}

data/ext/unqlite/unqlite_exception.h

@@ -0,0 +1,10 @@
+#ifndef UNQLITE_RUBY_EXCEPTION
+#define UNQLITE_RUBY_EXCEPTION
+
+#include <unqlite_ruby.h>
+
+/* Macro to raise the proper exception given a return code */
+#define CHECK(_db, _rc) rb_unqlite_raise(_db, _rc);
+void rb_unqlite_raise(unqlite *db, int rc);
+
+#endif

data/ext/unqlite/unqlite_ruby.h

@@ -6,6 +6,7 @@
 
 #include <unqlite_database.h>
 #include <unqlite_codes.h>
+#include <unqlite_exception.h>
 
 extern VALUE mUnQLite;
 

data/lib/unqlite.rb

@@ -1,4 +1,5 @@
 require 'unqlite/unqlite_native'
+require "unqlite/errors"
 require "unqlite/version"
 
 module UnQLite

data/lib/unqlite/errors.rb

@@ -0,0 +1,33 @@
+module UnQLite
+  class Exception < ::StandardError
+    @code = 0
+
+    def self.code
+      @code
+    end
+
+    def code
+      self.class.code
+    end
+  end
+
+  class MemoryException < Exception; end
+  class AbortException < Exception; end
+  class IOException < Exception; end
+  class CorruptException < Exception; end
+  class LockedException < Exception; end # Forbidden operation
+  class BusyException < Exception; end
+  #class DoneException < Exception; end # It is not clear on docs if it's an error or not
+  class PermissionException < Exception; end
+  class NotImplementedException < Exception; end
+  class NotFoundException < Exception; end # It is a quite confusing if is an error or an acceptable behavior (unqlite v1.1.6)
+  class EmptyException < Exception; end # Empty key (and some jx9 functions)
+  class InvalidParameterException < Exception; end
+  class EOFException < Exception; end
+  class UnknownConfigurationException < Exception; end
+  class LimitReachedException < Exception; end
+  class FullDatabaseException < Exception; end
+  class CantOpenDatabaseException < Exception; end
+  class ReadOnlyException < Exception; end
+  class LockProtocolException < Exception; end
+end

data/lib/unqlite/version.rb

@@ -1,3 +1,3 @@
 module UnQLite
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/test/test_database.rb

@@ -1,21 +1,81 @@
+require 'tempfile'
 require 'helper'
 
 module UnQLite
-  class TestDatabase < Minitest::Test
-    attr_reader :db
+  module CommonTestsForDatabase
+    def self.included(klass)
+      klass.class_eval { attr_reader :db_path }
+    end
 
     def setup
-      @db = UnQLite::Database.new(":mem:")
+      @db = UnQLite::Database.new(db_path)
+    end
+
+    def teardown
+      @db.close
     end
 
     def test_store
-      assert_equal UnQLite::Codes::OK, @db.store("key", "stored content")
+      assert @db.store("key", "stored content")
     end
 
     def test_fetch
       @db.store("key", "wabba")
 
-      assert_equal "wabba", @db.fetch("key")
+      assert_equal("wabba", @db.fetch("key"))
+    end
+
+    def test_exceptions
+      # TODO: Test other errors
+      assert_raises(UnQLite::NotFoundException) { @db.fetch("xxx") }
+    end
+  end
+
+  class TestInMemoryDatabase < Minitest::Test
+    include CommonTestsForDatabase
+
+    def initialize(*args)
+      @db_path = ":mem:"
+      super(*args)
+    end
+  end
+
+  class TestDatabase < Minitest::Test
+    include CommonTestsForDatabase
+
+    def setup
+      @tmp = Tempfile.new("test_db")
+      @db_path = @tmp.path
+      @tmp.close
+      super()
+    end
+
+    def teardown
+      super()
+      @tmp.unlink
+    end
+
+    def test_automatic_transaction
+      @db.store("auto", "wabba")
+      @db.rollback
+
+      assert_raises(UnQLite::NotFoundException) { @db.fetch("auto") }
+    end
+
+    def test_manual_transaction
+      @db.begin_transaction
+      @db.store("manual", "wabba")
+      @db.rollback
+
+      assert_raises(UnQLite::NotFoundException) { @db.fetch("manual") }
+
+      @db.store("manual2", "wabba")
+      @db.commit
+      @db.store("will_disapper", "wabba")
+      @db.rollback
+
+      assert_equal("wabba", @db.fetch("manual2"))
+      assert_raises(UnQLite::NotFoundException) { @db.fetch("will_disapper") }
     end
   end
 end

data/test/test_errors.rb

@@ -0,0 +1,36 @@
+require 'helper'
+
+module UnQLite
+  class TestErros < Minitest::Test
+    attr_reader :exceptions
+
+    def setup
+      @exceptions = [
+        UnQLite::MemoryException,
+        UnQLite::AbortException,
+        UnQLite::IOException,
+        UnQLite::CorruptException,
+        UnQLite::LockedException,
+        UnQLite::BusyException,
+        UnQLite::PermissionException,
+        UnQLite::NotImplementedException,
+        UnQLite::NotFoundException,
+        UnQLite::EmptyException,
+        UnQLite::InvalidParameterException,
+        UnQLite::EOFException,
+        UnQLite::UnknownConfigurationException,
+        UnQLite::LimitReachedException,
+        UnQLite::FullDatabaseException,
+        UnQLite::CantOpenDatabaseException,
+        UnQLite::ReadOnlyException,
+        UnQLite::LockedException
+      ] # + [UnQLite::DoneException]
+    end
+
+    def test_respond_to_code
+      exceptions.each do |exception|
+        assert true, exception.respond_to?(:code)
+      end
+    end
+  end
+end

data/unqlite.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "ZenTest"
-  spec.add_development_dependency "rake-compiler"
-  spec.add_development_dependency "minitest", "~> 5.0.3"
+  spec.add_development_dependency "bundler",        "~> 1.3"
+  spec.add_development_dependency "rake",           "~> 10.0.4"
+  spec.add_development_dependency "ZenTest",        "~> 4.9.2"
+  spec.add_development_dependency "rake-compiler",  "~> 0.8.3"
+  spec.add_development_dependency "minitest",       "~> 5.0.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unqlite
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Daniel Teixeira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-02 00:00:00.000000000 Z
+date: 2013-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,44 +28,44 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 10.0.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 10.0.4
 - !ruby/object:Gem::Dependency
   name: ZenTest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.9.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.9.2
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.3
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -90,6 +90,7 @@ extra_rdoc_files: []
 files:
 - .autotest
 - .gitignore
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -100,11 +101,15 @@ files:
 - ext/unqlite/unqlite_codes.h
 - ext/unqlite/unqlite_database.c
 - ext/unqlite/unqlite_database.h
+- ext/unqlite/unqlite_exception.c
+- ext/unqlite/unqlite_exception.h
 - ext/unqlite/unqlite_ruby.h
 - lib/unqlite.rb
+- lib/unqlite/errors.rb
 - lib/unqlite/version.rb
 - test/helper.rb
 - test/test_database.rb
+- test/test_errors.rb
 - unqlite.gemspec
 homepage: https://github.com/danieltdt/unqlite-ruby
 licenses:
@@ -133,3 +138,4 @@ summary: UnQLite for ruby (using C extension)
 test_files:
 - test/helper.rb
 - test/test_database.rb
+- test/test_errors.rb