amalgalite 1.1.2-x86-mswin32 → 1.3.0-x86-mswin32

data/ext/amalgalite/{sqlite3ext.h → c/sqlite3ext.h}

@@ -49,8 +49,10 @@ struct sqlite3_api_routines {
   int  (*busy_timeout)(sqlite3*,int ms);
   int  (*changes)(sqlite3*);
   int  (*close)(sqlite3*);
-  int  (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const char*));
-  int  (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const void*));
+  int  (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,
+                           int eTextRep,const char*));
+  int  (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,
+                             int eTextRep,const void*));
   const void * (*column_blob)(sqlite3_stmt*,int iCol);
   int  (*column_bytes)(sqlite3_stmt*,int iCol);
   int  (*column_bytes16)(sqlite3_stmt*,int iCol);
@@ -75,10 +77,18 @@ struct sqlite3_api_routines {
   void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
   int  (*complete)(const char*sql);
   int  (*complete16)(const void*sql);
-  int  (*create_collation)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*));
-  int  (*create_collation16)(sqlite3*,const void*,int,void*,int(*)(void*,int,const void*,int,const void*));
-  int  (*create_function)(sqlite3*,const char*,int,int,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*));
-  int  (*create_function16)(sqlite3*,const void*,int,int,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*));
+  int  (*create_collation)(sqlite3*,const char*,int,void*,
+                           int(*)(void*,int,const void*,int,const void*));
+  int  (*create_collation16)(sqlite3*,const void*,int,void*,
+                             int(*)(void*,int,const void*,int,const void*));
+  int  (*create_function)(sqlite3*,const char*,int,int,void*,
+                          void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+                          void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+                          void (*xFinal)(sqlite3_context*));
+  int  (*create_function16)(sqlite3*,const void*,int,int,void*,
+                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xFinal)(sqlite3_context*));
   int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
   int  (*data_count)(sqlite3_stmt*pStmt);
   sqlite3 * (*db_handle)(sqlite3_stmt*);
@@ -123,16 +133,19 @@ struct sqlite3_api_routines {
   void  (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
   void  (*result_value)(sqlite3_context*,sqlite3_value*);
   void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
-  int  (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,const char*,const char*),void*);
+  int  (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,
+                         const char*,const char*),void*);
   void  (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
   char * (*snprintf)(int,char*,const char*,...);
   int  (*step)(sqlite3_stmt*);
-  int  (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,char const**,char const**,int*,int*,int*);
+  int  (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,
+                                char const**,char const**,int*,int*,int*);
   void  (*thread_cleanup)(void);
   int  (*total_changes)(sqlite3*);
   void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
   int  (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*);
-  void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,sqlite_int64),void*);
+  void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,
+                                         sqlite_int64),void*);
   void * (*user_data)(sqlite3_context*);
   const void * (*value_blob)(sqlite3_value*);
   int  (*value_bytes)(sqlite3_value*);
@@ -154,15 +167,19 @@ struct sqlite3_api_routines {
   int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
   int (*clear_bindings)(sqlite3_stmt*);
   /* Added by 3.4.1 */
-  int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,void (*xDestroy)(void *));
+  int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,
+                          void (*xDestroy)(void *));
   /* Added by 3.5.0 */
   int (*bind_zeroblob)(sqlite3_stmt*,int,int);
   int (*blob_bytes)(sqlite3_blob*);
   int (*blob_close)(sqlite3_blob*);
-  int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,int,sqlite3_blob**);
+  int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,
+                   int,sqlite3_blob**);
   int (*blob_read)(sqlite3_blob*,void*,int,int);
   int (*blob_write)(sqlite3_blob*,const void*,int,int);
-  int (*create_collation_v2)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*),void(*)(void*));
+  int (*create_collation_v2)(sqlite3*,const char*,int,void*,
+                             int(*)(void*,int,const void*,int,const void*),
+                             void(*)(void*));
   int (*file_control)(sqlite3*,const char*,int,void*);
   sqlite3_int64 (*memory_highwater)(int);
   sqlite3_int64 (*memory_used)(void);
@@ -198,7 +215,11 @@ struct sqlite3_api_routines {
   int (*backup_step)(sqlite3_backup*,int);
   const char *(*compileoption_get)(int);
   int (*compileoption_used)(const char*);
-  int (*create_function_v2)(sqlite3*,const char*,int,int,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*),void(*xDestroy)(void*));
+  int (*create_function_v2)(sqlite3*,const char*,int,int,void*,
+                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+                            void (*xFinal)(sqlite3_context*),
+                            void(*xDestroy)(void*));
   int (*db_config)(sqlite3*,int,...);
   sqlite3_mutex *(*db_mutex)(sqlite3*);
   int (*db_status)(sqlite3*,int,int*,int*,int);
@@ -212,6 +233,9 @@ struct sqlite3_api_routines {
   int (*wal_autocheckpoint)(sqlite3*,int);
   int (*wal_checkpoint)(sqlite3*,const char*);
   void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*);
+  int (*blob_reopen)(sqlite3_blob*,sqlite3_int64);
+  int (*vtab_config)(sqlite3*,int op,...);
+  int (*vtab_on_conflict)(sqlite3*);
 };
 
 /*
@@ -412,6 +436,9 @@ struct sqlite3_api_routines {
 #define sqlite3_wal_autocheckpoint     sqlite3_api->wal_autocheckpoint
 #define sqlite3_wal_checkpoint         sqlite3_api->wal_checkpoint
 #define sqlite3_wal_hook               sqlite3_api->wal_hook
+#define sqlite3_blob_reopen            sqlite3_api->blob_reopen
+#define sqlite3_vtab_config            sqlite3_api->vtab_config
+#define sqlite3_vtab_on_conflict       sqlite3_api->vtab_on_conflict
 #endif /* SQLITE_CORE */
 
 #define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api = 0;

data/lib/amalgalite.rb

@@ -5,8 +5,8 @@
 
 # check if sqlite3 has already been required.  Amalgalite conflicts with system
 # level sqlite3 libraries.
-unless $LOADED_FEATURES.grep( /sqlite3/ ).empty? then
-  raise LoadError, "amalgalite conflicts with sqlite3-ruby, please choose one or the other."
+unless $LOADED_FEATURES.grep( /\Asqlite3/ ).empty? then
+  raise LoadError, "amalgalite conflicts with sqlite3, please choose one or the other."
 end
 
 module Amalgalite
@@ -16,10 +16,17 @@ module Amalgalite
   class Error < ::StandardError; end
 end
 
-# use a version subdirectory for extensions, initially to support windows, but
-# why make a special case, it doesn't hurt anyone to have an extra subdir
-# someplace 
-require "amalgalite/#{RUBY_VERSION.sub(/\.\d$/,'')}/amalgalite3"
+# Load the binary extension, try loading one for the specific version of ruby
+# and if that fails, then fall back to one in the top of the library.
+# this is the method recommended by rake-compiler
+begin
+  # this will be for windows
+  require "amalgalite/#{RUBY_VERSION.sub(/\.\d$/,'')}/amalgalite"
+rescue LoadError
+  # everyone else.
+  require 'amalgalite/amalgalite'
+end
+
 
 require 'amalgalite/aggregate'
 require 'amalgalite/blob'

data/lib/amalgalite/column.rb

@@ -16,15 +16,17 @@ module Amalgalite
     # the schema object this column is associated with
     attr_accessor :schema
 
-    # the database name this column belongs to
+    # the database name this column belongs to. This will be 'main' for the main
+    # database, 'temp' for the temp database and whatever an attached database
+    # was attached as.
     attr_accessor :db
 
-    # the column name
-    attr_accessor :name
-
     # the table to which this column belongs
     attr_accessor :table
 
+    # the column name
+    attr_accessor :name
+
     # the default value of the column.   This may not have a value and that
     # either means that there is no default value, or one could not be
     # determined.
@@ -47,8 +49,8 @@ module Amalgalite
     #
     def initialize( db, table, name, order)
       @db                 = db
-      @name               = name
       @table              = table
+      @name               = name
       @order              = Float(order).to_i
       @declared_data_type = nil
       @default_value      = nil

data/lib/amalgalite/database.rb

@@ -326,6 +326,14 @@ module Amalgalite
       return count
     end
 
+    ## 
+    # Execute a batch of statements via sqlite3_exec. This does the same as
+    # execute_batch, but doesn't update the statement statistics.
+    #
+    def import(sql)
+      @api.execute_batch(sql)
+    end
+
     ##
     # clear all the current taps
     #
@@ -486,11 +494,11 @@ module Amalgalite
     ##
     # :call-seq:
     #   db.schema( dbname = "main" ) -> Schema
-    # 
-    # Returns a Schema object  containing the table and column structure of the
+    #
+    # Returns a Schema object containing the table and column structure of the
     # database.
     #
-    def schema( dbname = "main" ) 
+    def schema( dbname = "main" )
       @schema ||= ::Amalgalite::Schema.new( self, dbname )
       if @schema and @schema.dirty?
         reload_schema!( dbname )
@@ -512,7 +520,7 @@ module Amalgalite
 
     ##
     # Run a pragma command against the database
-    # 
+    #
     # Returns the result set of the pragma
     def pragma( cmd, &block )
       execute("PRAGMA #{cmd}", &block)
@@ -741,9 +749,9 @@ module Amalgalite
         to_remove = possibles
       end
 
-      to_remove.each do |db_function|
-        @api.remove_function( db_function.name, db_function) 
-        @functions.delete( db_function.signature )
+      to_remove.each do |db_func|
+        @api.remove_function( db_func.name, db_func)
+        @functions.delete( db_func.signature )
       end
     end
 
@@ -802,9 +810,9 @@ module Amalgalite
         to_remove = possibles
       end
 
-      to_remove.each do |db_aggregate|
-        i = db_aggregate.new
-        @api.remove_aggregate( i.name, i.arity, db_aggregate )
+      to_remove.each do |db_agg|
+        i = db_agg.new
+        @api.remove_aggregate( i.name, i.arity, db_agg)
         @aggregates.delete( i.signature )
       end
     end

data/lib/amalgalite/packer.rb

@@ -105,7 +105,7 @@ module Amalgalite
     # The SQL to create the table for storing ruby code
     #
     def create_table_sql
-      sql = <<-create
+      <<-create
       CREATE TABLE #{options[:table_name]} (
       id                   INTEGER PRIMARY KEY AUTOINCREMENT,
       #{options[:filename_column]}   TEXT UNIQUE,
@@ -211,7 +211,10 @@ module Amalgalite
           STDERR.puts "Unable to add #{f} to the manifest, cannot find the file on disk"
           next
         end
-        m.require_path = m.require_path.to_s[ /\A(.*)\.rb\Z/, 1]
+        # Make sure that we can handle files without the .rb extension
+        # if we have to. This means bin/foo works as a require path
+        # without requiring bin/foo to actually be bin/foo.rb
+        m.require_path = m.require_path.to_s.sub(/\.rb\Z/,'')
         manifest << m
       end
       return manifest

data/lib/amalgalite/requires.rb

@@ -18,17 +18,24 @@ module Amalgalite
       end
 
       #
-      # Allocate a database connection to the given filename
+      # Allocate a database connection to the given filename. For
+      # file databases, this means giving the same connection
+      # back if you ask for a connection to the same file.
+      # For in-memory databases, you get a new one each time.
       #
       def db_connection_to( dbfile_name )
-        unless connection = load_path_db_connections[ dbfile_name ] 
-          connection = ::Amalgalite::Database.new( dbfile_name )
-          load_path_db_connections[dbfile_name] = connection
+        if dbfile_name == ":memory:"
+          return ::Amalgalite::Database.new( dbfile_name )
+        else
+          unless connection = load_path_db_connections[ dbfile_name ] 
+            connection = ::Amalgalite::Database.new( dbfile_name )
+            load_path_db_connections[dbfile_name] = connection
+          end
+          return connection
         end
-        return connection
       end
 
-      # 
+      #
       # Setting a class level variable as a flag to know what we are currently
       # in the middle of requiring
       #
@@ -55,7 +62,7 @@ module Amalgalite
           raise ::LoadError, "amalgalite has no such file to load -- #{filename}"
         end
       end
-   end
+    end
 
     attr_reader :dbfile_name
     attr_reader :table_name
@@ -96,16 +103,12 @@ module Amalgalite
       else
         begin
           filename = filename.gsub(/\.rb\Z/,'')
-          rows = db_connection.execute(sql, filename)
-          if rows.size > 0 then
-            row = rows.first
-            contents = row[contents_column].to_s
-            if row[compressed_column] then 
-              contents = ::Amalgalite::Packer.gunzip( contents )
-            end
 
-            eval( contents, TOPLEVEL_BINDING, row[filename_column] )
-            $LOADED_FEATURES << row[filename_column]
+          contents = file_contents(filename)
+
+          if contents
+            eval( contents, TOPLEVEL_BINDING, filename )
+            $LOADED_FEATURES << filename
             return true
           else
             return false
@@ -115,6 +118,34 @@ module Amalgalite
         end
       end
     end
+
+    # 
+    # Return the contents of the named file.
+    #
+    def file_contents(filename)
+      rows = db_connection.execute(sql, filename)
+      if rows.size > 0 then
+        row = rows.first
+
+        contents = row[contents_column].to_s
+        if row[compressed_column] then 
+          contents = ::Amalgalite::Packer.gunzip( contents )
+        end
+        
+        return contents
+      else
+        return nil
+      end
+    end
+
+    
+    #
+    # Import an SQL dump into the fake file system.
+    #
+    def import(sql)
+      db_connection.import(sql)
+    end
+
   end
 end
 require 'amalgalite/core_ext/kernel/require'

data/lib/amalgalite/schema.rb

@@ -15,31 +15,52 @@ module Amalgalite
   #
   class Schema
 
+    # The internal database that this schema is for. Most of the time this will
+    # be 'main' for the main database. For the temp tables, this will be 'temp'
+    # and for any attached databsae, this is the name of attached database.
     attr_reader :catalog
-    attr_reader :schema 
+
+    # The schema_version at the time this schema was taken.
     attr_reader :schema_version
-    attr_writer :dirty
+
+    # The Amalagalite::Database this schema is associated with.
     attr_reader :db
 
     #
     # Create a new instance of Schema
     #
-    def initialize( db, catalog = 'main', schema = 'sqlite')
-      @db = db
-      @catalog = catalog
-      @schema = schema
+    def initialize( db, catalog = 'main', master_table = 'sqlite_master' )
+      @db             = db
+      @catalog        = catalog
       @schema_version = nil
-      @tables = {}
-      @views  = {}
+      @tables         = {}
+      @views          = {}
+      @master_table   = master_table
+
+      if @master_table == 'sqlite_master' then
+        @temp_schema = ::Amalgalite::Schema.new( db, 'temp', 'sqlite_temp_master')
+      else
+        @temp_schema = nil
+      end
       load_schema!
     end
 
-    def dirty?() 
-      return (@schema_version != self.current_version)
+    def catalog_master_table
+      "#{catalog}.#{@master_table}"
+    end
+
+    def temporary?
+      catalog == "temp"
+    end
+
+    def dirty?()
+      return true  if (@schema_version != self.current_version)
+      return false unless @temp_schema
+      return @temp_schema.dirty?
     end
 
     def current_version
-      @db.first_value_from("PRAGMA schema_version")
+      @db.first_value_from("PRAGMA #{catalog}.schema_version")
     end
 
     #
@@ -47,15 +68,24 @@ module Amalgalite
     def load_schema!
       load_tables
       load_views
+      if @temp_schema then
+        @temp_schema.load_schema!
+      end
       @schema_version = self.current_version
       nil
     end
 
     ##
-    # return the tables, reloading if dirty
+    # return the tables, reloading if dirty.
+    # If there is a temp table and a normal table with the same name, then the
+    # temp table is the one that is returned in the hash.
     def tables
       load_schema! if dirty?
-      return @tables
+      t = @tables
+      if @temp_schema then
+        t = @tables.merge( @temp_schema.tables )
+      end
+      return t
     end
 
     ##
@@ -63,7 +93,7 @@ module Amalgalite
     #
     def load_tables
       @tables = {}
-      @db.execute("SELECT tbl_name FROM sqlite_master WHERE type = 'table' AND name != 'sqlite_sequence'") do |table_info|
+      @db.execute("SELECT tbl_name FROM #{catalog_master_table} WHERE type = 'table' AND name != 'sqlite_sequence'") do |table_info|
         table = load_table( table_info['tbl_name'] )
         table.indexes = load_indexes( table )
         @tables[table.name] = table
@@ -74,36 +104,26 @@ module Amalgalite
     ##
     # Load a single table
     def load_table( table_name )
-      rows = @db.execute("SELECT tbl_name, sql FROM sqlite_master WHERE type = 'table' AND tbl_name = ?", table_name)
+      rows = @db.execute("SELECT tbl_name, sql FROM #{catalog_master_table} WHERE type = 'table' AND tbl_name = ?", table_name)
       table_info = rows.first
       table = nil
-      if table_info then 
+      if table_info then
         table = Amalgalite::Table.new( table_info['tbl_name'], table_info['sql'] )
-        table.columns = load_columns( table )
         table.schema = self
+        table.columns = load_columns( table )
         table.indexes = load_indexes( table )
-        @tables[table.name] = table 
-      else
-        # might be a temporary table
-        table = Amalgalite::Table.new( table_name, nil )
-        cols = load_columns( table )
-        if cols.size > 0 then
-          table.columns = cols
-          table.schema = self
-          table.indexes = load_indexes( table )
-          @tables[table.name] = table
-        end
+        @tables[table.name] = table
       end
       return table
     end
 
-    ## 
+    ##
     # load all the indexes for a particular table
     #
     def load_indexes( table )
       indexes = {}
 
-      @db.prepare("SELECT name, sql FROM sqlite_master WHERE type ='index' and tbl_name = $name") do |idx_stmt|
+      @db.prepare("SELECT name, sql FROM #{catalog_master_table} WHERE type ='index' and tbl_name = $name") do |idx_stmt|
         idx_stmt.execute( "$name" => table.name) do |idx_info|
           indexes[idx_info['name']] = Amalgalite::Index.new( idx_info['name'], idx_info['sql'], table )
         end
@@ -134,8 +154,8 @@ module Amalgalite
     def load_columns( table )
       cols = {}
       idx = 0
-      @db.execute("PRAGMA table_info(#{@db.quote(table.name)})") do |row|
-        col = Amalgalite::Column.new( "main", table.name, row['name'], row['cid'])
+      @db.execute("PRAGMA #{catalog}.table_info(#{@db.quote(table.name)})") do |row|
+        col = Amalgalite::Column.new( catalog,  table.name, row['name'], row['cid'])
 
         col.default_value       = row['dflt_value']
 
@@ -154,7 +174,7 @@ module Amalgalite
 
         unless table.temporary? then
           # get more exact information
-          @db.api.table_column_metadata( "main", table.name, col.name ).each_pair do |key, value|
+          @db.api.table_column_metadata( catalog, table.name, col.name ).each_pair do |key, value|
             col.send("#{key}=", value)
           end
         end
@@ -168,16 +188,23 @@ module Amalgalite
     ##
     # return the views, reloading if dirty
     #
+    # If there is a temp view, and a regular view of the same name, then the
+    # temporary view is the one that is returned in the hash.
+    #
     def views
       reload_schema! if dirty?
-      return @views
+      v = @views
+      if @temp_schema then
+        v = @views.merge( @temp_schema.views )
+      end
+      return v
     end
 
     ##
     # load a single view
     #
     def load_view( name )
-      rows = @db.execute("SELECT name, sql FROM sqlite_master WHERE type = 'view' AND name = ?", name )
+      rows = @db.execute("SELECT name, sql FROM #{catalog_master_table} WHERE type = 'view' AND name = ?", name )
       view_info = rows.first
       view = Amalgalite::View.new( view_info['name'], view_info['sql'] )
       view.schema = self
@@ -188,7 +215,7 @@ module Amalgalite
     # load all the views for the database
     #
     def load_views
-      @db.execute("SELECT name, sql FROM sqlite_master WHERE type = 'view'") do |view_info|
+      @db.execute("SELECT name, sql FROM #{catalog_master_table} WHERE type = 'view'") do |view_info|
         view = load_view( view_info['name'] )
         @views[view.name] = view
       end