amalgalite 1.6.0-x64-mingw32

data/spec/sqlite3/status_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'amalgalite/sqlite3'
+require 'rbconfig'
+
+describe "Amalgalite::SQLite3::Status" do
+  it "knows how much memory it has used" do
+    Amalgalite::SQLite3.status.memory_used.current.should be >= 0
+    Amalgalite::SQLite3.status.memory_used.highwater.should be >= 0
+  end
+
+  it "can reset the highwater value" do
+    before = Amalgalite::SQLite3.status.memory_used.highwater
+    before.should be > 0
+
+    current = Amalgalite::SQLite3.status.memory_used.current
+    Amalgalite::SQLite3.status.memory_used.reset!
+    Amalgalite::SQLite3.status.memory_used.highwater.should be == current
+
+    after = Amalgalite::SQLite3.status.memory_used.highwater
+    after.should_not eql(before)
+  end
+end

data/spec/sqlite3/version_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'amalgalite/sqlite3/version'
+
+describe "Amalgalite::SQLite3::Version" do
+  it "should have the sqlite3 version" do
+    expect(Amalgalite::SQLite3::VERSION).to match(/\d+\.\d+\.\d+/)
+    expect(Amalgalite::SQLite3::Version.to_s).to match( /\d+\.\d+\.\d+/ )
+    expect(Amalgalite::SQLite3::Version.runtime_version).to match( /\d+\.\d+\.\d+/ )
+
+    Amalgalite::SQLite3::Version.to_i.should eql(3021000)
+    Amalgalite::SQLite3::Version.runtime_version_number.should eql(3021000)
+
+    Amalgalite::SQLite3::Version::MAJOR.should eql(3)
+    Amalgalite::SQLite3::Version::MINOR.should eql(21)
+    Amalgalite::SQLite3::Version::RELEASE.should eql(0)
+    expect(Amalgalite::SQLite3::Version.to_a.size).to eql(3)
+
+    Amalgalite::SQLite3::Version.compiled_version.should be == "3.21.0"
+    Amalgalite::SQLite3::Version.compiled_version_number.should be == 3021000
+    Amalgalite::SQLite3::Version.compiled_matches_runtime?.should be == true
+  end
+
+  it "should have the sqlite3 source id" do
+    source_id = "2017-10-24 18:55:49 1a584e499906b5c87ec7d43d4abce641fdf017c42125b083109bc77c4de48827"
+    Amalgalite::SQLite3::Version.compiled_source_id.should be == source_id
+    Amalgalite::SQLite3::Version.runtime_source_id.should be == source_id
+  end
+end

data/spec/sqlite3_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'amalgalite/sqlite3'
+require 'rbconfig'
+
+describe "Amalgalite::SQLite3" do
+  it "is threadsafe is ruby is compiled with pthread support, in this case that is (#{RbConfig::CONFIG['configure_args'].include?( "--enable-pthread" )})" do
+    Amalgalite::SQLite3.threadsafe?.should eql(RbConfig::CONFIG['configure_args'].include?( "--enable-pthread" ))
+  end
+
+  it "knows if an SQL statement is complete" do
+    Amalgalite::SQLite3.complete?("SELECT * FROM sometable;").should eql(true)
+    #Amalgalite::SQLite3.complete?("SELECT * FROM sometable;", :utf16 => true).should eql(true)
+  end
+  
+  it "knows if an SQL statement is not complete" do
+    Amalgalite::SQLite3.complete?("SELECT * FROM sometable ").should eql(false)
+    #Amalgalite::SQLite3.complete?("SELECT * FROM sometable WHERE ", :utf16 => true).should eql(false)
+  end
+
+  it "can produce random data" do
+    Amalgalite::SQLite3.randomness( 42 ).size.should eql(42)
+  end
+
+  it "has nil for the default sqlite temporary directory" do
+    Amalgalite::SQLite3.temp_directory.should eql(nil)
+  end
+
+  it "can set the temporary directory" do
+    Amalgalite::SQLite3.temp_directory.should eql(nil)
+    Amalgalite::SQLite3.temp_directory = "/tmp/testing"
+    Amalgalite::SQLite3.temp_directory.should eql("/tmp/testing")
+    Amalgalite::SQLite3.temp_directory = nil
+    Amalgalite::SQLite3.temp_directory.should eql(nil)
+  end
+
+  it "can escape quoted strings" do
+    Amalgalite::SQLite3.escape( "It's a happy day!" ).should eql("It''s a happy day!")
+  end
+
+  it "can escape a symble into a string" do
+    Amalgalite::SQLite3.escape( :stuff ).should eql("stuff")
+    Amalgalite::SQLite3.escape( :"stuff'n" ).should eql("stuff''n")
+  end
+
+  it "can quote and escape single quoted strings" do
+    Amalgalite::SQLite3.quote( "It's a happy day!" ).should eql("'It''s a happy day!'")
+  end
+
+  it "can quote and escape symbols" do
+    Amalgalite::SQLite3.quote( :stuff ).should eql("'stuff'")
+    Amalgalite::SQLite3.quote( :"stuff'n" ).should eql("'stuff''n'")
+  end
+end

data/spec/statement_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe Amalgalite::Statement do
+  before(:each) do
+    @db = Amalgalite::Database.new( SpecInfo.test_db )
+  end
+
+  after(:each) do
+    @db.close
+  end
+
+  it "a statement has a copy of the sql it was prepared with" do
+    stmt = @db.prepare( "SELECT strftime('%Y-%m-%d %H:%M:%S', 'now')")
+    stmt.sql.should eql("SELECT strftime('%Y-%m-%d %H:%M:%S', 'now')")
+    stmt.close
+  end
+
+  it "steps through results" do
+    now = Time.new.utc.strftime("%Y-%m-%d %H:%M")
+    @db.prepare( "SELECT strftime('%Y-%m-%d %H:%M', 'now') as now") do |stmt|
+      stmt.should_not eql(nil)
+      stmt.each do |row|
+        row['now'].should eql(now)
+      end
+    end
+  end
+
+  it "can prepare a statement without a block" do
+    stmt = @iso_db.prepare("SELECT * FROM country WHERE two_letter = :two") 
+    rs = stmt.execute( ":two" => "JP" )
+    rs.size.should eql(1)
+    stmt.close
+  end
+
+  it "knows how many parameters are in the statement" do
+    @iso_db.prepare("SELECT * FROM country WHERE two_letter = :two") do |stmt|
+      stmt.check_parameter_count!( 1 ).should eql(1)
+    end
+  end
+
+  it "raises an error if there are not enough parameters are passed in a statement" do
+    @iso_db.prepare("SELECT * FROM country WHERE two_letter = :two") do |stmt|
+      lambda{ stmt.execute }.should raise_error( Amalgalite::Error )
+    end
+  end
+
+
+  it "can run a query with a named parameter" do
+    @iso_db.prepare("SELECT * FROM country WHERE two_letter = :two") do |stmt|
+      all_rows = stmt.execute( ":two" => "JP" )
+      all_rows.size.should eql(1)
+      all_rows.first['name'].should eql("Japan")
+    end
+  end
+
+  it "it can execute a query with a named parameter and yield the rows" do 
+    @iso_db.prepare("SELECT * FROM country WHERE id = @id ORDER BY name") do |stmt|
+      rows = []
+      stmt.execute( "@id" => 891 ) do |row|
+        rows << row
+      end
+      rows.size.should eql(2)
+      rows.last['name'].should eql("Yugoslavia")
+      rows.first['two_letter'].should eql("CS")
+    end
+  end
+
+  it "can execute the same prepared statement multiple times" do
+    @db.execute(" CREATE TABLE t(x,y); ")
+    values = {}
+    @db.prepare("INSERT INTO t( x, y ) VALUES( $x, $y )" ) do |stmt|
+      20.times do |x|
+        y = rand( x )
+        stmt.execute( { "$x" => x, "$y" => y } )
+        values[x] = y
+      end
+    end
+    c = 0
+    @db.execute("SELECT * from t") do |row|
+      c += 1
+      values[ row['x'] ].should eql(row['y'])
+    end
+    c.should eql(20)
+  end
+
+  it "expands an array when binding parameters" do
+    @db.execute(" CREATE TABLE t(x,y); ")
+    values = {}
+    @db.prepare( "INSERT INTO t( x, y ) VALUES( ?, ? )") do |stmt|
+      20.times do |x|
+        y = rand( x )
+        a = [ x, y ]
+        stmt.execute( a )
+        values[x] = y
+      end
+    end
+    c = 0
+    @db.execute("SELECT * from t") do |row|
+      c += 1
+      values[ row['x'] ].should eql(row['y'])
+    end
+    c.should eql(20)
+ 
+  end
+
+  it "binds a integer variable correctly" do
+    @iso_db.prepare("SELECT * FROM country WHERE id = ? ORDER BY name ") do |stmt|
+      all_rows = stmt.execute( 891 )
+      all_rows.size.should eql(2)
+      all_rows.last['name'].should eql("Yugoslavia")
+      all_rows.first['two_letter'].should eql("CS")
+    end
+  end
+
+  it "raises and error if an invaliding binding is attempted" do 
+    @iso_db.prepare("SELECT * FROM country WHERE id = :somevar ORDER BY name ") do |stmt|
+      lambda{ stmt.execute( "blah" => 42 ) }.should raise_error(Amalgalite::Error)
+    end
+  end
+
+  it "can reset the statement to the state it was before executing" do
+    stmt = @iso_db.prepare("SELECT * FROM country WHERE id = :somevar ORDER BY name ") 
+    stmt.reset_and_clear_bindings!
+    stmt.close
+  end
+
+  it "can execute a single sql command and say if there is remaining sql to execute" do
+    stmt = @db.prepare( @schema )
+    stmt.execute
+    stmt.remaining_sql.size.should be > 0
+    stmt.close
+  end
+
+  it "can select the rowid from the table" do
+    db = Amalgalite::Database.new( ":memory:" )
+    db.execute( "create table t1(c1,c2,c3)" )
+    db.execute("insert into t1(c1,c2,c3) values (1,2,'abc')")
+    rows = db.execute( "select rowid,* from t1")
+    rows.size.should eql(1)
+    rows.first['rowid'].should eql(1)
+    rows.first['c1'].should eql(1 )
+    rows.first['c3'].should eql('abc')
+  end
+
+  it "shows that the rowid column is rowid column" do
+    db = Amalgalite::Database.new( ":memory:" )
+    db.execute( "create table t1(c1,c2,c3)" )
+    db.execute("insert into t1(c1,c2,c3) values (1,2,'abc')")
+    db.prepare( "select oid,* from t1" ) do |stmt|
+      stmt.execute
+      stmt.should be_using_rowid_column
+    end
+
+    db.prepare( "select * from t1" ) do  |stmt| 
+      stmt.execute
+      stmt.should_not be_using_rowid_column 
+    end
+  end
+
+  it "has index based access to the result set" do
+    @iso_db.prepare("SELECT * FROM country WHERE id = ? ORDER BY name ") do |stmt|
+      all_rows = stmt.execute( 891 )
+      all_rows.size.should eql(2)
+      all_rows.last.first.should eql("Yugoslavia")
+      all_rows.first[1].should eql("CS")
+    end
+  end
+end

data/spec/storage_map_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'amalgalite/type_maps/storage_map'
+
+describe Amalgalite::TypeMaps::StorageMap do
+  before(:each) do
+    @map = Amalgalite::TypeMaps::StorageMap.new
+  end
+
+  describe "#bind_type_of" do
+
+    it "Float is bound to DataType::FLOAT" do
+      @map.bind_type_of( 3.14 ).should == ::Amalgalite::SQLite3::Constants::DataType::FLOAT
+    end
+
+    it "Integer is bound to DataType::INTGER" do
+      @map.bind_type_of( 42 ).should == ::Amalgalite::SQLite3::Constants::DataType::INTEGER
+    end
+
+    it "nil is bound to DataType::NULL" do
+      @map.bind_type_of( nil ).should == ::Amalgalite::SQLite3::Constants::DataType::NULL
+    end
+
+    it "::Amalgalite::Blob is bound to DataType::BLOB" do
+      @map.bind_type_of( ::Amalgalite::Blob.new( :string => "testing mapping", :column => true )  ).should == ::Amalgalite::SQLite3::Constants::DataType::BLOB
+    end
+
+    it "everything else is bound to DataType::TEXT" do
+      @map.bind_type_of( "everything else" ).should == ::Amalgalite::SQLite3::Constants::DataType::TEXT
+    end
+
+  end
+
+  describe "#result_value_of" do
+    it "returns the original object for everything passed in" do
+      @map.result_value_of( "doesn't matter", 42 ).should == 42
+    end
+  end
+end

data/spec/tap_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+require 'amalgalite'
+require 'amalgalite/trace_tap'
+require 'amalgalite/profile_tap'
+require 'amalgalite/taps/console'
+require 'stringio'
+
+describe Amalgalite::TraceTap do
+  it "wraps up an object and delegates the 'trace' method to a method on that object" do
+    s = StringIO.new
+    tt = ::Amalgalite::TraceTap.new( s, 'puts' )
+    tt.trace('test trace')
+    s.string.should eql("test trace\n")
+  end
+  
+  it "raises an error if an the wrapped object does not respond to the indicated method"  do
+    lambda{ ::Amalgalite::TraceTap.new( Object.new ) }.should raise_error( Amalgalite::Error )
+  end
+end
+
+describe Amalgalite::ProfileTap do
+  it "raises an error if an the wrapped object does not respond to the indicated method"  do
+    lambda{ ::Amalgalite::ProfileTap.new( Object.new ) }.should raise_error( Amalgalite::Error )
+  end
+end
+
+describe Amalgalite::Taps::StringIO do
+  it "dumps profile information" do
+    s = ::Amalgalite::Taps::StringIO.new
+    s.profile( 'test', 42 )
+    s.dump_profile
+    s.string.should eql("42 : test\n[test] => sum: 42, sumsq: 1764, n: 1, mean: 42.000000, stddev: 0.000000, min: 42, max: 42\n")
+  end
+
+  it "has a stdout tap" do
+    ::Amalgalite::Taps::Stdout.new
+  end
+
+  it "has a stderr tap" do
+    ::Amalgalite::Taps::Stderr.new
+  end
+end
+
+describe Amalgalite::ProfileSampler do
+  it "aggregates samples" do
+    s = Amalgalite::ProfileSampler.new( 'test1' )
+    s.sample( 42 )
+    s.sample( 84 )
+    s.sample( 21 )
+    h = s.to_h
+    h['min'].should eql(21)
+    h['max'].should eql(84)
+    h['mean'].should eql(49.0)
+    h['n'].should eql(3)
+  end
+end

data/spec/text_map_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'amalgalite/type_maps/text_map'
+
+describe Amalgalite::TypeMaps::TextMap do
+  before(:each) do
+    @map = Amalgalite::TypeMaps::TextMap.new
+  end
+
+  describe "#bind_type_of" do
+    it "returnes text for everything" do
+      @map.bind_type_of( 3.14 ).should == ::Amalgalite::SQLite3::Constants::DataType::TEXT
+    end
+  end
+
+  describe "#result_value_of" do
+    it "returns the string value of the object for everything passed in" do
+      @map.result_value_of( "doesn't matter", 42 ).should == "42"
+    end
+  end
+end

data/spec/type_map_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'amalgalite/type_map'
+
+describe Amalgalite::TypeMap do
+  it "#bind_type_of raises NotImplemented error" do
+    tm = Amalgalite::TypeMap.new
+    lambda { tm.bind_type_of( Object.new ) }.should raise_error( NotImplementedError )
+  end
+
+  it "#result_value_of raises NotImplemented error" do
+    tm = Amalgalite::TypeMap.new
+    lambda { tm.result_value_of( "foo", Object.new ) }.should raise_error( NotImplementedError )
+  end
+end

data/spec/version_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'amalgalite/version'
+
+describe "Amalgalite::VERSION" do
+  it "should have a version string" do
+    expect(Amalgalite::VERSION).to match( /\d+\.\d+\.\d+/ )
+  end
+end

data/tasks/custom.rake

@@ -0,0 +1,102 @@
+#-----------------------------------------------------------------------
+# Custom tasks for this project
+#-----------------------------------------------------------------------
+require 'pathname'
+namespace :util do
+  desc "List the sqlite api calls that are not implemented"
+  task :todo do
+
+    not_implementing = %w[
+      sqlite3_exec
+      sqlite3_open
+      sqlite3_os_end
+      sqlite3_os_init
+      sqlite3_malloc
+      sqlite3_realloc
+      sqlite3_free
+      sqlite3_get_table
+      sqlite3_free_table
+      sqlite3_key
+      sqlite3_rekey
+      sqlite3_next_stmt
+      sqlite3_release_memory
+      sqlite3_sleep
+      sqlite3_snprintf
+      sqlite3_vmprintf
+      sqlite3_strnicmp
+      sqlite3_test_control
+      sqlite3_unlock_notify
+      sqlite3_vfs_find
+      sqlite3_vfs_register
+      sqlite3_vfs_unregister
+    ]
+
+    sqlite_h = File.join( *%w[ ext amalgalite c sqlite3.h ] )
+    api_todo = {}
+    IO.readlines( sqlite_h ).each do |line|
+      if line =~ /\ASQLITE_API/ then
+        if line !~ /SQLITE_DEPRECATED/ and line !~ /SQLITE_EXPERIMENTAL/ then
+          if md = line.match( /(sqlite3_[^(\s]+)\(/ ) then
+                                next if not_implementing.include?(md.captures[0])
+                                api_todo[md.captures[0]] = true
+          end
+        end
+      end
+    end
+
+    Dir.glob("ext/amalgalite/c/amalgalite*.c").each do |am_file|
+      IO.readlines( am_file ).each do |am_line|
+        if md = am_line.match( /(sqlite3_[^(\s]+)\(/ ) then
+                                 api_todo.delete( md.captures[0] )
+        end
+      end
+    end
+
+    puts "#{api_todo.keys.size} functions to still implement"
+    puts api_todo.keys.sort.join("\n")
+  end
+
+  desc "Download and integrate a version of sqlite"
+  task :update_sqlite, [:version,:year] do |task, args|
+    version      = args[:version] or abort "A version of SQLite please `rake #{task.name}[version,year]`"
+    version_year = args[:year]    or abort "The Year #{version} was released please `rake #{task.name}[version,year]`"
+
+    require 'uri'
+    require 'open-uri'
+    require 'zip'
+
+    parts = version.split(".")
+    next_version = [ parts.shift.to_s ]
+    parts.each do |p|
+      next_version << "#{"%02d" % p }"
+    end
+    next_version << "00" if next_version.size == 3
+
+    next_version = next_version.join('')
+
+    url = ::URI.parse("http://sqlite.org/#{version_year}/sqlite-amalgamation-#{next_version}.zip")
+    puts "downloading #{url.to_s} ..."
+    file = "tmp/#{File.basename( url.path ) }"
+    FileUtils.mkdir "tmp" unless File.directory?( "tmp" )
+    File.open( file, "wb+") do |f|
+      open(url) do |input|
+        f.write( input.read )
+      end
+    end
+
+    puts "extracting..."
+    upstream_files = %w[ sqlite3.h sqlite3.c sqlite3ext.h ]
+    Zip::ZipInputStream.open( file ) do |io|
+      loop do
+        entry = io.get_next_entry
+        break unless entry
+        bname = File.basename( entry.name )
+        if upstream_files.include?( bname ) then
+          dest_file = File.join( "ext", "amalgalite", "c", bname )
+          puts "updating #{dest_file}"
+          entry.extract( dest_file ) { true }
+        end
+      end
+    end
+  end
+end