sqlite3-ruby 0.5.0

data/lib/sqlite3/errors.rb

@@ -0,0 +1,84 @@
+#--
+# =============================================================================
+# 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/constants'
+
+module SQLite3
+
+  class Exception < ::Exception; end
+
+  class SQLException < Exception; end
+  class InternalException < Exception; end
+  class PermissionException < Exception; end
+  class AbortException < Exception; end
+  class BusyException < Exception; end
+  class LockedException < Exception; end
+  class MemoryException < Exception; end
+  class ReadOnlyException < Exception; end
+  class InterruptException < Exception; end
+  class IOException < Exception; end
+  class CorruptException < Exception; end
+  class NotFoundException < Exception; end
+  class FullException < Exception; end
+  class CantOpenException < Exception; end
+  class ProtocolException < Exception; end
+  class EmptyException < Exception; end
+  class SchemaChangedException < Exception; end
+  class TooBigException < Exception; end
+  class ConstraintException < Exception; end
+  class MismatchException < Exception; end
+  class MisuseException < Exception; end
+  class UnsupportedException < Exception; end
+  class AuthorizationException < Exception; end
+
+  EXCEPTIONS = [
+    nil,
+    SQLException, InternalException, PermissionException,
+    AbortException, BusyException, LockedException, MemoryException,
+    ReadOnlyException, InterruptException, IOException, CorruptException,
+    NotFoundException, FullException, CantOpenException, ProtocolException,
+    EmptyException, SchemaChangedException, TooBigException,
+    ConstraintException, MismatchException, MisuseException,
+    UnsupportedException, AuthorizationException
+  ]
+
+  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
+      end
+    end
+    module_function :check
+  end
+
+end

data/lib/sqlite3/pragmas.rb

@@ -0,0 +1,254 @@
+#--
+# =============================================================================
+# 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/errors'
+
+module SQLite3
+
+  # This module is intended for inclusion solely by the Database class. It
+  # defines convenience methods for the various pragmas supported by SQLite3.
+  #
+  # For a detailed description of these pragmas, see the SQLite3 documentation
+  # at http://sqlite.org/pragma.html.
+  module Pragmas
+
+    # Returns +true+ or +false+ depending on the value of the named pragma.
+    def get_boolean_pragma( name )
+      get_first_value( "PRAGMA #{name}" ) != "0"
+    end
+    private :get_boolean_pragma
+
+    # Sets the given pragma to the given boolean value. The value itself
+    # may be +true+ or +false+, or any other commonly used string or
+    # integer that represents truth.
+    def set_boolean_pragma( name, mode )
+      case mode
+        when String
+          case mode.downcase
+            when "on", "yes", "true", "y", "t": mode = "'ON'"
+            when "off", "no", "false", "n", "f": mode = "'OFF'"
+            else
+              raise Exception,
+                "unrecognized pragma parameter #{mode.inspect}"
+          end
+        when true, 1
+          mode = "ON"
+        when false, 0, nil
+          mode = "OFF"
+        else
+          raise Exception,
+            "unrecognized pragma parameter #{mode.inspect}"
+      end
+
+      execute( "PRAGMA #{name}=#{mode}" )
+    end
+    private :set_boolean_pragma
+
+    # Requests the given pragma (and parameters), and if the block is given,
+    # each row of the result set will be yielded to it. Otherwise, the results
+    # are returned as an array.
+    def get_query_pragma( name, *parms, &block ) # :yields: row
+      if parms.empty?
+        execute( "PRAGMA #{name}", &block )
+      else
+        args = "'" + parms.join("','") + "'"
+        execute( "PRAGMA #{name}( #{args} )", &block )
+      end
+    end
+    private :get_query_pragma
+
+    # Return the value of the given pragma.
+    def get_enum_pragma( name )
+      get_first_value( "PRAGMA #{name}" )
+    end
+    private :get_enum_pragma
+
+    # Set the value of the given pragma to +mode+. The +mode+ parameter must
+    # conform to one of the values in the given +enum+ array. Each entry in
+    # the array is another array comprised of elements in the enumeration that
+    # have duplicate values. See #synchronous, #default_synchronous,
+    # #temp_store, and #default_temp_store for usage examples.
+    def set_enum_pragma( name, mode, enums )
+      match = enums.find { |p| p.find { |i| i.to_s.downcase == mode.to_s.downcase } }
+      raise Exception,
+        "unrecognized #{name} #{mode.inspect}" unless match
+      execute( "PRAGMA #{name}='#{match.first.upcase}'" )
+    end
+    private :set_enum_pragma
+
+    # Returns the value of the given pragma as an integer.
+    def get_int_pragma( name )
+      get_first_value( "PRAGMA #{name}" ).to_i
+    end
+    private :get_int_pragma
+
+    # Set the value of the given pragma to the integer value of the +value+
+    # parameter.
+    def set_int_pragma( name, value )
+      execute( "PRAGMA #{name}=#{value.to_i}" )
+    end
+    private :set_int_pragma
+
+    # The enumeration of valid synchronous modes.
+    SYNCHRONOUS_MODES = [ [ 'full', 2 ], [ 'normal', 1 ], [ 'off', 0 ] ]
+
+    # The enumeration of valid temp store modes.
+    TEMP_STORE_MODES  = [ [ 'default', 0 ], [ 'file', 1 ], [ 'memory', 2 ] ]
+
+    # Does an integrity check on the database. If the check fails, a
+    # SQLite3::Exception will be raised. Otherwise it
+    # returns silently.
+    def integrity_check
+      execute( "PRAGMA integrity_check" ) do |row|
+        raise Exception, row[0] if row[0] != "ok"
+      end
+    end
+
+    def auto_vacuum
+      get_boolean_pragma "auto_vacuum"
+    end
+
+    def auto_vacuum=( mode )
+      set_boolean_pragma "auto_vacuum", mode
+    end
+
+    def schema_cookie
+      get_int_pragma "schema_cookie"
+    end
+
+    def schema_cookie=( cookie )
+      set_int_pragma "schema_cookie", cookie
+    end
+
+    def user_cookie
+      get_int_pragma "user_cookie"
+    end
+
+    def user_cookie=( cookie )
+      set_int_pragma "user_cookie", cookie
+    end
+
+    def cache_size
+      get_int_pragma "cache_size"
+    end
+
+    def cache_size=( size )
+      set_int_pragma "cache_size", size
+    end
+
+    def default_cache_size
+      get_int_pragma "default_cache_size"
+    end
+
+    def default_cache_size=( size )
+      set_int_pragma "default_cache_size", size
+    end
+
+    def default_synchronous
+      get_enum_pragma "default_synchronous"
+    end
+
+    def default_synchronous=( mode )
+      set_enum_pragma "default_synchronous", mode, SYNCHRONOUS_MODES
+    end
+
+    def synchronous
+      get_enum_pragma "synchronous"
+    end
+
+    def synchronous=( mode )
+      set_enum_pragma "synchronous", mode, SYNCHRONOUS_MODES
+    end
+
+    def default_temp_store
+      get_enum_pragma "default_temp_store"
+    end
+
+    def default_temp_store=( mode )
+      set_enum_pragma "default_temp_store", mode, TEMP_STORE_MODES
+    end
+  
+    def temp_store
+      get_enum_pragma "temp_store"
+    end
+
+    def temp_store=( mode )
+      set_enum_pragma "temp_store", mode, TEMP_STORE_MODES
+    end
+
+    def full_column_names
+      get_boolean_pragma "full_column_names"
+    end
+
+    def full_column_names=( mode )
+      set_boolean_pragma "full_column_names", mode
+    end
+  
+    def parser_trace
+      get_boolean_pragma "parser_trace"
+    end
+
+    def parser_trace=( mode )
+      set_boolean_pragma "parser_trace", mode
+    end
+  
+    def vdbe_trace
+      get_boolean_pragma "vdbe_trace"
+    end
+
+    def vdbe_trace=( mode )
+      set_boolean_pragma "vdbe_trace", mode
+    end
+
+    def database_list( &block ) # :yields: row
+      get_query_pragma "database_list", &block
+    end
+
+    def foreign_key_list( table, &block ) # :yields: row
+      get_query_pragma "foreign_key_list", table, &block
+    end
+
+    def index_info( index, &block ) # :yields: row
+      get_query_pragma "index_info", index, &block
+    end
+
+    def index_list( table, &block ) # :yields: row
+      get_query_pragma "index_list", table, &block
+    end
+
+    def table_info( table, &block ) # :yields: row
+      get_query_pragma "table_info", table, &block
+    end
+  
+  end
+
+end

data/lib/sqlite3/resultset.rb

@@ -0,0 +1,172 @@
+#--
+# =============================================================================
+# 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/constants'
+require 'sqlite3/errors'
+
+module SQLite3
+
+  # The ResultSet object encapsulates the enumerability of a query's output.
+  # It is a simple cursor over the data that the query returns. It will
+  # very rarely (if ever) be instantiated directly. Instead, client's should
+  # obtain a ResultSet instance via Statement#execute.
+  class ResultSet
+    include Enumerable
+
+    # A trivial module for adding a +types+ accessor to an object.
+    module TypesContainer
+      attr_accessor :types
+    end
+
+    # A trivial module for adding a +fields+ accessor to an object.
+    module FieldsContainer
+      attr_accessor :fields
+    end
+
+    # Create a new ResultSet attached to the given database, using the
+    # given sql text.
+    def initialize( db, stmt )
+      @db = db
+      @driver = @db.driver
+      @stmt = stmt
+      commence
+    end
+
+    # A convenience method for compiling the virtual machine and stepping
+    # to the first row of the result set.
+    def commence
+      result = @driver.step( @stmt.handle )
+      check result
+      @first_row = true
+    end
+    private :commence
+
+    def check( result )
+      @eof = ( result == Constants::ErrorCode::DONE )
+      found = ( result == Constants::ErrorCode::ROW )
+      Error.check( result, @db ) unless @eof || found
+    end
+    private :check
+
+    # Reset the cursor, so that a result set which has reached end-of-file
+    # can be rewound and reiterated.
+    def reset( *bind_params )
+      @driver.reset( @stmt.handle )
+      @stmt.bind_params *bind_params
+      @eof = false
+      commence
+    end
+
+    # Query whether the cursor has reached the end of the result set or not.
+    def eof?
+      @eof
+    end
+
+    # Obtain the next row from the cursor. If there are no more rows to be
+    # had, this will return +nil+. If type translation is active on the
+    # corresponding database, the values in the row will be translated
+    # according to their types.
+    #
+    # The returned value will be an array, unless Database#results_as_hash has
+    # been set to +true+, in which case the returned value will be a hash.
+    #
+    # For arrays, the column names are accessible via the +fields+ property,
+    # and the column types are accessible via the +types+ property.
+    #
+    # For hashes, the column names are the keys of the hash, and the column
+    # types are accessible via the +types+ property.
+    def next
+      return nil if @eof
+
+      unless @first_row
+        result = @driver.step( @stmt.handle )
+        check result
+      end
+
+      @first_row = false
+
+      unless @eof
+        row = []
+        @driver.data_count( @stmt.handle ).times do |column|
+          case @driver.column_type( @stmt.handle, column )
+            when Constants::ColumnType::NULL then
+              row << nil
+            when Constants::ColumnType::BLOB then
+              row << @driver.column_blob( @stmt.handle, column )
+            else
+              row << @driver.column_text( @stmt.handle, column )
+          end
+        end
+
+        if @db.type_translation
+          row = @stmt.types.zip( row ).map do |type, value|
+            @db.translator.translate( type, value )
+          end
+        end
+
+        if @db.results_as_hash
+          new_row = Hash[ *( @stmt.columns.zip( row ).flatten ) ]
+          row.each_with_index { |value,idx| new_row[idx] = value }
+          row = new_row
+        else
+          row.extend FieldsContainer unless row.respond_to?(:fields)
+          row.fields = @stmt.columns
+        end
+
+        row.extend TypesContainer
+        row.types = @stmt.types
+
+        return row
+      end
+
+      nil
+    end
+
+    # Required by the Enumerable mixin. Provides an internal iterator over the
+    # rows of the result set.
+    def each
+      while row=self.next
+        yield row
+      end
+    end
+
+    def types
+      @stmt.types
+    end
+
+    def columns
+      @stmt.columns
+    end
+
+  end
+
+end