sqlite3-ruby 0.6.0 → 0.9.0

data/lib/sqlite3/database.rb

@@ -249,12 +249,12 @@ module SQLite3
     # This always returns +nil+, making it unsuitable for queries that return
     # rows.
     def execute_batch( sql, *bind_vars )
-      loop do
+      sql = sql.strip
+      until sql.empty? do
         prepare( sql ) do |stmt|
           stmt.execute( *bind_vars )
-          sql = stmt.remainder
+          sql = stmt.remainder.strip
         end
-        break if sql.length < 1
       end
       nil
     end
@@ -299,8 +299,7 @@ module SQLite3
 
     # Interrupts the currently executing operation, causing it to abort.
     def interrupt
-      result = @driver.interrupt( @handle )
-      Error.check( result, self )
+      @driver.interrupt( @handle )
     end
 
     # Register a busy handler with this database instance. When a requested
@@ -345,9 +344,9 @@ module SQLite3
     #
     #   db.create_function( "maim", 1 ) do |func, value|
     #     if value.nil?
-    #       func.set_value nil
+    #       func.result = nil
     #     else
-    #       func.set_value value.split(//).sort.join
+    #       func.result = value.split(//).sort.join
     #     end
     #   end
     #
@@ -359,7 +358,7 @@ module SQLite3
         begin
           block.call( FunctionProxy.new( @driver, func ),
             *args.map{|v| Value.new(self,v)} )
-        rescue Exception => e
+        rescue StandardError, Exception => e
           @driver.result_error( func,
             "#{e.message} (#{e.class})", -1 )
         end
@@ -513,8 +512,8 @@ module SQLite3
           ctx[ :handler ] ||= handler.new
           begin
             ctx[ :handler ].step( FunctionProxy.new( @driver, func, ctx ),
-              *args )
-          rescue Exception => e
+              *args.map{|v| Value.new(self,v)} )
+          rescue Exception, StandardError => e
             ctx[ :__error ] = e
           end
         end
@@ -548,6 +547,9 @@ module SQLite3
     # by SQLite, so attempting to nest a transaction will result in a runtime
     # exception.
     #
+    # The +mode+ parameter may be either <tt>:deferred</tt> (the default),
+    # <tt>:immediate</tt>, or <tt>:exclusive</tt>.
+    #
     # If a block is given, the database instance is yielded to it, and the
     # transaction is committed when the block terminates. If the block
     # raises an exception, a rollback will be performed instead. Note that if
@@ -557,8 +559,8 @@ module SQLite3
     # If a block is not given, it is the caller's responsibility to end the
     # transaction explicitly, either by calling #commit, or by calling
     # #rollback.
-    def transaction
-      execute "begin transaction"
+    def transaction( mode = :deferred )
+      execute "begin #{mode.to_s} transaction"
       @transaction_active = true
 
       if block_given?

data/lib/sqlite3/driver/dl/driver.rb

@@ -48,7 +48,7 @@ class DL::PtrData
   def to_object
     n = to_s(4).unpack("L").first
     return nil if n < 1
-    ObjectSpace._id2ref(n)
+    ObjectSpace._id2ref(n) rescue self.to_s
   end
 
   def set_object(obj)
@@ -170,7 +170,7 @@ module SQLite3 ; module Driver ; module DL
 
       unless @trace_handler_callback
         @trace_handler_callback = ::DL.callback( "IPS" ) do |cookie,sql|
-          @trace_handler.call( cookie, sql ) || 0
+          @trace_handler.call( cookie ? cookie.to_object : nil, sql ) || 0
         end
       end
 
@@ -218,7 +218,7 @@ module SQLite3 ; module Driver ; module DL
     def aggregate_context( context )
       ptr = API.sqlite3_aggregate_context( context, 4 )
       ptr.free = nil
-      obj = ptr.to_object
+      obj = ( ptr ? ptr.to_object : nil )
       if obj.nil?
         obj = Hash.new
         ptr.set_object obj
@@ -237,6 +237,21 @@ module SQLite3 ; module Driver ; module DL
       API.send( method, stmt, index, s, s.length, TRANSIENT )
     end
 
+    def column_text( stmt, column )
+      result = API.sqlite3_column_text( stmt, column )
+      result ? result.to_s : nil
+    end
+
+    def column_name( stmt, column )
+      result = API.sqlite3_column_name( stmt, column )
+      result ? result.to_s : nil
+    end
+
+    def column_decltype( stmt, column )
+      result = API.sqlite3_column_decltype( stmt, column )
+      result ? result.to_s : nil
+    end
+
     def self.api_delegate( name )
       define_method( name ) { |*args| API.send( "sqlite3_#{name}", *args ) }
     end
@@ -250,13 +265,12 @@ module SQLite3 ; module Driver ; module DL
     api_delegate :busy_timeout
     api_delegate :changes
     api_delegate :close
+    api_delegate :column_bytes
+    api_delegate :column_bytes16
     api_delegate :column_count
-    api_delegate :column_decltype
     api_delegate :column_double
     api_delegate :column_int
     api_delegate :column_int64
-    api_delegate :column_name
-    api_delegate :column_text
     api_delegate :column_type
     api_delegate :data_count
     api_delegate :errcode

data/lib/sqlite3/driver/native/driver.rb

@@ -0,0 +1,218 @@
+#--
+# =============================================================================
+# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu)
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+# 
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+# 
+#     * The names of its contributors may not be used to endorse or promote
+#       products derived from this software without specific prior written
+#       permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# =============================================================================
+#++
+
+require 'sqlite3_api'
+
+module SQLite3 ; module Driver ; module Native
+
+  class Driver
+
+    def initialize
+      @callback_data = Hash.new
+    end
+
+    def complete?( sql, utf16=false )
+      API.send( utf16 ? :sqlite3_complete16 : :sqlite3_complete, sql ) != 0
+    end
+
+    def busy_handler( db, data=nil, &block )
+      if block
+        cb = API::CallbackData.new
+        cb.proc = block
+        cb.data = data
+      end
+
+      API.sqlite3_busy_handler( db,
+        block ? API::Sqlite3_ruby_busy_handler : nil, cb )
+    end
+
+    def set_authorizer( db, data=nil, &block )
+      if block
+        cb = API::CallbackData.new
+        cb.proc = block
+        cb.data = data
+      end
+
+      API.sqlite3_set_authorizer( db,
+        block ? API::Sqlite3_ruby_authorizer : nil, cb )
+    end
+
+    def trace( db, data=nil, &block )
+      if block
+        cb = API::CallbackData.new
+        cb.proc = block
+        cb.data = data
+      end
+
+      API.sqlite3_trace( db,
+        block ? API::Sqlite3_ruby_trace : nil, cb )
+    end
+
+    def open( filename, utf16=false )
+      API.send( utf16 ? :sqlite3_open16 : :sqlite3_open, filename )
+    end
+
+    def errmsg( db, utf16=false )
+      API.send( utf16 ? :sqlite3_errmsg16 : :sqlite3_errmsg, db )
+    end
+
+    def prepare( db, sql, utf16=false )
+      API.send( ( utf16 ? :sqlite3_prepare16 : :sqlite3_prepare ),
+        db, sql )
+    end
+
+    def bind_text( stmt, index, value, utf16=false )
+      API.send( ( utf16 ? :sqlite3_bind_text16 : :sqlite3_bind_text ),
+        stmt, index, value )
+    end
+
+    def column_name( stmt, index, utf16=false )
+      API.send( ( utf16 ? :sqlite3_column_name16 : :sqlite3_column_name ),
+        stmt, index )
+    end
+
+    def column_decltype( stmt, index, utf16=false )
+      API.send(
+        ( utf16 ? :sqlite3_column_decltype16 : :sqlite3_column_decltype ),
+        stmt, index )
+    end
+
+    def column_text( stmt, index, utf16=false )
+      API.send( ( utf16 ? :sqlite3_column_text16 : :sqlite3_column_text ),
+        stmt, index )
+    end
+
+    def create_function( db, name, args, text, cookie, func, step, final )
+      if func || ( step && final )
+        cb = API::CallbackData.new
+        cb.proc = cb.proc2 = nil
+        cb.data = cookie
+        @callback_data[ name ] = cb
+      else
+        @callback_data.delete( name )
+      end
+
+      if func
+        cb.proc = func
+
+        func = API::Sqlite3_ruby_function_step
+        step = final = nil
+      elsif step && final
+        cb.proc = step
+        cb.proc2 = final
+
+        func = nil
+        step = API::Sqlite3_ruby_function_step
+        final = API::Sqlite3_ruby_function_final
+      end
+
+      API.sqlite3_create_function( db, name, args, text, cb, func, step, final )
+    end
+
+    def value_text( value, utf16=false )
+      method = case utf16
+        when nil, false then :sqlite3_value_text
+        when :le then :sqlite3_value_text16le
+        when :be then :sqlite3_value_text16be
+        else :sqlite3_value_text16
+      end
+
+      API.send( method, value )
+    end
+
+    def result_text( context, result, utf16=false )
+      method = case utf16
+        when nil, false then :sqlite3_result_text
+        when :le then :sqlite3_result_text16le
+        when :be then :sqlite3_result_text16be
+        else :sqlite3_result_text16
+      end
+
+      API.send( method, context, result.to_s )
+    end
+
+    def result_error( context, value, utf16=false )
+      API.send( ( utf16 ? :sqlite3_result_error16 : :sqlite3_result_error ),
+        context, value )
+    end
+
+    def self.api_delegate( name )
+      define_method( name ) { |*args| API.send( "sqlite3_#{name}", *args ) }
+    end
+
+    api_delegate :libversion
+    api_delegate :close
+    api_delegate :last_insert_rowid
+    api_delegate :changes
+    api_delegate :total_changes
+    api_delegate :interrupt
+    api_delegate :busy_timeout
+    api_delegate :errcode
+    api_delegate :bind_blob
+    api_delegate :bind_double
+    api_delegate :bind_int
+    api_delegate :bind_int64
+    api_delegate :bind_null
+    api_delegate :bind_parameter_count
+    api_delegate :bind_parameter_name
+    api_delegate :bind_parameter_index
+    api_delegate :column_count
+    api_delegate :step
+    api_delegate :data_count
+    api_delegate :column_blob
+    api_delegate :column_bytes
+    api_delegate :column_bytes16
+    api_delegate :column_double
+    api_delegate :column_int
+    api_delegate :column_int64
+    api_delegate :column_type
+    api_delegate :finalize
+    api_delegate :reset
+    api_delegate :aggregate_count
+    api_delegate :value_blob
+    api_delegate :value_bytes
+    api_delegate :value_bytes16
+    api_delegate :value_double
+    api_delegate :value_int
+    api_delegate :value_int64
+    api_delegate :value_type
+    api_delegate :result_blob
+    api_delegate :result_double
+    api_delegate :result_int
+    api_delegate :result_int64
+    api_delegate :result_null
+    api_delegate :result_value
+    api_delegate :aggregate_context
+
+  end
+
+end ; end ; end

data/lib/sqlite3/resultset.rb

@@ -81,7 +81,7 @@ module SQLite3
     # can be rewound and reiterated.
     def reset( *bind_params )
       @driver.reset( @stmt.handle )
-      @stmt.bind_params *bind_params
+      @stmt.bind_params( *bind_params )
       @eof = false
       commence
     end

data/lib/sqlite3/version.rb

@@ -35,7 +35,7 @@ module SQLite3
   module Version
 
     MAJOR = 0
-    MINOR = 6
+    MINOR = 9
     TINY  = 0
 
     STRING = [ MAJOR, MINOR, TINY ].join( "." )

data/test/native-vs-dl.rb

@@ -0,0 +1,126 @@
+$:.unshift "../lib", "../ext/sqlite3_api"
+
+require 'sqlite3'
+
+require 'benchmark'
+
+N = 1000
+
+$VERBOSE=nil
+
+puts "database creation..."
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    N.times do
+      File.delete "test.db" rescue nil
+      SQLite3::Database.open( "test.db", :driver => "DL" ).close
+    end
+  end
+  x.report('native') do
+    N.times do
+      File.delete "test.db" rescue nil
+      SQLite3::Database.open( "test.db", :driver => "Native" ).close
+    end
+  end
+end
+File.delete "test.db" rescue nil
+
+SQLite3::Database.open( "test.db" ).close
+
+puts
+puts "database open..."
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    N.times do
+      SQLite3::Database.open( "test.db", :driver => "DL" ).close
+    end
+  end
+  x.report('native') do
+    N.times do
+      SQLite3::Database.open( "test.db", :driver => "Native" ).close
+    end
+  end
+end
+File.delete "test.db" rescue nil
+
+dl = SQLite3::Database.open( "test-dl.db", :driver => "DL" )
+native = SQLite3::Database.open( "test-native.db", :driver => "Native" )
+
+dl.execute "create table foo (a,b)"
+native.execute "create table foo (a,b)"
+
+puts
+puts "insertions"
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    dl.transaction do
+      N.times do |i|
+        dl.execute "insert into foo values (#{i}, #{i+1})"
+      end
+    end
+  end
+  x.report('native') do
+    native.transaction do
+      N.times do |i|
+        native.execute "insert into foo values (#{i}, #{i+1})"
+      end
+    end
+  end
+end
+
+puts
+puts "insertions using prepared statement"
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    dl.transaction do
+      dl.prepare "insert into foo values (?,?)" do |stmt|
+        N.times { |i| stmt.execute i, i+1 }
+      end
+    end
+  end
+  x.report('native') do
+    native.transaction do
+      native.prepare( "insert into foo values (?,?)" ) do |stmt|
+        N.times { |i| stmt.execute i, i+1 }
+      end
+    end
+  end
+end
+
+dl.close
+native.close
+File.delete "test-dl.db" rescue nil
+File.delete "test-native.db" rescue nil
+
+dl = SQLite3::Database.open( "test-dl.db", :driver => "DL" )
+native = SQLite3::Database.open( "test-native.db", :driver => "Native" )
+
+dl.execute "create table foo (a,b)"
+dl.execute "insert into foo values (1,2)"
+dl.execute "insert into foo values (3,4)"
+dl.execute "insert into foo values (5,6)"
+
+native.execute "create table foo (a,b)"
+native.execute "insert into foo values (1,2)"
+native.execute "insert into foo values (3,4)"
+native.execute "insert into foo values (5,6)"
+
+puts
+puts "queries"
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    N.times do
+      dl.execute "select * from foo"
+    end
+  end
+  x.report('native') do
+    N.times do
+      native.execute "select * from foo"
+    end
+  end
+end
+
+dl.close
+native.close
+File.delete "test-dl.db" rescue nil
+File.delete "test-native.db" rescue nil