sqlite3 0.0.2 → 0.0.3

data/Rakefile

@@ -16,12 +16,15 @@ begin
     gem.add_development_dependency "test-unit", ">= 2.0"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
     gem.post_install_message = <<-EOM
-
-WARNING!
-
+==== WARNING ===================================================================
 This is an early alpha version of SQLite3/Ruby FFI bindings!
-If you need native, production ready bindings install sqlite3-ruby instead.
+Currently we support Ruby 1.9 ONLY.
+
+If you need native bindings for Ruby 1.8 - install sqlite3-ruby instead.
+You may need to uninstall this sqlite3 gem as well.
 
+Thank you for installing sqlite3 gem! Suggestions: qoobaa@gmail.com
+================================================================================
 EOM
   end
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/sqlite3.rb

@@ -1 +1,16 @@
+# start (required by translator)
+require "time"
+require "date"
+# end
+
+require "ffi"
+
+require "sqlite3/constants"
+require "sqlite3/errors"
+require "sqlite3/pragmas"
+require "sqlite3/statement"
+require "sqlite3/translator"
+require "sqlite3/resultset"
+require "sqlite3/value"
+require "sqlite3/encoding"
 require "sqlite3/database"

data/lib/sqlite3/database.rb

@@ -1,10 +1,3 @@
-require "sqlite3/constants"
-require "sqlite3/errors"
-require "sqlite3/pragmas"
-require "sqlite3/statement"
-require "sqlite3/translator"
-require "sqlite3/value"
-
 module SQLite3
 
   # The Database class encapsulates a single connection to a SQLite3 database.
@@ -64,38 +57,41 @@ module SQLite3
     # database.
     attr_accessor :type_translation
 
+    # Encoding used to comunicate with database.
+    attr_reader :encoding
+
     # Create a new Database object that opens the given file. If utf16
     # is +true+, the filename is interpreted as a UTF-16 encoded string.
     #
     # By default, the new database will return result rows as arrays
     # (#results_as_hash) and has type translation disabled (#type_translation=).
     def initialize(file_name, options = {})
-      utf16 = options.fetch(:utf16, false)
+      @encoding = Encoding.find(options.fetch(:encoding, "utf-8"))
+
       load_driver(options[:driver])
 
       @statement_factory = options[:statement_factory] || Statement
 
-      result, @handle = @driver.open(file_name, utf16)
+      result, @handle = @driver.open(file_name, Encoding.utf_16?(@encoding))
       Error.check(result, self, "could not open database")
 
       @closed = false
-      @results_as_hash = options.fetch(:results_as_hash,false)
-      @type_translation = options.fetch(:type_translation,false)
+      @results_as_hash = options.fetch(:results_as_hash, false)
+      @type_translation = options.fetch(:type_translation, false)
       @translator = nil
       @transaction_active = false
     end
 
     # Return +true+ if the string is a valid (ie, parsable) SQL statement, and
-    # +false+ otherwise. If +utf16+ is +true+, then the string is a UTF-16
-    # character string.
-    def complete?(string, utf16 = false)
-      @driver.complete?(string, utf16)
+    # +false+ otherwise
+    def complete?(string)
+      @driver.complete?(string)
     end
 
     # Return a string describing the last error to have occurred with this
     # database.
-    def errmsg(utf16 = false)
-      @driver.errmsg(@handle, utf16)
+    def errmsg
+      @driver.errmsg(@handle)
     end
 
     # Return an integer representing the last error to have occurred with this
@@ -128,30 +124,13 @@ module SQLite3
       @closed
     end
 
-    # Installs (or removes) a block that will be invoked for every SQL
-    # statement executed. The block receives a two parameters: the +data+
-    # argument, and the SQL statement executed. If the block is +nil+,
-    # any existing tracer will be uninstalled.
-    def trace(data = nil, &block)
-      @driver.trace(@handle, data, &block)
-    end
-
-    # Installs (or removes) a block that will be invoked for every access
-    # to the database. If the block returns 0 (or +nil+), the statement
-    # is allowed to proceed. Returning 1 causes an authorization error to
-    # occur, and returning 2 causes the access to be silently denied.
-    def authorizer(data = nil, &block)
-      result = @driver.set_authorizer(@handle, data, &block)
-      Error.check(result, self)
-    end
-
     # Returns a Statement object representing the given SQL. This does not
     # execute the statement; it merely prepares the statement for execution.
     #
     # The Statement can then be executed using Statement#execute.
     #
     def prepare(sql)
-      stmt = @statement_factory.new(self, sql)
+      stmt = @statement_factory.new(self, sql, Encoding.utf_16?(@encoding))
       if block_given?
         begin
           yield stmt
@@ -296,20 +275,6 @@ module SQLite3
       @driver.interrupt(@handle)
     end
 
-    # Register a busy handler with this database instance. When a requested
-    # resource is busy, this handler will be invoked. If the handler returns
-    # +false+, the operation will be aborted; otherwise, the resource will
-    # be requested again.
-    #
-    # The handler will be invoked with the name of the resource that was
-    # busy, and the number of times it has been retried.
-    #
-    # See also the mutually exclusive #busy_timeout.
-    def busy_handler(data = nil, &block) # :yields: data, retries
-      result = @driver.busy_handler(@handle, data, &block)
-      Error.check(result, self)
-    end
-
     # Indicates that if a request for a resource terminates because that
     # resource is busy, SQLite should sleep and retry for up to the indicated
     # number of milliseconds. By default, SQLite does not retry
@@ -322,210 +287,6 @@ module SQLite3
       Error.check(result, self)
     end
 
-    # Creates a new function for use in SQL statements. It will be added as
-    # +name+, with the given +arity+. (For variable arity functions, use
-    # -1 for the arity.)
-    #
-    # The block should accept at least one parameter--the FunctionProxy
-    # instance that wraps this function invocation--and any other
-    # arguments it needs (up to its arity).
-    #
-    # The block does not return a value directly. Instead, it will invoke
-    # the FunctionProxy#set_result method on the +func+ parameter and
-    # indicate the return value that way.
-    #
-    # Example:
-    #
-    #   db.create_function("maim", 1) do |func, value|
-    #     if value.nil?
-    #       func.result = nil
-    #     else
-    #       func.result = value.split(//).sort.join
-    #     end
-    #   end
-    #
-    #   puts db.get_first_value("select maim(name) from table")
-    def create_function(name, arity, text_rep = Constants::TextRep::ANY, &block) # :yields: func, *args
-      # begin
-      callback = proc do |func, *args|
-        begin
-          block.call(FunctionProxy.new(@driver, func), *args.map { |v| Value.new(self, v) })
-        rescue StandardError, Exception => e
-          @driver.result_error(func, "#{e.message} (#{e.class})", -1)
-        end
-      end
-
-      result = @driver.create_function(@handle, name, arity, text_rep, nil, callback, nil, nil)
-      Error.check(result, self)
-
-      self
-    end
-
-    # Creates a new aggregate function for use in SQL statements. Aggregate
-    # functions are functions that apply over every row in the result set,
-    # instead of over just a single row. (A very common aggregate function
-    # is the "count" function, for determining the number of rows that match
-    # a query.)
-    #
-    # The new function will be added as +name+, with the given +arity+. (For
-    # variable arity functions, use -1 for the arity.)
-    #
-    # The +step+ parameter must be a proc object that accepts as its first
-    # parameter a FunctionProxy instance (representing the function
-    # invocation), with any subsequent parameters (up to the function's arity).
-    # The +step+ callback will be invoked once for each row of the result set.
-    #
-    # The +finalize+ parameter must be a +proc+ object that accepts only a
-    # single parameter, the FunctionProxy instance representing the current
-    # function invocation. It should invoke FunctionProxy#set_result to
-    # store the result of the function.
-    #
-    # Example:
-    #
-    #   db.create_aggregate("lengths", 1) do
-    #     step do |func, value|
-    #       func[:total] ||= 0
-    #       func[:total] += (value ? value.length : 0)
-    #     end
-    #
-    #     finalize do |func|
-    #       func.set_result(func[:total] || 0)
-    #     end
-    #   end
-    #
-    #   puts db.get_first_value("select lengths(name) from table")
-    #
-    # See also #create_aggregate_handler for a more object-oriented approach to
-    # aggregate functions.
-    def create_aggregate(name, arity, step = nil, finalize = nil, text_rep = Constants::TextRep::ANY, &block)
-      # begin
-      if block
-        proxy = AggregateDefinitionProxy.new
-        proxy.instance_eval(&block)
-        step ||= proxy.step_callback
-        finalize ||= proxy.finalize_callback
-      end
-
-      step_callback = proc do |func, *args|
-        ctx = @driver.aggregate_context(func)
-        unless ctx[:__error]
-          begin
-            step.call(FunctionProxy.new(@driver, func, ctx), *args.map { |v| Value.new(self, v) })
-          rescue Exception => e
-            ctx[:__error] = e
-          end
-        end
-      end
-
-      finalize_callback = proc do |func|
-        ctx = @driver.aggregate_context(func)
-        unless ctx[:__error]
-          begin
-            finalize.call(FunctionProxy.new(@driver, func, ctx))
-          rescue Exception => e
-            @driver.result_error(func, "#{e.message} (#{e.class})", -1)
-          end
-        else
-          e = ctx[:__error]
-          @driver.result_error(func, "#{e.message} (#{e.class})", -1)
-        end
-      end
-
-      result = @driver.create_function(@handle, name, arity, text_rep, nil, nil, step_callback, finalize_callback)
-      Error.check(result, self)
-
-      self
-    end
-
-    # This is another approach to creating an aggregate function (see
-    # #create_aggregate). Instead of explicitly specifying the name,
-    # callbacks, arity, and type, you specify a factory object
-    # (the "handler") that knows how to obtain all of that information. The
-    # handler should respond to the following messages:
-    #
-    # +arity+:: corresponds to the +arity+ parameter of #create_aggregate. This
-    #           message is optional, and if the handler does not respond to it,
-    #           the function will have an arity of -1.
-    # +name+:: this is the name of the function. The handler _must_ implement
-    #          this message.
-    # +new+:: this must be implemented by the handler. It should return a new
-    #         instance of the object that will handle a specific invocation of
-    #         the function.
-    #
-    # The handler instance (the object returned by the +new+ message, described
-    # above), must respond to the following messages:
-    #
-    # +step+:: this is the method that will be called for each step of the
-    #          aggregate function's evaluation. It should implement the same
-    #          signature as the +step+ callback for #create_aggregate.
-    # +finalize+:: this is the method that will be called to finalize the
-    #              aggregate function's evaluation. It should implement the
-    #              same signature as the +finalize+ callback for
-    #              #create_aggregate.
-    #
-    # Example:
-    #
-    #   class LengthsAggregateHandler
-    #     def self.arity; 1; end
-    #
-    #     def initialize
-    #       @total = 0
-    #     end
-    #
-    #     def step(ctx, name)
-    #       @total += (name ? name.length : 0)
-    #     end
-    #
-    #     def finalize(ctx)
-    #       ctx.set_result(@total)
-    #     end
-    #   end
-    #
-    #   db.create_aggregate_handler(LengthsAggregateHandler)
-    #   puts db.get_first_value("select lengths(name) from A")
-    def create_aggregate_handler(handler)
-      arity = -1
-      text_rep = Constants::TextRep::ANY
-
-      arity = handler.arity if handler.respond_to?(:arity)
-      text_rep = handler.text_rep if handler.respond_to?(:text_rep)
-      name = handler.name
-
-      step = proc do |func,*args|
-        ctx = @driver.aggregate_context(func)
-        unless ctx[:__error]
-          ctx[:handler] ||= handler.new
-          begin
-            ctx[:handler].step(FunctionProxy.new(@driver, func, ctx), *args.map{|v| Value.new(self,v)})
-          rescue Exception, StandardError => e
-            ctx[:__error] = e
-          end
-        end
-      end
-
-      finalize = proc do |func|
-        ctx = @driver.aggregate_context(func)
-        unless ctx[:__error]
-          ctx[:handler] ||= handler.new
-          begin
-            ctx[:handler].finalize(FunctionProxy.new(@driver, func, ctx))
-          rescue Exception => e
-            ctx[:__error] = e
-          end
-        end
-
-        if ctx[:__error]
-          e = ctx[:__error]
-          @driver.sqlite3_result_error(func, "#{e.message} (#{e.class})", -1)
-        end
-      end
-
-      result = @driver.create_function(@handle, name, arity, text_rep, nil, nil, step, finalize)
-      Error.check(result, self)
-
-      self
-    end
-
     # Begins a new transaction. Note that nested transactions are not allowed
     # by SQLite, so attempting to nest a transaction will result in a runtime
     # exception.
@@ -586,6 +347,8 @@ module SQLite3
       @transaction_active
     end
 
+    private
+
     # Loads the corresponding driver, or if it is nil, attempts to locate a
     # suitable driver.
     def load_driver(driver)
@@ -611,93 +374,7 @@ module SQLite3
 
       @driver = driver.new
     end
-    private :load_driver
-
-    # A helper class for dealing with custom functions (see #create_function,
-    # #create_aggregate, and #create_aggregate_handler). It encapsulates the
-    # opaque function object that represents the current invocation. It also
-    # provides more convenient access to the API functions that operate on
-    # the function object.
-    #
-    # This class will almost _always_ be instantiated indirectly, by working
-    # with the create methods mentioned above.
-    class FunctionProxy
-
-      # Create a new FunctionProxy that encapsulates the given +func+ object.
-      # If context is non-nil, the functions context will be set to that. If
-      # it is non-nil, it must quack like a Hash. If it is nil, then none of
-      # the context functions will be available.
-      def initialize(driver, func, context = nil)
-        @driver = driver
-        @func = func
-        @context = context
-      end
-
-      # Calls #set_result to set the result of this function.
-      def result=(result)
-        set_result(result)
-      end
-
-      # Set the result of the function to the given value. The function will
-      # then return this value.
-      def set_result(result, utf16 = false)
-        @driver.result_text(@func, result, utf16)
-      end
-
-      # Set the result of the function to the given error message.
-      # The function will then return that error.
-      def set_error(error)
-        @driver.result_error(@func, error.to_s, -1)
-      end
-
-      # (Only available to aggregate functions.) Returns the number of rows
-      # that the aggregate has processed so far. This will include the current
-      # row, and so will always return at least 1.
-      def count
-        ensure_aggregate!
-        @driver.aggregate_count(@func)
-      end
-
-      # Returns the value with the given key from the context. This is only
-      # available to aggregate functions.
-      def [](key)
-        ensure_aggregate!
-        @context[key]
-      end
-
-      # Sets the value with the given key in the context. This is only
-      # available to aggregate functions.
-      def []=(key, value)
-        ensure_aggregate!
-        @context[key] = value
-      end
-
-      # A function for performing a sanity check, to ensure that the function
-      # being invoked is an aggregate function. This is implied by the
-      # existence of the context variable.
-      def ensure_aggregate!
-        unless @context
-          raise MisuseException, "function is not an aggregate"
-        end
-      end
-      private :ensure_aggregate!
-
-    end
-
-    # A proxy used for defining the callbacks to an aggregate function.
-    class AggregateDefinitionProxy # :nodoc:
-      attr_reader :step_callback, :finalize_callback
-
-      def step(&block)
-        @step_callback = block
-      end
-
-      def finalize(&block)
-        @finalize_callback = block
-      end
-    end
 
   end
-
 end