sqlite3-ruby 1.0.1 → 1.1.0

data/lib/sqlite3/database.rb

@@ -204,7 +204,7 @@ module SQLite3
     # by the query. Otherwise, any results are accumulated into an array and
     # returned wholesale.
     #
-    # See also #execute2, and #execute_batch for additional ways of
+    # See also #execute2, #query, and #execute_batch for additional ways of
     # executing statements.
     def execute( sql, *bind_vars )
       prepare( sql ) do |stmt|
@@ -225,7 +225,7 @@ module SQLite3
     # Thus, even if the query itself returns no rows, this method will always
     # return at least one row--the names of the columns.
     #
-    # See also #execute, and #execute_batch for additional ways of
+    # See also #execute, #query, and #execute_batch for additional ways of
     # executing statements.
     def execute2( sql, *bind_vars )
       prepare( sql ) do |stmt|
@@ -259,6 +259,30 @@ module SQLite3
       nil
     end
 
+    # This is a convenience method for creating a statement, binding
+    # paramters to it, and calling execute:
+    #
+    #   result = db.query( "select * from foo where a=?", 5 )
+    #   # is the same as
+    #   result = db.prepare( "select * from foo where a=?" ).execute( 5 )
+    #
+    # You must be sure to call +close+ on the ResultSet instance that is
+    # returned, or you could have problems with locks on the table. If called
+    # with a block, +close+ will be invoked implicitly when the block 
+    # terminates.
+    def query( sql, *bind_vars )
+      result = prepare( sql ).execute( *bind_vars )
+      if block_given?
+        begin
+          yield result
+        ensure
+          result.close
+        end
+      else
+        return result
+      end
+    end
+
     # A convenience method for obtaining the first row of a result set, and
     # discarding all others. It is otherwise identical to #execute.
     #
@@ -620,7 +644,7 @@ module SQLite3
               break
             rescue SyntaxError
               raise
-            rescue ScriptError, Exception
+            rescue ScriptError, Exception, NameError
             end
           end
           raise "no driver for sqlite3 found" unless driver

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

@@ -40,7 +40,7 @@ module SQLite3 ; module Driver; module DL;
     library_name = case RUBY_PLATFORM.downcase
       when /darwin/
         "libsqlite3.dylib"
-      when /linux/, /freebsd|netbsd|openbsd|dragonfly/
+      when /linux/, /freebsd|netbsd|openbsd|dragonfly/, /solaris/
         "libsqlite3.so"
       when /win32/
         "sqlite3.dll"

data/lib/sqlite3/errors.rb

@@ -34,7 +34,19 @@ require 'sqlite3/constants'
 
 module SQLite3
 
-  class Exception < ::Exception; end
+  class Exception < ::Exception
+    @code = 0
+
+    # The numeric error code that this exception represents.
+    def self.code
+      @code
+    end
+
+    # A convenience for accessing the error code for this exception.
+    def code
+      self.class.code
+    end
+  end
 
   class SQLException < Exception; end
   class InternalException < Exception; end
@@ -59,6 +71,9 @@ module SQLite3
   class MisuseException < Exception; end
   class UnsupportedException < Exception; end
   class AuthorizationException < Exception; end
+  class FormatException < Exception; end
+  class RangeException < Exception; end
+  class NotADatabaseException < Exception; end
 
   EXCEPTIONS = [
     nil,
@@ -68,14 +83,15 @@ module SQLite3
     NotFoundException, FullException, CantOpenException, ProtocolException,
     EmptyException, SchemaChangedException, TooBigException,
     ConstraintException, MismatchException, MisuseException,
-    UnsupportedException, AuthorizationException
-  ]
+    UnsupportedException, AuthorizationException, FormatException,
+    RangeException, NotADatabaseException
+  ].each_with_index { |e,i| e.instance_variable_set( :@code, i ) if e }
 
   module Error
     def check( result, db=nil, msg=nil )
       unless result == Constants::ErrorCode::OK
         msg = ( msg ? msg + ": " : "" ) + db.errmsg if db
-        raise EXCEPTIONS[result], msg
+        raise ( EXCEPTIONS[result] || SQLite3::Exception ), msg
       end
     end
     module_function :check

data/lib/sqlite3/resultset.rb

@@ -80,6 +80,7 @@ module SQLite3
     # Reset the cursor, so that a result set which has reached end-of-file
     # can be rewound and reiterated.
     def reset( *bind_params )
+      @stmt.must_be_open!
       @driver.reset( @stmt.handle )
       @stmt.bind_params( *bind_params )
       @eof = false
@@ -107,6 +108,8 @@ module SQLite3
     def next
       return nil if @eof
 
+      @stmt.must_be_open!
+
       unless @first_row
         result = @driver.step( @stmt.handle )
         check result
@@ -159,10 +162,24 @@ module SQLite3
       end
     end
 
+    # Closes the statement that spawned this result set.
+    # <em>Use with caution!</em> Closing a result set will automatically
+    # close any other result sets that were spawned from the same statement.
+    def close
+      @stmt.close
+    end
+
+    # Queries whether the underlying statement has been closed or not.
+    def closed?
+      @stmt.closed?
+    end
+
+    # Returns the types of the columns returned by this result set.
     def types
       @stmt.types
     end
 
+    # Returns the names of the columns returned by this result set.
     def columns
       @stmt.columns
     end

data/lib/sqlite3/statement.rb

@@ -65,14 +65,24 @@ module SQLite3
     def initialize( db, sql, utf16=false )
       @db = db
       @driver = @db.driver
+      @closed = false
       result, @handle, @remainder = @driver.prepare( @db.handle, sql )
       Error.check( result, @db )
     end
 
+    # Closes the statement by finalizing the underlying statement
+    # handle. The statement must not be used after being closed.
     def close
+      must_be_open!
+      @closed = true
       @driver.finalize( @handle )
     end
 
+    # Returns true if the underlying statement has been closed.
+    def closed?
+      @closed
+    end
+
     # Binds the given variables to the corresponding placeholders in the SQL
     # text.
     #
@@ -104,6 +114,7 @@ module SQLite3
     #
     # See also #bind_params.
     def bind_param( param, value )
+      must_be_open!
       if Fixnum === param
         case value
           when Integer then
@@ -140,6 +151,7 @@ module SQLite3
     #
     # See also #bind_params, #execute!.
     def execute( *bind_vars )
+      must_be_open!
       @driver.reset( @handle ) if @results
 
       bind_params *bind_vars unless bind_vars.empty?
@@ -199,6 +211,8 @@ module SQLite3
     # that this will actually execute the SQL, which means it can be a
     # (potentially) expensive operation.
     def get_metadata
+      must_be_open!
+
       @columns = []
       @types = []
 
@@ -213,6 +227,14 @@ module SQLite3
     end
     private :get_metadata
 
+    # Performs a sanity check to ensure that the statement is not
+    # closed. If it is, an exception is raised.
+    def must_be_open! # :nodoc:
+      if @closed
+        raise SQLite3::Exception, "cannot use a closed statement"
+      end
+    end
+
   end
 
 end

data/lib/sqlite3/version.rb

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

data/test/tc_errors.rb

@@ -0,0 +1,54 @@
+#--
+# =============================================================================
+# 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.
+# =============================================================================
+#++
+
+$:.unshift "../lib"
+
+require 'sqlite3/errors'
+require 'test/unit'
+require 'flexmock'
+
+class TC_Errors < Test::Unit::TestCase
+  (1..26).each do |code|
+    define_method( "test_error_code_%02d" % code ) do
+      db = FlexMock.new
+      db.mock_handle( :errmsg ) { "message" }
+      begin
+        SQLite3::Error.check( code, db )
+      rescue SQLite3::Exception => e
+        assert_instance_of SQLite3::EXCEPTIONS[code], e
+        assert_equal code, e.code
+        assert_equal code, e.class.code
+        assert_equal "message", e.message
+      end
+    end
+  end
+end

data/test/tc_integration.rb

@@ -302,6 +302,70 @@ module Integration
         assert_equal %w{1 1 1}, rows
       end
 
+      define_method( "test_query_no_block_no_bind_no_match" ) do
+        result = @db.query( "select * from foo where a > 100" )
+        assert_nil result.next
+        result.close
+      end
+
+      define_method( "test_query_with_block_no_bind_no_match" ) do
+        r = nil
+        @db.query( "select * from foo where a > 100" ) do |result|
+          assert_nil result.next
+          r = result
+        end
+        assert r.closed?
+      end
+
+      define_method( "test_query_no_block_with_bind_no_match" ) do
+        result = @db.query( "select * from foo where a > ?", 100 )
+        assert_nil result.next
+        result.close
+      end
+
+      define_method( "test_query_with_block_with_bind_no_match" ) do
+        r = nil
+        @db.query( "select * from foo where a > ?", 100 ) do |result|
+          assert_nil result.next
+          r = result
+        end
+        assert r.closed?
+      end
+
+      define_method( "test_query_no_block_no_bind_with_match" ) do
+        result = @db.query( "select * from foo where a = 1" )
+        assert_not_nil result.next
+        assert_nil result.next
+        result.close
+      end
+
+      define_method( "test_query_with_block_no_bind_with_match" ) do
+        r = nil
+        @db.query( "select * from foo where a = 1" ) do |result|
+          assert_not_nil result.next
+          assert_nil result.next
+          r = result
+        end
+        assert r.closed?
+      end
+
+      define_method( "test_query_no_block_with_bind_with_match" ) do
+        result = @db.query( "select * from foo where a = ?", 1 )
+        assert_not_nil result.next
+        assert_nil result.next
+        result.close
+      end
+
+      define_method( "test_query_with_block_with_bind_with_match" ) do
+        r = nil
+        @db.query( "select * from foo where a = ?", 1 ) do |result|
+          assert_not_nil result.next
+          assert_nil result.next
+          r = result
+        end
+        assert r.closed?
+      end
+
       define_method( "test_get_first_row_no_bind_no_match" ) do
         result = @db.get_first_row( "select * from foo where a=100" )
         assert_nil result
@@ -741,6 +805,20 @@ module Integration
         end
         assert called
       end
+
+      define_method( "test_close" ) do
+        stmt = @db.prepare( "select * from foo" )
+        assert !stmt.closed?
+        stmt.close
+        assert stmt.closed?
+        assert_raise( SQLite3::Exception ) { stmt.execute }
+        assert_raise( SQLite3::Exception ) { stmt.execute! }
+        assert_raise( SQLite3::Exception ) { stmt.close }
+        assert_raise( SQLite3::Exception ) { stmt.bind_params 5 }
+        assert_raise( SQLite3::Exception ) { stmt.bind_param 1, 5 }
+        assert_raise( SQLite3::Exception ) { stmt.columns }
+        assert_raise( SQLite3::Exception ) { stmt.types }
+      end
     end
     const_set( "TC_Statement_#{driver}", test_case )
 
@@ -837,6 +915,21 @@ module Integration
       define_method( "test_columns" ) do
         assert_equal [ "a", "b" ], @result.columns
       end
+
+      define_method( "test_close" ) do
+        stmt = @db.prepare( "select * from foo" )
+        result = stmt.execute
+        assert !result.closed?
+        result.close
+        assert result.closed?
+        assert stmt.closed?
+        assert_raise( SQLite3::Exception ) { result.reset }
+        assert_raise( SQLite3::Exception ) { result.next }
+        assert_raise( SQLite3::Exception ) { result.each }
+        assert_raise( SQLite3::Exception ) { result.close }
+        assert_raise( SQLite3::Exception ) { result.types }
+        assert_raise( SQLite3::Exception ) { result.columns }
+      end
     end
     const_set( "TC_ResultSet_#{driver}", test_case )
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.4
 specification_version: 1
 name: sqlite3-ruby
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
-date: 2005-02-06
+  version: 1.1.0
+date: 2005-02-15
 summary: SQLite3/Ruby is a module to allow Ruby scripts to interface with a SQLite3 database.
 require_paths: 
   - lib
@@ -58,6 +58,7 @@ files:
   - test/mocks.rb
   - test/tests.rb
   - test/tc_integration.rb
+  - test/tc_errors.rb
   - test/driver
   - test/native-vs-dl.rb
   - test/tc_database.rb