RubyGems - rq-ruby1.8 - Versions diffs - 3.4.3 → 3.4.5 - Mend

rq-ruby1.8 3.4.3 → 3.4.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

data/Gemfile CHANGED

@@ -1,22 +1,14 @@
 source "http://rubygems.org"
-# Add dependencies required to use your gem here.
-# Example:
-#   gem "activesupport", ">= 2.3.5"
 # Runtime dependencies
-# gem "bio", ">= 1.3.1"
-# gem "bio-logger", "> 0.8.0"
-# gem "nokogiri", ">= 1.4.4"
 gem "posixlock"
 gem "arrayfields"
 gem "lockfile"
-# gem "sqlite-1.3.1"  # on rubygems?
+# gem "sqlite-1.3.1"  # now included with rq-ruby1.8
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  # gem "rspec", "~> 2.3.0"
   gem "bundler", "~> 1.0.15"
   gem "jeweler", "~> 1.6.4"
-  # gem "rcov", ">= 0"
 end

data/INSTALL CHANGED

@@ -4,85 +4,66 @@ The current version of rq runs on ruby1.8. A gem is available on rubygems:
   https://rubygems.org/gems/rq-ruby1.8
-install with
+simply with
+  install sqlite2 (Debian apt-get install libsqlite0-dev)
+and
   gem1.8 install rq-ruby1.8
-which should include:
+The gem includes sqlite-1.3.1 for Ruby. And should include:
   - gem1.8 install posixlock
   - gem1.8 install arrayfields
   - gem1.8 install lockfile
-sqlite-1.3.1, however, is not on rubygems, so you may need to:
-  - install sqlite2 (Debian apt-get install libsqlite0-dev)
-  - wget http://rubyforge.org/frs/download.php/1070/sqlite-1.3.1.gem
-  - gem1.8 install sqlite-1.3.1.gem
-  - gem1.8 install rq-ruby1.8 (or run from source)
+  gems also available from http://bio4.dnsalias.net/download/gem/ruby1.8/
-  Also available from http://bio4.dnsalias.net/download/gem/ruby1.8/
+Find rq
-run with, for example
+  gem1.8 contents rq-ruby1.8|grep bin/rq$
+Maybe link it
-  ln -s /var/lib/gems/1.8/gems/rq-ruby1.8-3.4.3/bin/rq /usr/local/bin/rq
+  ln -sf `gem1.8 contents rq-ruby1.8|grep bin/rq$` /usr/local/bin/rq
   rq --help
 === Debian
 On Debian systems, the recommended procedure is to use Debian apt on all
-machines. For now, use the 3.4.3 install, as documented in the README!
+machines. For now, use the gem install, as documented in the README!
 This has been tested on Debian Squeeze (BioLinux Minimal):
-root@vagrant-debian-squeeze:/home/vagrant#  gem1.8 install rq-ruby1.8
-Building native extensions.  This could take a while...
-Successfully installed posixlock-0.0.1
-Successfully installed arrayfields-4.7.4
-Successfully installed lockfile-1.4.3
-Successfully installed rq-ruby1.8-3.4.3
-4 gems installed
-Installing ri documentation for posixlock-0.0.1...
-Installing ri documentation for arrayfields-4.7.4...
-Installing ri documentation for lockfile-1.4.3...
-Installing ri documentation for rq-ruby1.8-3.4.3...
-Installing RDoc documentation for posixlock-0.0.1...
-Installing RDoc documentation for arrayfields-4.7.4...
-Installing RDoc documentation for lockfile-1.4.3...
-Installing RDoc documentation for rq-ruby1.8-3.4.3...
-  ln -s /var/lib/gems/1.8/gems/rq-ruby1.8-3.4.3/bin/rq /usr/local/bin/rq
-apt-get install libsqlite0-dev
-  Setting up libsqlite0 (2.8.17-6) ...
-  Setting up libsqlite0-dev (2.8.17-6) ...
-wget http://rubyforge.org/frs/download.php/1070/sqlite-1.3.1.gem
-  Saving to: `sqlite-1.3.1.gem'
-  100%[======================================>] 41,278      --.-K/s   in 0.1s
-  2011-07-21 11:36:21 (347 KB/s) - `sqlite-1.3.1.gem' saved [41278/41278]
-root@vagrant-debian-squeeze:/home/vagrant# gem1.8 install sqlite-1.3.1.gem
-  Building native extensions.  This could take a while...
-  Successfully installed sqlite-1.3.1
-  1 gem installed
-  Installing ri documentation for sqlite-1.3.1...
-  Installing RDoc documentation for sqlite-1.3.1...
+        apt-get install libsqlite0-dev
+          Setting up libsqlite0 (2.8.17-6) ...
+          Setting up libsqlite0-dev (2.8.17-6) ...
+        gem1.8 install rq-ruby1.8
+          Building native extensions.  This could take a while...
+          Successfully installed posixlock-0.0.1
+          Successfully installed arrayfields-4.7.4
+          Successfully installed lockfile-1.4.3
+          Successfully installed rq-ruby1.8-3.4.4
+          4 gems installed
+          Installing ri documentation for posixlock-0.0.1...
+          Installing ri documentation for arrayfields-4.7.4...
+          Installing ri documentation for lockfile-1.4.3...
+          Installing ri documentation for rq-ruby1.8-3.4.4...
+          Installing RDoc documentation for posixlock-0.0.1...
+          Installing RDoc documentation for arrayfields-4.7.4...
+          Installing RDoc documentation for lockfile-1.4.3...
+          Installing RDoc documentation for rq-ruby1.8-3.4.4...
+      ln -sf `gem1.8 contents rq-ruby1.8|grep bin/rq$` /usr/local/bin/rq
 root@vagrant-debian-squeeze:/home/vagrant# rq --help
   NAME
-    rq v3.4.3
+    rq v3.4.4
-(the end!)
-(below will become available later)
-  * apt-get install rq-ruby1.8
-which resolves all dependencies, or alternatively
-  * Download the rq deb file from http://bio4.dnsalias.net/download/Debian/
-  * apt-get install libposixlock-ruby1.8 libsqlite3-ruby1.8 ruby1.8
-  * dpkg --force-architecture -i rq-ruby1.8-ver.deb
+(...)
 which works on on 32-bits and 64-bits systems. The commands
@@ -135,12 +116,6 @@ version >4.4
     install which all cluster nodes can use. The other install methods mean
     you will have to install rq on __each__ node you plan to use it on.
-=== RUBYGEMS
-(currently defunct, awaits updating rq to Ruby 1.9.x and sqlite3)
-  * gem install rq
 === STANDARD
 (in rq version <=3.4.0)
@@ -164,3 +139,23 @@ The current version of rq runs on ruby1.8, using bundler and jeweler:
   rake gemspec
   rake build  # creates gem in ./pkg
+== Trouble shooting
+=== rubyio.h error
+Building native extensions.  This could take a while...
+ERROR:  Error installing rq-ruby1.8-3.4.5.gem:
+        ERROR: Failed to build gem native extension.
+/usr/local/include/ruby-1.9.1/ruby/backward/rubyio.h:2:2: warning: #warning use "ruby/io.h" instead of "rubyio.h"
+Solution: you are trying to build against ruby1.9. Use gem1.8 instead. If you
+have problems mixing gems, take a look at 'rvm'.
+=== can not find rq, after successful install
+gem1.8 stores gems in dirs named /var/lib/gems/1.8/gems/rq-ruby1.8-3.4.5/. You
+may have to create a symbolic link, e.g.
+  ln -sf `gem1.8 contents rq-ruby1.8|grep bin/rq$` /usr/local/bin/rq

data/README CHANGED

@@ -1,41 +1,108 @@
 NAME
-  rq v3.4.3
+  rq v3.4.5
 SYNOPSIS
-  rq (queue | export RQ_Q=q) mode [mode_args]* [options]*
+  rq queue mode [mode_args]* [options]*
+  ruby queue (rq) is a zero-admin zero-configuration tool used to create
+  instant unix clusters on a multi-core machine, and/or multiple nodes in a
+  network, or in the Cloud. rq requires only a centrally mounted directory
+  (e.g. NFS) in order to manage a simple sqlite database as a distributed
+  priority work queue. See QUICK START below.
-URIS
-    https://github.com/pjotrp/rq - main website
-    http://www.linuxjournal.com/article/7922
+DESCRIPTION
-  and
-    http://rubyforge.org/projects/codeforpeople/
-    http://codeforpeople.com/lib/ruby/rq/
+  ruby queue (rq) is a zero-admin zero-configuration tool used to create
+  instant unix clusters. the simple design allows researchers with minimal unix
+  experience to install and configure, in only a few minutes and without root
+  privileges, a robust unix cluster capable of distributing processes to many
+  nodes - bringing dozens of powerful cpus to their knees with a single blow.
+  clearly this software should be kept out of the hands of free radicals, seti
+  enthusiasts, and one mr. j safran.
-LICENSE
+  the central concept of rq is that n nodes work in isolation to pull jobs
+  from an centrally mounted nfs priority work queue in a synchronized fashion.
+  the nodes have absolutely no knowledge of each other and all communication
+  is done via the queue meaning that, so long as the queue is available via
+  nfs and a single node is running jobs from it, the system will continue to
+  process jobs.  there is no centralized process whatsoever - all nodes work
+  to take jobs from the queue and run them as fast as possible.  this creates
+  a system which load balances automatically and is robust in face of node
+  failures.
-   rq is distributed under the BSD license, see the ./LICENSE file
+  although the rq system is simple in it's design it features powerful
+  functionality such as priority management, predicate and sql query, compact
+  streaming command-line processing, programmable api, hot-backup, and
+  input/capture of the stdin/stdout/stderr io streams of remote jobs. to date
+  rq has had no reported runtime failures and is in operation at
+  dozens of research centers around the world. while rq is written in
+  the Ruby programming language, there is no Ruby programming
+  involved in using rq.
+QUICK START
+  install rq using rubygems
+    gem1.8 install rq-ruby1.8
+    ln -sf `gem1.8 contents rq-ruby1.8|grep bin/rq$` /usr/local/bin/rq
+    rq --help
+  set up a directory for the queue - this can be a local, or an NFS/sshfs
+  mounted drive:
+    rq dir create
+  on every node create a queue runner, specifying the number of cores (here 8)
+    rq dir feed --daemon --log=rq.log --max_feed=8
+  submit two jobs - shell style
+    rq dir submit 'sleep 10'
+    rq dir submit 'sleep 9'
+  check status
+    rq dir status
+  shows
+        ---
+        jobs:
+          pending: 0
+          holding: 0
+          running: 2
+          finished: 0
+          dead: 0
+          total: 2
+        temporal:
+          running:
+            min: {2: 00h00m03.49s}
+            max: {1: 00h00m03.60s}
+        performance:
+          avg_time_per_job: 00h00m00.00s
+          n_jobs_in_last_hrs:
+            1: 0
+            12: 0
+            24: 0
+        exit_status:
+          successes: 0
+          failures: 0
+          ok: 0
+  Now, that was easy!!
 INSTALL
   See the ./INSTALL file, but quickly
-  gems (per node):
-    gem >=3.4.3:
+  gem >=3.4.5:
-      - install sqlite2 (Debian apt-get install libsqlite0-dev)
-      - wget http://rubyforge.org/frs/download.php/1070/sqlite-1.3.1.gem
-      - gem1.8 install sqlite-1.3.1.gem
-      - gem1.8 install posixlock
-      - gem1.8 install arrayfields
-      - gem1.8 install lockfile
-      - gem1.8 install rq-ruby1.8 (or run from source)
+    - install sqlite2 (Debian apt-get install libsqlite0-dev)
+    - gem1.8 install rq-ruby1.8
     Also available from http://bio4.dnsalias.net/download/gem/ruby1.8/
@@ -52,37 +119,6 @@ INSTALL
     see ./INSTALL file for latest
-DESCRIPTION
-  ruby queue (rq) is a zero-admin zero-configuration tool used to create instant
-  unix clusters.  rq requires only a central nfs filesystem in order to manage a
-  simple sqlite database as a distributed priority work queue.  this simple
-  design allows researchers with minimal unix experience to install and
-  configure, in only a few minutes and without root privileges, a robust unix
-  cluster capable of distributing processes to many nodes - bringing dozens of
-  powerful cpus to their knees with a single blow.  clearly this software should
-  be kept out of the hands of free radicals, seti enthusiasts, and one mr. j
-  safran.
-  the central concept of rq is that n nodes work in isolation to pull jobs
-  from an centrally mounted nfs priority work queue in a synchronized fashion.
-  the nodes have absolutely no knowledge of each other and all communication
-  is done via the queue meaning that, so long as the queue is available via
-  nfs and a single node is running jobs from it, the system will continue to
-  process jobs.  there is no centralized process whatsoever - all nodes work
-  to take jobs from the queue and run them as fast as possible.  this creates
-  a system which load balances automatically and is robust in face of node
-  failures.
-  although the rq system is simple in it's design it features powerful
-  functionality such as priority management, predicate and sql query, compact
-  streaming command-line processing, programmable api, hot-backup, and
-  input/capture of the stdin/stdout/stderr io streams of remote jobs. to date
-  rq has had no reported runtime failures and is in operation at
-  dozens of research centers around the world. while rq is written in
-  the Ruby programming language, there is no Ruby programming
-  involved in using rq.
 INVOCATION
   the first argument to any rq command is the always the name of the queue
@@ -1086,6 +1122,16 @@ DIAGNOSTICS
  success : $? == 0
  failure : $? != 0
+URIS
+    https://github.com/pjotrp/rq - main website
+    http://www.linuxjournal.com/article/7922
+    http://rubyforge.org/projects/codeforpeople/ (original)
+LICENSE
+   rq is distributed under the BSD license, see the ./LICENSE file
 CREDITS
   - kim baugh       : patient tester and design input
@@ -1098,7 +1144,7 @@ CREDITS
 INSTALL
-    gem install rq-ruby1.8 (see top of page)
+    gem1.8 install rq-ruby1.8 (see top of page)
 TEST

data/VERSION CHANGED

	@@ -1 +1 @@
1	- 3.4.3
1	+ 3.4.5

data/bin/rq CHANGED

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby1.8
-$: << '/var/lib/gems/1.8/gems/rq-ruby1.8-3.4.3/lib'  # locate gem1.8 install
+$: << '/var/lib/gems/1.8/gems/rq-ruby1.8-3.4.5/lib'  # locate gem1.8 install
 $: << '/usr/share/rq-ruby1.8/lib'
 #

data/ext/extconf.rb ADDED

@@ -0,0 +1,7 @@
+require 'mkmf'
+dir_config( "sqlite" )
+have_library( "sqlite" )
+if have_header( "sqlite.h" ) and have_library( "sqlite", "sqlite_open" )
+  create_makefile( "_sqlite" )
+end

data/ext/sqlite.c ADDED

@@ -0,0 +1,862 @@
+/* --------------------------------------------------------------------------
+ * sqlite.c -- glue code between for the SQLite database and Ruby.
+ * Copyright (C) 2003 Jamis Buck (jgb3@email.byu.edu)
+ * --------------------------------------------------------------------------
+ * The  SQLite/Ruby module  is  free software; you can redistribute it and/or
+ * modify  it  under the terms of the GNU General Public License as published
+ * by  the  Free  Software  Foundation;  either  version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * The SQLite/Ruby Interface is free software; you can redistribute it and/or
+ * modify  it  under the terms of the BSD License as published by  the  Free
+ * Software  Foundation. See also the rq LICENSE file.
+ *
+ * The license was changed for older sqlite-1.3.1 in agreement with Jamis Buck.
+ *
+ * The SQLite/Ruby Interface is distributed in the hope that it will be useful,
+ *  but   WITHOUT   ANY   WARRANTY;  without  even  the  implied  warranty  of
+ * MERCHANTABILITY  or  FITNESS  FOR  A  PARTICULAR  PURPOSE.
+ * --------------------------------------------------------------------------
+ * This file defines the glue code between the SQLite database engine and
+ * the Ruby interpreter.
+ *
+ * Author: Jamis Buck (jgb3@email.byu.edu)
+ * Date: June 2003
+ * --------------------------------------------------------------------------
+ * NOTE: rq still users the older sqlite2 engine and bindings. This will
+ * change.
+ */
+#include <sqlite.h>
+#include <stdio.h>
+#include "ruby.h"
+#include "stdarg.h"
+/* these constants defines the current version of the SQLite/Ruby module */
+#define LIB_VERSION_MAJOR  1
+#define LIB_VERSION_MINOR  3
+#define LIB_VERSION_TINY   1
+/* this wraps the sqlite db pointer.  We need to do it this way so that we
+ * can keep the object alive even after we've closed the DB handle, and we
+ * need to be able to tell the difference between an open and a closed DB
+ * handle.  This way, if the 'db' member is NULL, we know the database is
+ * not open. */
+typedef struct
+{
+  sqlite *db;
+  int     use_array;
+} SQLITE_RUBY_DATA;
+/* This represents the information for a callback during query execution. */
+typedef struct
+{
+  VALUE callback;         /* the Method object to invoke for each row */
+  VALUE arg;              /* the application-defined cookie value to pass to the method */
+  VALUE columns;          /* a ruby array of all of the column names */
+  VALUE types;            /* a ruby hash of all of the column types (may be null) */
+  int   built_columns;    /* whether or not the 'columns' member is valid yet */
+  int   do_translate;     /* whether or not to do type translation */
+  SQLITE_RUBY_DATA *self; /* a reference to the database instance being queried */
+} SQLITE_RUBY_CALLBACK;
+/* This represents the information for a callback on a custom SQL function */
+typedef struct
+{
+  VALUE callback;        /* the Method object to invoke for each function invocation */
+  VALUE finalize;        /* the Method object to invoke when an aggregate function is finished */
+  VALUE arg;             /* the app-defined cookie value */
+} SQLITE_CUSTOM_FUNCTION_CB;
+/* global variables for defining the classes, modules, and symbols that are used by this
+ * module. */
+static VALUE mSQLite;
+static VALUE cSQLite;
+static VALUE cSQLiteTypeTranslator;
+static VALUE cSQLiteException;
+static VALUE cSQLiteQueryContext;
+static VALUE oSQLiteQueryAbort;
+static ID    idCallMethod;
+static ID    idInstanceEvalMethod;
+static ID    idTranslate;
+static ID    idFields;
+static ID    idFieldsEqual;
+static struct {
+  char *name;
+  VALUE object;
+} g_sqlite_exceptions[] = {
+  { "OK", 0 },
+  { "SQL", 0 },
+  { "Internal", 0 },
+  { "Permissions", 0 },
+  { "Abort", 0 },
+  { "Busy", 0 },
+  { "Locked", 0 },
+  { "OutOfMemory", 0 },
+  { "ReadOnly", 0 },
+  { "Interrupt", 0 },
+  { "IOError", 0 },
+  { "Corrupt", 0 },
+  { "NotFound", 0 },
+  { "Full", 0 },
+  { "CantOpen", 0 },
+  { "Protocol", 0 },
+  { "Empty", 0 },
+  { "SchemaChanged", 0 },
+  { "TooBig", 0 },
+  { "Constraint", 0 },
+  { "Mismatch", 0 },
+  { "Misuse", 0 },
+  { "UnsupportedOSFeature", 0 },
+  { "Authorization", 0 },
+  { NULL, 0 }
+};
+/* free's the given database handle when the Ruby engine garbage collects it. */
+static void static_free_database_handle( SQLITE_RUBY_DATA *hdb );
+/* called when a query is processing another row */
+static int static_ruby_sqlite_callback( void *pArg, int argc, char **argv, char **columns );
+/* called when a custom SQL function is invoked */
+static void static_custom_function_callback( sqlite_func* ctx, int argc, const char **argv );
+/* called when a custom aggregate SQL function is invoked */
+static void static_custom_aggregate_callback( sqlite_func* ctx, int argc, const char **argv );
+/* called when the custom aggregate SQL finalize function is invoked */
+static void static_custom_finalize_callback( sqlite_func* ctx );
+/* determines whether the given pragma is enabled or not */
+static int static_pragma_enabled( sqlite* db, const char *pragma );
+/* configure the various exception subclasses used by the module */
+static void static_configure_exception_classes();
+/* raise an exception */
+static void static_raise_db_error( int code, char *msg, ... );
+static VALUE static_database_new( VALUE klass,
+                                  VALUE dbname,
+                                  VALUE mode );
+static VALUE static_database_close( VALUE self );
+static VALUE static_database_exec( VALUE self,
+                                   VALUE sql,
+                                   VALUE callback,
+                                   VALUE parm );
+static VALUE static_last_insert_rowid( VALUE self );
+static VALUE static_changes( VALUE self );
+static VALUE static_interrupt( VALUE self );
+static VALUE static_complete( VALUE self,
+                              VALUE sql );
+static VALUE static_create_function( VALUE self,
+                                     VALUE name,
+                                     VALUE argc,
+                                     VALUE callback,
+                                     VALUE parm );
+static VALUE static_create_aggregate( VALUE self,
+                                      VALUE name,
+                                      VALUE argc,
+                                      VALUE step,
+                                      VALUE finalize,
+                                      VALUE parm );
+static VALUE static_aggregate_count( VALUE self );
+static VALUE static_get_properties( VALUE self );
+static VALUE static_is_doing_type_translation( VALUE self );
+static VALUE static_set_type_translation( VALUE self, VALUE value );
+static void static_free_database_handle( SQLITE_RUBY_DATA *hdb )
+{
+  if( hdb )
+  {
+    if( hdb->db )
+    {
+      sqlite_close( hdb->db );
+      hdb->db = NULL;
+    }
+    free( hdb );
+  }
+}
+static int static_ruby_sqlite_callback( void *pArg, int argc, char **argv, char **columns )
+{
+  SQLITE_RUBY_CALLBACK *hook = (SQLITE_RUBY_CALLBACK*)pArg;
+  VALUE result;
+  int i;
+  VALUE rc;
+  if( hook->self->use_array )
+  {
+    result = rb_ary_new();
+  }
+  else
+  {
+    result = rb_hash_new();
+  }
+  if( !hook->built_columns )
+  {
+    hook->columns = rb_ary_new2( argc );
+  }
+  for( i = 0; i < argc; i++ )
+  {
+    VALUE val;
+    if( !hook->built_columns )
+    {
+      rb_ary_push( hook->columns, rb_str_new2( columns[i] ) );
+      if( hook->types != Qnil )
+      {
+        VALUE type;
+        char *type_name = columns[ i + argc ];
+        type = rb_str_new2( type_name == NULL ? "STRING" : type_name );
+        rb_hash_aset( hook->types, rb_ary_entry( hook->columns, i ), type );
+        rb_hash_aset( hook->types, INT2FIX(i), type );
+      }
+    }
+    if( argv != NULL )
+    {
+      val = ( argv[i] ? rb_str_new2( argv[i] ) : Qnil );
+      if( hook->do_translate )
+      {
+        VALUE type = rb_hash_aref( hook->types, INT2FIX(i) );
+        val = rb_funcall( cSQLiteTypeTranslator, idTranslate, 2, type, val );
+      }
+      if( hook->self->use_array )
+      {
+        rb_ary_store( result, i, val );
+      }
+      else
+      {
+        rb_hash_aset( result, rb_ary_entry( hook->columns, i ), val );
+        rb_hash_aset( result, INT2FIX(i), val );
+      }
+    }
+  }
+  if( hook->self->use_array )
+  {
+    if( rb_respond_to( result, idFieldsEqual ) )
+    {
+      rb_funcall( result, idFieldsEqual, 1, hook->columns );
+    }
+    else
+    {
+      rb_iv_set( result, "@fields", hook->columns );
+      if( !rb_respond_to( result, idFields ) )
+        rb_funcall( result, idInstanceEvalMethod, 1, rb_str_new2( "def fields;@fields;end" ) );
+    }
+  }
+  hook->built_columns = 1;
+  rb_iv_set( result, "@argument", hook->arg );
+  rb_funcall( result, idInstanceEvalMethod, 1, rb_str_new2( "def argument;@argument;end" ) );
+  if( hook->types != Qnil )
+  {
+    rb_iv_set( result, "@column_types", hook->types );
+    rb_funcall( result, idInstanceEvalMethod, 1, rb_str_new2( "def column_types;@column_types;end" ) );
+  }
+  rc = rb_funcall( hook->callback, idCallMethod, 1, result );
+  return ( rc == oSQLiteQueryAbort ? 1 : 0 );
+}
+static void static_custom_function_callback( sqlite_func* ctx, int argc, const char **argv )
+{
+  SQLITE_CUSTOM_FUNCTION_CB *data;
+  VALUE rc;
+  VALUE args;
+  int i;
+  data = (SQLITE_CUSTOM_FUNCTION_CB*)sqlite_user_data( ctx );
+  args = rb_ary_new2( argc );
+  rb_ary_push( args, Data_Wrap_Struct( cSQLiteQueryContext, 0, 0, ctx ) );
+  for( i = 0; i < argc; i++ )
+  {
+    if( argv[i] )
+      rb_ary_push( args, rb_str_new2( argv[i] ) );
+    else
+      rb_ary_push( args, Qnil );
+  }
+  rc = rb_apply( data->callback, idCallMethod, args );
+  switch( TYPE(rc) )
+  {
+    case T_STRING:
+      sqlite_set_result_string( ctx, STR2CSTR(rc), RSTRING(rc)->len );
+      break;
+    case T_FIXNUM:
+      sqlite_set_result_int( ctx, FIX2INT(rc) );
+      break;
+    case T_FLOAT:
+      sqlite_set_result_double( ctx, NUM2DBL(rc) );
+      break;
+  }
+}
+static void static_custom_aggregate_callback( sqlite_func* ctx, int argc, const char **argv )
+{
+  SQLITE_CUSTOM_FUNCTION_CB *data;
+  VALUE args;
+  VALUE *hash;
+  int i;
+  hash = (VALUE*)sqlite_aggregate_context( ctx, sizeof( VALUE ) );
+  if( *hash == 0 ) *hash = rb_hash_new();
+  data = (SQLITE_CUSTOM_FUNCTION_CB*)sqlite_user_data( ctx );
+  args = rb_ary_new2( argc );
+  rb_ary_push( args, Data_Wrap_Struct( cSQLiteQueryContext, 0, 0, ctx ) );
+  for( i = 0; i < argc; i++ )
+  {
+    if( argv[i] )
+      rb_ary_push( args, rb_str_new2( argv[i] ) );
+    else
+      rb_ary_push( args, Qnil );
+  }
+  rb_apply( data->callback, idCallMethod, args );
+}
+static void static_custom_finalize_callback( sqlite_func* ctx )
+{
+  SQLITE_CUSTOM_FUNCTION_CB *data;
+  VALUE rc;
+  int i;
+  data = (SQLITE_CUSTOM_FUNCTION_CB*)sqlite_user_data( ctx );
+  rc = rb_funcall( data->finalize, idCallMethod, 1, Data_Wrap_Struct( cSQLiteQueryContext, 0, 0, ctx ) );
+  switch( TYPE(rc) )
+  {
+    case T_STRING:
+      sqlite_set_result_string( ctx, STR2CSTR(rc), RSTRING(rc)->len );
+      break;
+    case T_FIXNUM:
+      sqlite_set_result_int( ctx, FIX2INT(rc) );
+      break;
+    case T_FLOAT:
+      sqlite_set_result_double( ctx, NUM2DBL(rc) );
+      break;
+  }
+}
+static int static_pragma_enabled_callback( void *arg, int argc, char **argv, char **columnNames )
+{
+  int *result = (int*)arg;
+  if( ( strcmp( argv[0], "ON" ) == 0 ) || ( strcmp( argv[0], "1" ) == 0 ) )
+  {
+    *result = 1;
+  }
+  else
+  {
+    *result = 0;
+  }
+  return SQLITE_OK;
+}
+static int static_pragma_enabled( sqlite* db, const char *pragma )
+{
+  int result;
+  int return_code;
+  char sql[ 256 ];
+  char *msg;
+  sprintf( sql, "PRAGMA %s", pragma );
+  return_code = sqlite_exec( db, sql, static_pragma_enabled_callback, &result, &msg );
+  if( return_code != SQLITE_OK )
+  {
+    VALUE err = rb_str_new2( msg );
+    free( msg );
+    static_raise_db_error( return_code,
+                           "could not determine status of pragma '%s' (%s)",
+                           pragma, STR2CSTR(err) );
+  }
+  return result;
+}
+/**
+ * Opens a SQLite database. If the database does not exist, it will be
+ * created. The mode parameter is currently unused and should be set to 0.
+ */
+static VALUE static_database_new( VALUE klass,
+                                  VALUE dbname,
+                                  VALUE mode )
+{
+  SQLITE_RUBY_DATA *hdb;
+  sqlite *db;
+  char   *s_dbname;
+  int     i_mode;
+  char   *errmsg;
+  VALUE   v_db;
+  Check_Type( dbname, T_STRING );
+  Check_Type( mode,   T_FIXNUM );
+  s_dbname = STR2CSTR(dbname);
+  i_mode   = FIX2INT(mode);
+  db = sqlite_open( s_dbname, i_mode, &errmsg );
+  if( db == NULL )
+  {
+    VALUE err = rb_str_new2( errmsg );
+    free( errmsg );
+    static_raise_db_error( -1, "%s", STR2CSTR( err ) );
+  }
+  hdb = ALLOC( SQLITE_RUBY_DATA );
+  hdb->db = db;
+  hdb->use_array = 0; /* default to FALSE */
+  v_db = Data_Wrap_Struct( klass, NULL, static_free_database_handle, hdb );
+  static_set_type_translation( v_db, Qfalse );
+  return v_db;
+}
+/**
+ * Closes an open database. No further methods should be invoked on the database
+ * after closing it.
+ */
+static VALUE static_database_close( VALUE self )
+{
+  SQLITE_RUBY_DATA *hdb;
+  Data_Get_Struct( self, SQLITE_RUBY_DATA, hdb );
+  if( hdb->db != NULL )
+  {
+    sqlite_close( hdb->db );
+    hdb->db = NULL;
+  }
+  return Qnil;
+}
+/**
+ * This is the base method used for querying the database. You will rarely use this method
+ * directly; rather, you should use the #execute method, instead. The +sql+ parameter is
+ * the text of the sql to execute, +callback+ is a proc object to be invoked for each row
+ * of the result set, and +parm+ is an application-specific cookie value that will be passed to
+ * the +callback+.
+ */
+static VALUE static_database_exec( VALUE self,
+                                   VALUE sql,
+                                   VALUE callback,
+                                   VALUE parm )
+{
+  SQLITE_RUBY_DATA *hdb;
+  SQLITE_RUBY_CALLBACK hook;
+  char *s_sql;
+  int i;
+  char *err = NULL;
+  VALUE v_err;
+  Check_Type( sql, T_STRING );
+  s_sql = STR2CSTR(sql);
+  Data_Get_Struct( self, SQLITE_RUBY_DATA, hdb );
+  if( hdb->db == NULL )
+    static_raise_db_error( -1, "attempt to access a closed database" );
+  hook.callback = callback;
+  hook.arg = parm;
+  hook.built_columns = 0;
+  hook.columns = Qnil;
+  hook.self = hdb;
+  hook.do_translate = ( rb_iv_get( self, "@type_translation" ) == Qtrue );
+  if( static_pragma_enabled( hdb->db, "show_datatypes" ) )
+  {
+    hook.types = rb_hash_new();
+  }
+  else
+  {
+    hook.types = Qnil;
+    hook.do_translate = 0; /* show_datatypes must be anbled for type translation */
+  }
+  i = sqlite_exec( hdb->db,
+                   s_sql,
+                   static_ruby_sqlite_callback,
+                   &hook,
+                   &err );
+  if( err != 0 )
+  {
+    v_err = rb_str_new2( err );
+    free( err );
+  }
+  switch( i )
+  {
+    case SQLITE_OK:
+    case SQLITE_ABORT:
+      break;
+    default:
+      static_raise_db_error( i, "%s", STR2CSTR(v_err) );
+  }
+  return INT2FIX(0);
+}
+/**
+ * Returns the key value of the last inserted row.
+ */
+static VALUE static_last_insert_rowid( VALUE self )
+{
+  SQLITE_RUBY_DATA *hdb;
+  Data_Get_Struct( self, SQLITE_RUBY_DATA, hdb );
+  if( hdb->db == NULL )
+    static_raise_db_error( -1, "attempt to access a closed database" );
+  return INT2FIX( sqlite_last_insert_rowid( hdb->db ) );
+}
+/**
+ * Returns the number of rows that were affected by the last query.
+ */
+static VALUE static_changes( VALUE self )
+{
+  SQLITE_RUBY_DATA *hdb;
+  Data_Get_Struct( self, SQLITE_RUBY_DATA, hdb );
+  if( hdb->db == NULL )
+    static_raise_db_error( -1, "attempt to access a closed database" );
+  return INT2FIX( sqlite_changes( hdb->db ) );
+}
+/**
+ * Interrupts the currently executing query, causing it to abort. If there
+ * is no current query, this does nothing.
+ */
+static VALUE static_interrupt( VALUE self )
+{
+  SQLITE_RUBY_DATA *hdb;
+  Data_Get_Struct( self, SQLITE_RUBY_DATA, hdb );
+  if( hdb->db == NULL )
+    static_raise_db_error( -1, "attempt to access a closed database" );
+  sqlite_interrupt( hdb->db );
+  return Qnil;
+}
+/**
+ * Queries whether or not the given SQL statement is complete or not.
+ * This is primarly useful in interactive environments where you are
+ * prompting the user for a query, line-by-line.
+ */
+static VALUE static_complete( VALUE self,
+                              VALUE sql )
+{
+  Check_Type( sql, T_STRING );
+  return ( sqlite_complete( STR2CSTR( sql ) ) ? Qtrue : Qfalse );
+}
+/**
+ * Causes the database instance to use an array to represent rows
+ * in query results, if 'boolean' is not Qnil or Qfalse.
+ */
+static VALUE static_set_use_array( VALUE self, VALUE boolean )
+{
+  int use_array = RTEST( boolean );
+  SQLITE_RUBY_DATA *hdb;
+  Data_Get_Struct( self, SQLITE_RUBY_DATA, hdb );
+  hdb->use_array = use_array;
+  return boolean;
+}
+/**
+ * Queries the database instance to determine whether or not arrays
+ * are being used to represent rows in query results.
+ */
+static VALUE static_is_use_array( VALUE self )
+{
+  SQLITE_RUBY_DATA *hdb;
+  Data_Get_Struct( self, SQLITE_RUBY_DATA, hdb );
+  return ( hdb->use_array ? Qtrue : Qfalse );
+}
+/**
+ * Defines a custom SQL function with the given name and expected parameter count.
+ * The +callback+ must be a proc object, which will be invoked for each row of the
+ * result set. The +parm+ will be passed to the callback as well.
+ */
+static VALUE static_create_function( VALUE self,
+                                     VALUE name,
+                                     VALUE argc,
+                                     VALUE callback,
+                                     VALUE parm )
+{
+  SQLITE_RUBY_DATA *hdb;
+  SQLITE_CUSTOM_FUNCTION_CB *data;
+  char *s_name;
+  int   i_argc;
+  int   rc;
+  Data_Get_Struct( self, SQLITE_RUBY_DATA, hdb );
+  s_name = STR2CSTR( name );
+  i_argc = FIX2INT( argc );
+  if( hdb->db == NULL )
+    static_raise_db_error( -1, "attempt to access a closed database" );
+  data = ALLOC( SQLITE_CUSTOM_FUNCTION_CB );
+  data->callback = callback;
+  data->arg = parm;
+  rc = sqlite_create_function( hdb->db,
+                               s_name,
+                               i_argc,
+                               static_custom_function_callback,
+                               data );
+  if( rc != 0 )
+    static_raise_db_error( rc, "error registering custom function" );
+  return Qnil;
+}
+/**
+ * Defines a custom aggregate SQL function with the given name and argument count
+ * (+argc+). The +step+ parameter must be a proc object, which will be called for
+ * each iteration during the processing of the aggregate. The +finalize+ parameter
+ * must also be a proc object, and is called at the end of the processing of the
+ * aggreate. The +parm+ parameter will be passed to both callbacks.
+ */
+static VALUE static_create_aggregate( VALUE self,
+                                      VALUE name,
+                                      VALUE argc,
+                                      VALUE step,
+                                      VALUE finalize,
+                                      VALUE parm )
+{
+  SQLITE_RUBY_DATA *hdb;
+  SQLITE_CUSTOM_FUNCTION_CB *data;
+  char *s_name;
+  int   i_argc;
+  int   rc;
+  Data_Get_Struct( self, SQLITE_RUBY_DATA, hdb );
+  s_name = STR2CSTR( name );
+  i_argc = FIX2INT( argc );
+  if( hdb->db == NULL )
+    static_raise_db_error( -1, "attempt to access a closed database" );
+  data = ALLOC( SQLITE_CUSTOM_FUNCTION_CB );
+  data->callback = step;
+  data->finalize = finalize;
+  data->arg = parm;
+  rc = sqlite_create_aggregate( hdb->db,
+                                s_name,
+                                i_argc,
+                                static_custom_aggregate_callback,
+                                static_custom_finalize_callback,
+                                data );
+  if( rc != 0 )
+    static_raise_db_error( rc, "error registering custom function" );
+  return Qnil;
+}
+/**
+ * Returns the number of rows in the aggregate context.
+ */
+static VALUE static_aggregate_count( VALUE self )
+{
+  sqlite_func *ctx;
+  Data_Get_Struct( self, sqlite_func, ctx );
+  return INT2FIX( sqlite_aggregate_count( ctx ) );
+}
+/**
+ * Returns the properties attribute of the aggregate context. This will always
+ * be a Hash object, which your custom functions may use to accumulate information
+ * into.
+ */
+static VALUE static_get_properties( VALUE self )
+{
+  sqlite_func *ctx;
+  Data_Get_Struct( self, sqlite_func, ctx );
+  return *(VALUE*)sqlite_aggregate_context( ctx, sizeof( VALUE ) );
+}
+/**
+ * Query whether or not the database is doing automatic type translation between
+ * the SQLite type (always a string) and the corresponding Ruby type.
+ */
+static VALUE static_is_doing_type_translation( VALUE self )
+{
+  return rb_iv_get( self, "@type_translation" );
+}
+/**
+ * Specify whether or not the database should do automatic type translation.
+ */
+static VALUE static_set_type_translation( VALUE self, VALUE value )
+{
+  if( value == Qnil || value == Qfalse )
+  {
+    value = Qfalse;
+  }
+  else
+  {
+    value = Qtrue;
+  }
+  return rb_iv_set( self, "@type_translation", value );
+}
+static void static_configure_exception_classes()
+{
+  int i;
+  for( i = 1; g_sqlite_exceptions[ i ].name != NULL; i++ )
+  {
+    char name[ 128 ];
+    sprintf( name, "%sException", g_sqlite_exceptions[ i ].name );
+    g_sqlite_exceptions[ i ].object = rb_define_class_under( mSQLite, name, cSQLiteException );
+  }
+}
+static void static_raise_db_error( int code, char *msg, ... )
+{
+  va_list args;
+  char message[ 2048 ];
+  VALUE exc;
+  va_start( args, msg );
+  vsnprintf( message, sizeof( message ), msg, args );
+  va_end( args );
+  exc = ( code <= 0 ? cSQLiteException : g_sqlite_exceptions[ code ].object );
+  rb_raise( exc, message );
+}
+void Init__sqlite()
+{
+  VALUE version;
+  mSQLite = rb_define_module( "SQLite" );
+  idCallMethod  = rb_intern( "call" );
+  idInstanceEvalMethod = rb_intern("instance_eval");
+  idTranslate = rb_intern("translate");
+  idFields = rb_intern("fields");
+  idFieldsEqual = rb_intern("fields=");
+  cSQLite = rb_define_class_under( mSQLite, "Database", rb_cObject );
+  cSQLiteException = rb_define_class_under( mSQLite, "DatabaseException", rb_eStandardError );
+  cSQLiteQueryContext = rb_define_class_under( mSQLite, "QueryContext", rb_cHash );
+  cSQLiteTypeTranslator = rb_define_class_under( mSQLite, "TypeTranslator", rb_cObject );
+  static_configure_exception_classes();
+  rb_define_singleton_method( cSQLite, "new", static_database_new, 2 );
+  rb_define_method( cSQLite, "close", static_database_close, 0 );
+  rb_define_method( cSQLite, "exec", static_database_exec, 3 );
+  rb_define_method( cSQLite, "last_insert_rowid", static_last_insert_rowid, 0 );
+  rb_define_method( cSQLite, "changes", static_changes, 0 );
+  rb_define_method( cSQLite, "interrupt", static_interrupt, 0 );
+  rb_define_method( cSQLite, "complete?", static_complete, 1 );
+  rb_define_method( cSQLite, "create_function", static_create_function, 4 );
+  rb_define_method( cSQLite, "create_aggregate", static_create_aggregate, 5 );
+  rb_define_method( cSQLite, "type_translation?", static_is_doing_type_translation, 0 );
+  rb_define_method( cSQLite, "type_translation=", static_set_type_translation, 1 );
+  rb_define_method( cSQLite, "use_array=", static_set_use_array, 1 );
+  rb_define_method( cSQLite, "use_array?", static_is_use_array, 0 );
+  rb_define_const( cSQLite, "VERSION", rb_str_new2( sqlite_libversion() ) );
+  rb_define_const( cSQLite, "ENCODING", rb_str_new2( sqlite_libencoding() ) );
+  version = rb_ary_new();
+  rb_ary_push( version, INT2FIX( LIB_VERSION_MAJOR ) );
+  rb_ary_push( version, INT2FIX( LIB_VERSION_MINOR ) );
+  rb_ary_push( version, INT2FIX( LIB_VERSION_TINY ) );
+  rb_define_const( mSQLite, "LIB_VERSION", version );
+  oSQLiteQueryAbort = rb_funcall( rb_cObject, rb_intern( "new" ), 0 );
+  rb_define_const( mSQLite, "ABORT", oSQLiteQueryAbort );
+  rb_define_method( cSQLiteQueryContext, "aggregate_count", static_aggregate_count, 0 );
+  rb_define_method( cSQLiteQueryContext, "properties", static_get_properties, 0 );
+}