amalgalite 1.8.0-x64-mingw-ucrt

data/lib/amalgalite/type_map.rb

@@ -0,0 +1,63 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+module Amalgalite
+  ##
+  # TypeMap defines the protocol used between Ruby and SQLite for mapping
+  # binding types, used in prepared statements; and result types, used in
+  # returning objects from a query.
+  #
+  #
+  class TypeMap
+    ##
+    # :call-seq:
+    #   map.bind_type_of( obj ) -> DataType constant
+    #
+    # bind_type_of is called during the Statement#bind process to convert the
+    # bind parameter to the appropriate SQLite types.  This method MUST return
+    # one of the valid constants in the namespace 
+    # Amalgalite::SQLite::Constants::DataType
+    #
+    def bind_type_of( obj )
+      raise NotImplementedError, "bind_type_of has not been implemented"
+    end
+
+    ##
+    # :call-seq:
+    #   map.result_value_of( declared_type, value ) -> String
+    #
+    # result_value_of is called during the result processing of column values 
+    # to convert an SQLite database value into the appropriate Ruby class.  
+    #
+    # +declared_type+ is the string from the original CREATE TABLE statment 
+    # from which the column value originates.  It may also be nil if the origin
+    # column cannot be determined.
+    #
+    # +value+ is the SQLite value from the column as either a Ruby String,
+    # Integer, Float or Amalgalite::Blob. 
+    #
+    # result_value should return the value that is to be put into the result set
+    # for the query.  It may do nothing, or it may do massive amounts of
+    # conversion. 
+    def result_value_of( delcared_type, value )
+      raise NotImplementedError, "result_value_of has not been implemented"
+    end
+  end 
+
+  ##
+  # The TypeMaps module holds all typemaps that ship with Amagalite.  They
+  # currently are:
+  #
+  # DefaultMap:: does a 'best-guess' mapping to convert as many types as
+  #              possible to known ruby classes from known SQL types.
+  # StorageMap:: converts to a limited set of classes directly based 
+  #              upon the SQLite storage types
+  # TextMap::    Everything is Text ... everything everything everything
+  #
+  module TypeMaps
+  end
+end
+require 'amalgalite/type_maps/default_map'
+require 'amalgalite/type_maps/storage_map'
+require 'amalgalite/type_maps/text_map'

data/lib/amalgalite/type_maps/default_map.rb

@@ -0,0 +1,166 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'time'
+require 'date'
+
+module Amalgalite::TypeMaps
+  ##
+  # An Amalgalite::TypeMap that does its best to convert between Ruby classes
+  # and known SQL data types.  
+  #
+  # Upon instantiation, DefaultMap generates a conversion map to try to figure
+  # out the best way to convert between populate SQL 'types' and ruby classes
+  #
+  class DefaultMap
+    class << self
+      def methods_handling_sql_types # :nodoc:
+        @methods_handling_sql_types ||= {
+          'date'      => %w[ date ],
+          'datetime'  => %w[ datetime ],
+          'time'      => %w[ timestamp time ],
+          'float'     => %w[ double float real numeric decimal ],
+          'integer'   => %w[ integer tinyint smallint int int2 int4 int8 bigint serial bigserial ],
+          'string'    => %w[ text char string varchar character json ],
+          'boolean'   => %w[ bool boolean ],
+          'blob'      => %w[ binary blob ],
+        }
+      end
+
+      # say what method to call to convert an sql type to a ruby type
+      #
+      def sql_to_method( sql_type  ) # :nodoc:
+        unless defined? @sql_to_method
+          @sql_to_method = {}
+          methods_handling_sql_types.each_pair do |method, sql_types|
+            sql_types.each { |t| @sql_to_method[t] = method }
+          end
+        end
+        return_method = @sql_to_method[sql_type]
+
+        # the straight lookup didn't work, try iterating through the types and
+        # see what is found
+        unless return_method
+          @sql_to_method.each_pair do |sql, method|
+            if sql_type.index(sql) then
+              return_method = method
+              break
+            end
+          end
+        end
+        return return_method
+      end
+    end
+
+    def initialize
+    end
+
+    ##
+    # A straight logical mapping (for me at least) of basic Ruby classes to SQLite types, if
+    # nothing can be found then default to TEXT.
+    #
+    def bind_type_of( obj )
+      case obj
+      when Float
+        ::Amalgalite::SQLite3::Constants::DataType::FLOAT
+      when Integer
+        ::Amalgalite::SQLite3::Constants::DataType::INTEGER
+      when NilClass
+        ::Amalgalite::SQLite3::Constants::DataType::NULL
+      when ::Amalgalite::Blob
+        ::Amalgalite::SQLite3::Constants::DataType::BLOB
+      else
+        ::Amalgalite::SQLite3::Constants::DataType::TEXT
+      end
+    end
+
+    ##
+    # Map the incoming value to an outgoing value.  For some incoming values,
+    # there will be no change, but for some (i.e. Dates and Times) there is some
+    # conversion
+    #
+    def result_value_of( declared_type, value )
+      case value
+      when Numeric
+        return value
+      when NilClass
+        return value
+      when Amalgalite::Blob
+        return value
+      when String
+        if declared_type then
+          conversion_method = DefaultMap.sql_to_method( declared_type.downcase )
+          if conversion_method then
+            return send(conversion_method, value)  
+          else
+            raise ::Amalgalite::Error, "Unable to convert SQL type of #{declared_type} to a Ruby class"
+          end
+        else
+          # unable to do any other conversion, just return what we have.
+          return value
+        end
+      else 
+        raise ::Amalgalite::Error, "Unable to convert a class #{value.class.name} with value #{value.inspect}"
+      end
+    end
+
+    ##
+    # convert a string to a date
+    #
+    def date( str )
+      Date.parse( str )
+    end
+
+    ##
+    # convert a string to a datetime, if no timzone is found in the parsed
+    # string, set it to the local offset.  
+    #
+    def datetime( str )
+      DateTime.parse( str )
+    end
+
+    ##
+    # convert a string to a Time
+    #
+    def time( str )
+      Time.parse( str )
+    end
+
+    ##
+    # convert a string to a Float
+    #
+    def float( str )
+      Float( str )
+    end
+
+    ##
+    # convert an string to an Integer
+    #
+    def integer( str )
+      Float( str ).to_i
+    end
+
+    ##
+    # convert a string to a String, yes redundant I know.
+    # 
+    def string( str )
+      str
+    end
+
+    ##
+    # convert a string to true of false
+    #
+    def boolean( str )
+      ::Amalgalite::Boolean.to_bool( str )
+    end
+
+    ##
+    # convert a string to a blob
+    #
+    def blob( str )
+      ::Amalgalite::Blob.new( :string => str )
+    end
+  end
+end

data/lib/amalgalite/type_maps/storage_map.rb

@@ -0,0 +1,38 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+module Amalgalite::TypeMaps
+  ##
+  # An Amalagliate TypeMap that has a one-to-one conversion between SQLite types
+  # and Ruby classes
+  #
+  class StorageMap < ::Amalgalite::TypeMap
+    ##
+    # A straight logical mapping (for me at least) of basic Ruby classes to SQLite types, if
+    # nothing can be found then default to TEXT.
+    #
+    def bind_type_of( obj )
+      case obj
+      when Float
+        ::Amalgalite::SQLite3::Constants::DataType::FLOAT
+      when Integer
+        ::Amalgalite::SQLite3::Constants::DataType::INTEGER
+      when NilClass
+        ::Amalgalite::SQLite3::Constants::DataType::NULL
+      when ::Amalgalite::Blob
+        ::Amalgalite::SQLite3::Constants::DataType::BLOB
+      else
+        ::Amalgalite::SQLite3::Constants::DataType::TEXT
+      end
+    end
+
+    ##
+    # Do no mapping, just return the value as it was retrieved from SQLite.
+    #
+    def result_value_of( delcared_type, value )
+      return value
+    end
+  end
+end

data/lib/amalgalite/type_maps/text_map.rb

@@ -0,0 +1,21 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+#
+
+module Amalgalite::TypeMaps
+  ##
+  # An Amalagliate TypeMap that converts both bind parameters and result
+  # parameters to a String, no matter what.
+  #
+  class TextMap < ::Amalgalite::TypeMap
+    def bind_type_of( obj )
+      return ::Amalgalite::SQLite3::Constants::DataType::TEXT
+    end
+
+    def result_value_of( delcared_type, value )
+      return value.to_s
+    end
+  end
+end

data/lib/amalgalite/version.rb

@@ -0,0 +1,8 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for licensing details
+#++
+
+module Amalgalite
+  VERSION = "1.8.0"
+end

data/lib/amalgalite/view.rb

@@ -0,0 +1,26 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+module Amalgalite
+  #
+  # a class representing the meta information about an SQLite view
+  #
+  class View
+    # the schame this view is assciated with
+    attr_accessor :schema
+
+    # the table name
+    attr_reader   :name
+
+    # the original sql that was used to create this table
+    attr_reader   :sql
+
+    def initialize( name, sql ) 
+      @name    = name
+      @sql     = sql
+    end
+  end
+end
+

data/lib/amalgalite.rb

@@ -0,0 +1,51 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+# check if sqlite3 has already been required.  Amalgalite conflicts with system
+# level sqlite3 libraries.
+unless $LOADED_FEATURES.grep( /\Asqlite3/ ).empty? then
+  raise LoadError, "amalgalite conflicts with sqlite3, please choose one or the other."
+end
+
+module Amalgalite
+  # 
+  # Base class of all errors in Amalgalite
+  #
+  class Error < ::StandardError; end
+end
+
+# 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'
+require 'amalgalite/boolean'
+require 'amalgalite/busy_timeout'
+require 'amalgalite/column'
+require 'amalgalite/database'
+require 'amalgalite/function'
+require 'amalgalite/index'
+require 'amalgalite/memory_database'
+require 'amalgalite/paths'
+require 'amalgalite/profile_tap'
+require 'amalgalite/progress_handler'
+require 'amalgalite/schema'
+require 'amalgalite/sqlite3'
+require 'amalgalite/statement'
+require 'amalgalite/table'
+require 'amalgalite/taps'
+require 'amalgalite/trace_tap'
+require 'amalgalite/type_map'
+require 'amalgalite/version'
+require 'amalgalite/view'

data/spec/aggregate_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+class AggregateTest1 < ::Amalgalite::Aggregate
+  def initialize
+    super
+    @name = 'atest1'
+    @arity = -1
+    @count = 0
+  end
+  def step( *args )
+    @count += 1
+  end
+  def finalize
+    return @count
+  end
+end
+
+
+describe "Aggregate SQL Functions" do
+
+  it "must have a finalize method implemented" do
+    ag = ::Amalgalite::Aggregate.new
+    lambda { ag.finalize }.should raise_error( NotImplementedError, /Aggregate#finalize must be implemented/ )
+  end
+
+  it "can define a custom SQL aggregate as a class with N params" do
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
+  end
+
+  it "can remove a custom SQL aggregate by class" do
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    @iso_db.aggregates.size.should eql(1)
+    r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
+    @iso_db.remove_aggregate( "atest1", AggregateTest1 )
+    @iso_db.aggregates.size.should eql(0)
+    lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
+  end
+
+  it "can remove a custom SQL aggregate by arity" do
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    @iso_db.aggregates.size.should eql(1)
+    r = @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country")
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
+    @iso_db.remove_aggregate( "atest1", -1)
+    @iso_db.aggregates.size.should eql(0)
+    lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
+  end
+
+  it "can remove all custom SQL aggregates with the same name" do
+    class AT2 < AggregateTest1
+      def arity() 1; end
+    end
+    @iso_db.define_aggregate("atest1", AggregateTest1 )
+    @iso_db.define_aggregate("atest1", AT2)
+    @iso_db.aggregates.size.should eql(2)
+    r = @iso_db.execute("SELECT atest1(id,name) as a, atest1(id), count(*) as c FROM country")
+    r.first['a'].should eql(r.first['c'])
+    r.first['a'].should eql(242)
+    @iso_db.remove_aggregate( "atest1" )
+    @iso_db.aggregates.size.should eql(0)
+    lambda{ @iso_db.execute("SELECT atest1(id,name) as a, count(*) as c FROM country") }.should raise_error(::Amalgalite::SQLite3::Error, /no such function: atest1/ )
+  end
+
+
+
+  it "does not allow mixing of arbitrary and mandatory arguments to an SQL function" do
+    class AggregateTest2 < AggregateTest1
+      def name() "atest2"; end
+      def arity() -2; end
+    end
+    lambda { @iso_db.define_aggregate("atest2", AggregateTest2 ) }.should raise_error( ::Amalgalite::Database::AggregateError, 
+                                                    /Use only mandatory or arbitrary parameters in an SQL Aggregate, not both/ )
+  end
+
+  it "does not allow outrageous arity" do
+    class AggregateTest3 < AggregateTest1
+      def name() "atest3"; end
+      def arity() 128; end
+    end
+    lambda { @iso_db.define_aggregate("atest3", AggregateTest3 ) }.should raise_error( ::Amalgalite::SQLite3::Error, /SQLITE_ERROR .* Library used incorrectly/ )
+  end
+
+  it "does not allow registering a function which does not match the defined name " do
+    class AggregateTest4 < AggregateTest1
+      def name() "name_mismatch"; end
+    end
+    lambda { @iso_db.define_aggregate("atest4", AggregateTest4 ) }.should raise_error( ::Amalgalite::Database::AggregateError,
+                                           /Aggregate implementation name 'name_mismatch' does not match defined name 'atest4'/)
+  end
+
+  it "handles an error being thrown during the step function" do
+    class AggregateTest5 < AggregateTest1
+      def initialize
+        super
+        @name = "atest5"
+        @arity = -1
+        @count = 0
+      end
+
+      def step( *args )
+        @count += 1
+        if @count > 50 then
+          raise "Stepwise error!" if @count > 50
+        end
+      end
+
+    end
+
+    @iso_db.define_aggregate( "atest5", AggregateTest5 )
+    lambda { @iso_db.execute( "SELECT atest5(*) AS a FROM country" ) }.should raise_error( ::Amalgalite::SQLite3::Error, /Stepwise error!/ )
+  end
+
+  it "handles an error being thrown during the finalize function" do
+    class AggregateTest6 < AggregateTest1
+      def initialize
+        super
+        @name = "atest6"
+        @count = 0
+        @arity = -1
+      end
+      def finalize
+        raise "Finalize error!"
+      end
+    end
+    @iso_db.define_aggregate( "atest6", AggregateTest6 )
+    lambda { @iso_db.execute( "SELECT atest6(*) AS a FROM country" ) }.should raise_error( ::Amalgalite::SQLite3::Error, /Finalize error!/ )
+  end
+
+  it "handles an error being thrown during initialization in the C extension" do
+    class AggregateTest7 < AggregateTest1
+      @called = false
+      def self.called?
+        if @called then
+          raise "Initialization error!"
+        else
+          @called = true
+        end
+      end
+
+      def initialize
+        super
+        @name = "atest7"
+        @count = 0
+        @arity = -1
+        self.class.called?
+      end
+    end
+    @iso_db.define_aggregate( "atest7", AggregateTest7 )
+    lambda { @iso_db.execute( "SELECT atest7(*) AS a FROM country" ) }.should raise_error( ::Amalgalite::SQLite3::Error, /Initialization error!/ )
+  end
+end
+

data/spec/amalgalite_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Amalgalite do
+end

data/spec/blob_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Amalgalite::Blob do
+
+  before(:each) do
+    @blob_db_name = File.join(File.dirname( __FILE__ ), "blob.db")
+    File.unlink @blob_db_name if File.exist?( @blob_db_name )
+    @db = Amalgalite::Database.new( @blob_db_name )
+    @schema_sql = <<-SQL
+      CREATE TABLE blobs(
+        id      INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+        name    VARCHAR(128) NOT NULL UNIQUE,
+        data    TEXT ); 
+    SQL
+    @db.execute( @schema_sql )
+    @country_data_file = Amalgalite::Iso3166Database.country_data_file
+    @junk_file = File.join( File.dirname(__FILE__), "test_output")
+  end
+
+  after(:each) do
+    @db.close
+    File.unlink @blob_db_name if File.exist?( @blob_db_name )
+    File.unlink @junk_file    if File.exist?( @junk_file )
+  end
+
+  { :file   => Amalgalite::Iso3166Database.country_data_file,
+    :string => IO.read( Amalgalite::Iso3166Database.country_data_file),
+    :io     => StringIO.new( IO.read( Amalgalite::Iso3166Database.country_data_file) ) }.each_pair do |style, data |
+    describe "inserts a blob from a #{style}" do
+      before(:each) do
+        column = @db.schema.tables['blobs'].columns['data']
+        @db.execute("INSERT INTO blobs(name, data) VALUES ($name, $data)",
+                    { "$name" => @country_data_file,
+                      "$data" => Amalgalite::Blob.new( style => data,
+                                                      :column => column ) } )
+        @db.execute("VACUUM")
+      end
+
+      after(:each) do
+        @db.execute("DELETE FROM blobs")
+        data.rewind if data.respond_to?( :rewind )
+      end
+
+      it "and retrieves the data as a single value" do
+        all_rows = @db.execute("SELECT name,data FROM blobs")
+        all_rows.size.should eql(1)
+        all_rows.first['name'].should eql(@country_data_file)
+        all_rows.first['data'].should_not be_incremental
+        all_rows.first['data'].to_string_io.string.should eql(IO.read( @country_data_file ))
+      end
+
+      it "and retrieves the data using incremental IO" do
+        all_rows = @db.execute("SELECT * FROM blobs")
+        all_rows.size.should eql(1)
+        all_rows.first['name'].should eql(@country_data_file)
+        all_rows.first['data'].should be_incremental
+        all_rows.first['data'].to_string_io.string.should eql(IO.read( @country_data_file ))
+      end
+
+      it "writes the data to a file " do
+        all_rows = @db.execute("SELECT * FROM blobs")
+        all_rows.size.should eql(1)
+        all_rows.first['name'].should eql(@country_data_file)
+        all_rows.first['data'].should be_incremental
+        all_rows.first['data'].write_to_file( @junk_file )
+        IO.read( @junk_file).should eql(IO.read( @country_data_file ))
+      end
+    end
+  end
+
+
+
+  it "raises an error if initialized incorrectly" do
+    lambda{ Amalgalite::Blob.new( :file => "/dev/null", :string => "foo" ) }.should raise_error( Amalgalite::Blob::Error )
+  end
+end
+
+

data/spec/boolean_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+require 'amalgalite'
+require 'amalgalite/boolean'
+
+describe Amalgalite::Boolean do
+  %w[ True Y Yes T 1 ].each do |v|
+    it "converts #{v} to true" do
+      Amalgalite::Boolean.to_bool(v).should == true
+    end
+  end
+
+  %w[ False F f No n 0 ].each do |v|
+    it "converts #{v} to false " do
+      Amalgalite::Boolean.to_bool(v).should == false
+    end
+  end
+
+  %w[ other things nil ].each do |v|
+    it "converts #{v} to nil" do
+      Amalgalite::Boolean.to_bool(v).should == nil
+    end
+  end
+end