extralite 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6467de8ba44e1e77c57965e0360a18f9e2cf97084f0c507d0b1946e2cb0bb153
+  data.tar.gz: a12610ea4fab0207d5360f5410428ab7d8ce004c98ecd05fcb13785bf173c196
+SHA512:
+  metadata.gz: 5c17e8b73c0e94718a80bdcce58c98072c640b952959b441c7053f367984650688ee25ce5d7e0c6c4706d9d13d688f6e006c336e78c0c803d35af3a9cab15885
+  data.tar.gz: 194b2b8e9d469927e08bb6bc9b9e88238fb2b289bace6501c736817cfdee29e4c13d20d420a1a344c107ce039786b703826a11091a8f2eb3cc366dde6f922d46

data/.gitignore

@@ -0,0 +1,57 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+lib/extralite_ext.*
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Digital Fabric
+
+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/README.md

@@ -0,0 +1,51 @@
+## Extralite
+
+Extralite is an extra-lightweight SQLite3 wrapper for Ruby. It provides a single
+class with a minimal set of methods to interact with an SQLite3 database.
+
+### Features
+
+- A variety of ways to get back query results: row as hash, row as array, single
+  column, single value.
+- Iterate over records with a block, or collect records into an array.
+- Parameter binding.
+- Get last insert rowid.
+- Get number of rows changed by last query.
+
+### Usage
+
+```ruby
+require 'extralite'
+
+# open a database
+db = Extralite::Database.new('mydb')
+
+# get query results as array of hashes
+db.query_hash('select 1 as foo') #=> [{ :foo => 1 }]
+# or iterate over results
+db.query_hash('select 1 as foo') { |r| p r }
+# { :foo => 1 }
+
+# get query results as array of arrays
+db.query_ary('select 1, 2, 3') #=> [[1, 2, 3]]
+# or iterate over results
+db.query_ary('select 1, 2, 3') { |r| p r }
+# [1, 2, 3]
+
+# get single column query results as array of values
+db.query_single_column('select 42') #=> [42]
+# or iterate over results
+db.query_single_column('select 42') { |v| p v }
+# 42
+
+# get single value from first row of results
+db.query_single_value("select 'foo'") #=> "foo"
+
+# parameter binding (works for all query_xxx methods)
+db.query_hash('select ? as foo, ? as bar', 1, 2) #=> [{ :foo => 1, :bar => 2 }]
+
+# get last insert rowid
+rowid = db.last_insert_id()
+```
+
+

data/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/clean"
+
+require "rake/extensiontask"
+Rake::ExtensionTask.new("extralite_ext") do |ext|
+  ext.ext_dir = "ext/extralite"
+end
+
+task :recompile => [:clean, :compile]
+
+task :default => [:compile, :test]
+task :test do
+  exec 'ruby test/run.rb'
+end
+
+CLEAN.include "**/*.o", "**/*.so", "**/*.so.*", "**/*.a", "**/*.bundle", "**/*.jar", "pkg", "tmp"

data/ext/extralite/extconf.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# require 'rubygems'
+# require 'mkmf'
+
+# # $CFLAGS << "-Wdiscarded-qualifier"
+#   # $CFLAGS << " -Wno-comment"
+#   # $CFLAGS << " -Wno-unused-result"
+#   # $CFLAGS << " -Wno-dangling-else"
+#   # $CFLAGS << " -Wno-parentheses"
+
+# dir_config 'extralite_ext'
+# create_makefile 'extralite_ext'
+
+ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
+
+require 'mkmf'
+
+# :stopdoc:
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+ldflags = cppflags = nil
+if RbConfig::CONFIG["host_os"] =~ /darwin/
+  begin
+    if with_config('sqlcipher')
+      brew_prefix = `brew --prefix sqlcipher`.chomp
+      ldflags   = "#{brew_prefix}/lib"
+      cppflags  = "#{brew_prefix}/include/sqlcipher"
+      pkg_conf  = "#{brew_prefix}/lib/pkgconfig"
+    else
+      brew_prefix = `brew --prefix sqlite3`.chomp
+      ldflags   = "#{brew_prefix}/lib"
+      cppflags  = "#{brew_prefix}/include"
+      pkg_conf  = "#{brew_prefix}/lib/pkgconfig"
+    end
+
+    # pkg_config should be less error prone than parsing compiler
+    # commandline options, but we need to set default ldflags and cpp flags
+    # in case the user doesn't have pkg-config installed
+    ENV['PKG_CONFIG_PATH'] ||= pkg_conf
+  rescue
+  end
+end
+
+if with_config('sqlcipher')
+  pkg_config("sqlcipher")
+else
+  pkg_config("sqlite3")
+end
+
+# --with-sqlite3-{dir,include,lib}
+if with_config('sqlcipher')
+  $CFLAGS << ' -DUSING_SQLCIPHER'
+  dir_config("sqlcipher", cppflags, ldflags)
+else
+  dir_config("sqlite3", cppflags, ldflags)
+end
+
+if RbConfig::CONFIG["host_os"] =~ /mswin/
+  $CFLAGS << ' -W3'
+end
+
+if RUBY_VERSION < '2.7'
+  $CFLAGS << ' -DTAINTING_SUPPORT'
+end
+
+def asplode missing
+  if RUBY_PLATFORM =~ /mingw|mswin/
+    abort "#{missing} is missing. Install SQLite3 from " +
+          "http://www.sqlite.org/ first."
+  else
+    abort <<-error
+#{missing} is missing. Try 'brew install sqlite3',
+'yum install sqlite-devel' or 'apt-get install libsqlite3-dev'
+and check your shared library search path (the
+location where your sqlite3 shared library is located).
+    error
+  end
+end
+
+asplode('sqlite3.h')  unless find_header  'sqlite3.h'
+find_library 'pthread', 'pthread_create' # 1.8 support. *shrug*
+
+have_library 'dl' # for static builds
+
+if with_config('sqlcipher')
+  asplode('sqlcipher') unless find_library 'sqlcipher', 'sqlite3_libversion_number'
+else
+  asplode('sqlite3') unless find_library 'sqlite3', 'sqlite3_libversion_number'
+end
+
+# Functions defined in 1.9 but not 1.8
+have_func('rb_proc_arity')
+
+# Functions defined in 2.1 but not 2.0
+have_func('rb_integer_pack')
+
+# These functions may not be defined
+have_func('sqlite3_initialize')
+have_func('sqlite3_backup_init')
+have_func('sqlite3_column_database_name')
+have_func('sqlite3_enable_load_extension')
+have_func('sqlite3_load_extension')
+
+unless have_func('sqlite3_open_v2')
+  abort "Please use a newer version of SQLite3"
+end
+
+have_func('sqlite3_prepare_v2')
+have_type('sqlite3_int64', 'sqlite3.h')
+have_type('sqlite3_uint64', 'sqlite3.h')
+
+dir_config('extralite_ext')
+create_makefile('extralite_ext')

data/ext/extralite/extralite.c

@@ -0,0 +1,375 @@
+#include <stdio.h>
+#include "ruby.h"
+#include "../sqlite3/sqlite3.h"
+
+VALUE cError;
+
+typedef struct Database_t {
+  sqlite3 *sqlite3_db;
+} Database_t;
+
+static size_t Database_size(const void *ptr) {
+  return sizeof(Database_t);
+}
+
+static void Database_free(void *ptr) {
+  Database_t *db = ptr;
+  if (db->sqlite3_db) {
+    sqlite3_close(db->sqlite3_db);
+  }
+  // close db
+  free(ptr);
+}
+
+static const rb_data_type_t Database_type = {
+    "Database",
+    {0, Database_free, Database_size,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Database_allocate(VALUE klass) {
+  Database_t *db = ALLOC(Database_t);
+  db->sqlite3_db = 0;
+  return TypedData_Wrap_Struct(klass, &Database_type, db);
+}
+
+#define GetDatabase(obj, database) \
+  TypedData_Get_Struct((obj), Database_t, &Database_type, (database))
+
+
+VALUE Database_initialize(VALUE self, VALUE path) {
+  int rc;
+  Database_t *db;
+  GetDatabase(self, db);
+
+  rc = sqlite3_open(StringValueCStr(path), &db->sqlite3_db);
+  if (rc) {
+    fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db->sqlite3_db));
+    sqlite3_close(db->sqlite3_db);
+    // TODO: raise error
+    return Qfalse;
+  }
+
+  return Qnil;
+}
+
+inline VALUE get_column_value(sqlite3_stmt *stmt, int col, int type) {
+  switch (type) {
+    case SQLITE_NULL:
+      return Qnil;
+    case SQLITE_INTEGER:
+      return INT2NUM(sqlite3_column_int(stmt, col));
+    case SQLITE_FLOAT:
+      return DBL2NUM(sqlite3_column_double(stmt, col));
+    case SQLITE_TEXT:
+      return rb_str_new_cstr((char *)sqlite3_column_text(stmt, col));
+    case SQLITE_BLOB:
+      rb_raise(cError, "BLOB reading not yet implemented");
+    default:
+      rb_raise(cError, "Unknown column type: %d", type);
+  }
+
+  return Qnil;
+}
+
+static inline void bind_parameter_value(sqlite3_stmt *stmt, int pos, VALUE value) {
+  switch (TYPE(value)) { 
+    case T_NIL:
+      sqlite3_bind_null(stmt, pos);
+      return;
+    case T_FIXNUM:
+      sqlite3_bind_int(stmt, pos, NUM2INT(value));
+      return;
+    case T_FLOAT:
+      sqlite3_bind_double(stmt, pos, NUM2DBL(value));
+      return;
+    case T_TRUE:
+      sqlite3_bind_int(stmt, pos, 1);
+      return;
+    case T_FALSE:
+      sqlite3_bind_int(stmt, pos, 0);
+      return;
+    case T_STRING:
+      sqlite3_bind_text(stmt, pos, RSTRING_PTR(value), RSTRING_LEN(value), SQLITE_TRANSIENT);
+      return;
+    default:
+      rb_raise(cError, "Cannot bind parameter at position %d", pos);
+  }
+}
+
+static inline void bind_all_parameters(sqlite3_stmt *stmt, int argc, VALUE *argv) {
+  if (argc > 1) {
+    for (int i = 1; i < argc; i++) {
+      bind_parameter_value(stmt, i, argv[i]);
+    }
+  }
+}
+
+static inline VALUE get_column_names(sqlite3_stmt *stmt, int column_count) {
+  VALUE arr = rb_ary_new2(column_count);
+  for (int i = 0; i < column_count; i++) { 
+    VALUE name = ID2SYM(rb_intern(sqlite3_column_name(stmt, i)));
+    rb_ary_push(arr, name);
+  }
+  return arr;
+}
+
+static inline VALUE row_to_hash(sqlite3_stmt *stmt, int column_count, VALUE column_names) {
+  VALUE row = rb_hash_new();
+  for (int i = 0; i < column_count; i++) {
+    VALUE value = get_column_value(stmt, i, sqlite3_column_type(stmt, i));
+    rb_hash_aset(row, RARRAY_AREF(column_names, i), value);
+  }
+  return row;
+}
+
+VALUE Database_query_hash(int argc, VALUE *argv, VALUE self) {
+  int rc;
+  sqlite3_stmt* stmt;
+  int column_count;
+  Database_t *db;
+  VALUE result = self;
+  int yield_to_block = rb_block_given_p();
+  VALUE row;
+  VALUE column_names;
+  VALUE sql;
+  
+  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+  sql = argv[0];
+  GetDatabase(self, db);
+
+  rc = sqlite3_prepare(db->sqlite3_db, RSTRING_PTR(sql), RSTRING_LEN(sql), &stmt, 0);
+  if (rc) {
+    sqlite3_finalize(stmt);
+    rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
+    return Qnil;
+  }
+
+  bind_all_parameters(stmt, argc, argv);
+  column_count = sqlite3_column_count(stmt);
+  column_names = get_column_names(stmt, column_count);
+
+  // block not given, so prepare the array of records to be returned
+  if (!yield_to_block) result = rb_ary_new();
+    
+step:
+  rc = sqlite3_step(stmt);
+  switch (rc) {
+    case SQLITE_ROW:
+      row = row_to_hash(stmt, column_count, column_names);
+      if (yield_to_block) rb_yield(row); else rb_ary_push(result, row);
+      goto step;
+    case SQLITE_DONE:
+      break;
+    case SQLITE_BUSY:
+      rb_raise(cError, "Database is busy");
+    case SQLITE_ERROR:
+      rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
+    default:
+      rb_raise(cError, "Invalid return code for sqlite3_step: %d", rc);
+  }
+  sqlite3_finalize(stmt);
+  RB_GC_GUARD(column_names);
+  RB_GC_GUARD(row);
+  RB_GC_GUARD(result);
+  return result;
+}
+
+static inline VALUE row_to_ary(sqlite3_stmt *stmt, int column_count) {
+  VALUE row = rb_ary_new2(column_count);
+  for (int i = 0; i < column_count; i++) {
+    VALUE value = get_column_value(stmt, i, sqlite3_column_type(stmt, i));
+    rb_ary_push(row, value);
+  }
+  return row;
+}
+
+VALUE Database_query_ary(int argc, VALUE *argv, VALUE self) {
+  int rc;
+  sqlite3_stmt* stmt;
+  int column_count;
+  Database_t *db;
+  VALUE result = self;
+  int yield_to_block = rb_block_given_p();
+  VALUE row;
+  VALUE sql;
+
+  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+  sql = argv[0];
+  GetDatabase(self, db);
+
+  rc = sqlite3_prepare(db->sqlite3_db, RSTRING_PTR(sql), RSTRING_LEN(sql), &stmt, 0);
+  if (rc) {
+    fprintf(stderr, "Failed to prepare statement: %s\n", sqlite3_errmsg(db->sqlite3_db));
+    sqlite3_finalize(stmt);
+    // TODO: raise error
+    return Qfalse;
+  }
+
+  bind_all_parameters(stmt, argc, argv);
+  column_count = sqlite3_column_count(stmt);
+
+  // block not given, so prepare the array of records to be returned
+  if (!yield_to_block) result = rb_ary_new();
+step:
+  rc = sqlite3_step(stmt);
+  switch (rc) {
+    case SQLITE_ROW:
+      row = row_to_ary(stmt, column_count);
+      if (yield_to_block) rb_yield(row); else rb_ary_push(result, row);
+      goto step;
+    case SQLITE_DONE:
+      break;
+    case SQLITE_BUSY:
+      rb_raise(cError, "Database is busy");
+    case SQLITE_ERROR:
+      rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
+    default:
+      rb_raise(cError, "Invalid return code for sqlite3_step: %d", rc);
+  }
+  sqlite3_finalize(stmt);
+  RB_GC_GUARD(row);
+  RB_GC_GUARD(result);
+  return result;
+}
+
+VALUE Database_query_single_column(int argc, VALUE *argv, VALUE self) {
+  int rc;
+  sqlite3_stmt* stmt;
+  int column_count;
+  Database_t *db;
+  VALUE result = self;
+  int yield_to_block = rb_block_given_p();
+  VALUE sql;
+  VALUE value;
+
+  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+  sql = argv[0];
+  GetDatabase(self, db);
+
+  rc = sqlite3_prepare(db->sqlite3_db, RSTRING_PTR(sql), RSTRING_LEN(sql), &stmt, 0);
+  if (rc) {
+    fprintf(stderr, "Failed to prepare statement: %s\n", sqlite3_errmsg(db->sqlite3_db));
+    sqlite3_finalize(stmt);
+    // TODO: raise error
+    return Qfalse;
+  }
+
+  bind_all_parameters(stmt, argc, argv);
+  column_count = sqlite3_column_count(stmt);
+  if (column_count != 1)
+    rb_raise(cError, "Expected query result to have 1 column");
+
+  // block not given, so prepare the array of records to be returned
+  if (!yield_to_block) result = rb_ary_new();
+step:
+  rc = sqlite3_step(stmt);
+  switch (rc) {
+    case SQLITE_ROW:
+      value = get_column_value(stmt, 0, sqlite3_column_type(stmt, 0));
+      if (yield_to_block) rb_yield(value); else rb_ary_push(result, value);
+      goto step;
+    case SQLITE_DONE:
+      break;
+    case SQLITE_BUSY:
+      rb_raise(cError, "Database is busy");
+    case SQLITE_ERROR:
+      rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
+    default:
+      rb_raise(cError, "Invalid return code for sqlite3_step: %d", rc);
+  }
+
+  sqlite3_finalize(stmt);
+  RB_GC_GUARD(value);
+  RB_GC_GUARD(result);
+  return result;
+}
+
+VALUE Database_query_single_value(int argc, VALUE *argv, VALUE self) {
+  int rc;
+  sqlite3_stmt* stmt;
+  int column_count;
+  Database_t *db;
+  VALUE sql;
+  VALUE value = Qnil;
+
+  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+  sql = argv[0];
+  GetDatabase(self, db);
+
+  rc = sqlite3_prepare(db->sqlite3_db, RSTRING_PTR(sql), RSTRING_LEN(sql), &stmt, 0);
+  if (rc) {
+    fprintf(stderr, "Failed to prepare statement: %s\n", sqlite3_errmsg(db->sqlite3_db));
+    sqlite3_finalize(stmt);
+    // TODO: raise error
+    return Qfalse;
+  }
+
+  bind_all_parameters(stmt, argc, argv);
+  column_count = sqlite3_column_count(stmt);
+  if (column_count != 1)
+    rb_raise(cError, "Expected query result to have 1 column");
+
+  rc = sqlite3_step(stmt);
+  switch (rc) {
+    case SQLITE_ROW:
+      value = get_column_value(stmt, 0, sqlite3_column_type(stmt, 0));
+      break;
+    case SQLITE_BUSY:
+      rb_raise(cError, "Database is busy");
+    case SQLITE_ERROR:
+      rb_raise(cError, "%s", sqlite3_errmsg(db->sqlite3_db));
+    default:
+      rb_raise(cError, "Invalid return code for sqlite3_step: %d", rc);
+  }
+
+  sqlite3_finalize(stmt);
+  RB_GC_GUARD(value);
+  return value;
+}
+
+VALUE Database_last_insert_rowid(VALUE self) {
+  Database_t *db;
+  GetDatabase(self, db);
+
+  return INT2NUM(sqlite3_last_insert_rowid(db->sqlite3_db));
+}
+
+VALUE Database_changes(VALUE self) {
+  Database_t *db;
+  GetDatabase(self, db);
+
+  return INT2NUM(sqlite3_changes(db->sqlite3_db));
+}
+
+VALUE Database_filename(int argc, VALUE *argv, VALUE self) {
+  const char *db_name;
+  const char *filename;
+  Database_t *db;
+  GetDatabase(self, db);
+
+  rb_check_arity(argc, 0, 1);
+  db_name = (argc == 1) ? StringValueCStr(argv[0]) : "main";
+  filename = sqlite3_db_filename(db->sqlite3_db, db_name);
+  return filename ? rb_str_new_cstr(filename) : Qnil;
+}
+
+void Init_Extralite() {
+  VALUE mExtralite = rb_define_module("Extralite");
+  VALUE cDatabase = rb_define_class_under(mExtralite, "Database", rb_cObject);
+  rb_define_alloc_func(cDatabase, Database_allocate);
+
+  rb_define_method(cDatabase, "initialize", Database_initialize, 1);
+  
+  rb_define_method(cDatabase, "query", Database_query_hash, -1);
+  rb_define_method(cDatabase, "query_hash", Database_query_hash, -1);
+  rb_define_method(cDatabase, "query_ary", Database_query_ary, -1);
+  rb_define_method(cDatabase, "query_single_column", Database_query_single_column, -1);
+  rb_define_method(cDatabase, "query_single_value", Database_query_single_value, -1);
+  
+  rb_define_method(cDatabase, "last_insert_rowid", Database_last_insert_rowid, 0);
+  rb_define_method(cDatabase, "changes", Database_changes, 0);
+  rb_define_method(cDatabase, "filename", Database_filename, -1);
+
+  cError = rb_define_class_under(mExtralite, "Error", rb_eRuntimeError);
+}