amalgalite 0.10.1-x86-mingw32

data/spec/requires_spec.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+#require 'amalgalite/requires'
+
+#describe Amalgalite::Requires do
+#  it "#require_order has all files in 'lib' and no more" do
+#    dir_files = Dir.glob( File.join( Amalgalite::Paths.lib_path , "**", "*.rb" ) )
+#    require_files = Amalgalite::Requires.require_order.collect { |r| Amalgalite::Paths.lib_path r }
+#    dir_files.size.should == require_files.size
+#    (dir_files - require_files).size.should == 0
+#    (require_files - dir_files).size.should == 0
+#  end
+#
+#  it "can compress and uncompress data" do
+#    s = IO.read( __FILE__ )
+#    s_gz = Amalgalite::Requires.gzip( s )
+#    s.should == Amalgalite::Requires.gunzip( s_gz )
+#  end
+#end
+
+

data/spec/rtree_spec.rb

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'spec'
+require File.expand_path( File.join( File.dirname(__FILE__), 'spec_helper'))
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+require 'amalgalite/database'
+
+# Example from http://sqlite.org/rtree.html
+#
+describe "SQLite3 R*Tree extension" do
+  before( :each ) do
+    @db = Amalgalite::Database.new( ":memory:" )
+    x = @db.execute_batch <<-sql
+    CREATE VIRTUAL TABLE demo_index USING rtree(
+       id,              -- Integer primary key
+       minX, maxX,      -- Minimum and maximum X coordinate
+       minY, maxY       -- Minimum and maximum Y coordinate
+    );
+    -- 
+    INSERT INTO demo_index VALUES(
+        1,                   -- Primary key
+        -80.7749, -80.7747,  -- Longitude range
+        30.3776, 30.3778     -- Latitude range
+    );
+    INSERT INTO demo_index VALUES(
+        2,
+        -81.0, -79.6,
+        35.0, 36.2
+    );
+    sql
+    x.should == 3
+  end
+
+  after( :each ) do
+    @db.close
+  end
+
+  it "has 2 rows" do
+    r = @db.first_value_from( "SELECT count(*) FROM demo_index")
+    r.should == 2
+  end
+
+  it "queries normally" do
+    r = @db.execute "SELECT * FROM demo_index WHERE id=1;"
+    r.size.should == 1
+    row = r.first
+    row['id'].should == 1
+  end
+
+  it "does a 'contained within' query" do
+    r = @db.execute <<-sql
+    SELECT id FROM demo_index
+     WHERE minX>=-81.08 AND maxX<=-80.58
+       AND minY>=30.00  AND maxY<=30.44;
+    sql
+
+    r.size.should == 1
+    r.first['id'].should == 1
+  end
+
+  it "does an 'overlapping' query" do
+    r = @db.execute <<-sql
+    SELECT id FROM demo_index
+     WHERE maxX>=-81.08 AND minX<=-80.58
+       AND maxY>=30.00  AND minY<=35.44;
+    sql
+    r.size.should == 2
+  end
+end
+

data/spec/schema_spec.rb

@@ -0,0 +1,120 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+require 'amalgalite'
+require 'amalgalite/schema'
+
+describe Amalgalite::Schema do
+  before(:each) do
+    @schema = IO.read( SpecInfo.test_schema_file )
+    @iso_db_file = SpecInfo.make_iso_db
+    @iso_db = Amalgalite::Database.new( SpecInfo.make_iso_db )
+  end
+
+  after(:each) do
+    File.unlink SpecInfo.test_db if File.exist?( SpecInfo.test_db )
+    @iso_db.close
+    File.unlink @iso_db_file if File.exist?( @iso_db_file )
+  end
+
+  it "loads the schema of a database" do
+    schema = @iso_db.schema
+    schema.load_tables
+    schema.tables.size.should eql(2)
+  end
+
+  it "lazily loads new table schema" do
+    @iso_db.schema.tables.size.should eql(2)
+    sql = "CREATE TABLE t1 ( a, b, c )"
+    @iso_db.execute( sql )
+    @iso_db.schema.tables.size.should eql(2)
+    @iso_db.schema.dirty!
+    @iso_db.schema.tables['t1'].column_names.should eql(%w[ a b c ])
+    @iso_db.schema.tables.size.should eql(3)
+  end
+
+  it "loads the views in the database" do
+    sql = "CREATE VIEW v1 AS SELECT c.name, c.two_letter, s.name, s.subdivision FROM country AS c JOIN subcountry AS s ON c.two_letter = s.country"
+    @iso_db.execute( sql )
+    @iso_db.schema.load_views
+    @iso_db.schema.views.size.should eql(1)
+    @iso_db.schema.views["v1"].sql.should eql(sql)
+  end
+
+  it "removes quotes from around default values in columns" do
+    sql = "CREATE TABLE t1( d1 default 't' )"
+    @iso_db.execute( sql )
+    @iso_db.schema.dirty!
+    tt = @iso_db.schema.tables['t1']
+    tt.columns['d1'].default_value.should == "t"
+  end
+
+  it "loads the tables and columns" do
+    ct = @iso_db.schema.tables['country']
+    ct.name.should eql("country")
+    ct.columns.size.should eql(3)
+    ct.indexes.size.should eql(2)
+    ct.column_names.should eql(%w[ name two_letter id ])
+    @iso_db.schema.tables.size.should eql(2)
+
+
+    ct.columns['two_letter'].should be_primary_key
+    ct.columns['two_letter'].declared_data_type.should eql("TEXT")
+    ct.columns['name'].should_not be_nullable
+    ct.columns['name'].should be_not_null_constraint
+    ct.columns['name'].should_not be_has_default_value
+    ct.columns['id'].should_not be_auto_increment
+  end
+
+  it "knows what the primary key of a table is" do
+    ct = @iso_db.schema.tables['country']
+    ct.primary_key.should == [ ct.columns['two_letter'] ]
+  end
+
+  it "knows the primary key of a table even without an explicity unique index" do
+    sql = "CREATE TABLE u( id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL , other text )"
+    @iso_db.execute( sql )
+    @iso_db.schema.dirty!
+    ut = @iso_db.schema.tables['u']
+    ut.primary_key.should == [ ut.columns['id'] ]
+  end
+
+  it "knows the primary key of a temporary table" do
+    @iso_db.execute "CREATE TEMPORARY TABLE tt( a, b INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, c )"
+    @iso_db.schema.dirty!
+    tt = @iso_db.schema.load_table( 'tt' )
+    tt.primary_key.should == [ tt.columns['b'] ]
+
+  end
+
+  it "knows what the primary key of a table is when it is a multiple column primary key" do
+    sql = "CREATE TABLE m ( id1, id2, PRIMARY KEY (id2, id1) )"
+    @iso_db.execute( sql )
+    @iso_db.schema.dirty!
+    mt = @iso_db.schema.tables['m']
+    mt.primary_key.should == [ mt.columns['id2'], mt.columns['id1'] ]
+  end
+
+  it "loads the indexes" do
+    c = @iso_db.schema.tables['country']
+    c.indexes.size.should eql(2)
+    c.indexes['country_name'].columns.size.should eql(1)
+    c.indexes['country_name'].should_not be_unique
+    c.indexes['country_name'].sequence_number.should eql(0)
+    c.indexes['country_name'].columns.first.should eql(@iso_db.schema.tables['country'].columns['name'])
+    c.indexes['sqlite_autoindex_country_1'].should be_unique
+
+    subc = @iso_db.schema.tables['subcountry']
+    subc.indexes.size.should eql(3)
+    subc.indexes['subcountry_country'].columns.first.should eql(@iso_db.schema.tables['subcountry'].columns['country'])
+  end
+
+  it "can load the schema of a temporary table" do
+    @iso_db.execute "CREATE TEMPORARY TABLE tt( a, b, c )"
+    @iso_db.schema.dirty!
+    @iso_db.schema.tables['tt'].should be_nil
+    @iso_db.schema.load_table('tt').should_not be_nil
+    @iso_db.schema.tables['tt'].should be_temporary
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+
+require 'amalgalite'
+
+class SpecInfo
+  class << self
+    def test_db
+      @test_db ||=  File.expand_path(File.join(File.dirname(__FILE__), "test.db"))
+    end
+
+    def test_schema_file
+      @test_schema_file ||= File.expand_path(File.join(File.dirname(__FILE__),"iso-3166-schema.sql"))
+    end
+
+    def make_iso_db
+      @iso_db ||= File.expand_path(File.join(File.dirname(__FILE__), "iso-3166.db"))
+      @new_is_db =  File.expand_path(File.join(File.dirname(__FILE__), "iso-3166-testing.db"))
+      FileUtils.cp @iso_db, @new_is_db
+      return @new_is_db
+    end
+
+  end
+end
+

data/spec/sqlite3/constants_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__),%w[ .. spec_helper.rb ]))
+
+require 'amalgalite/sqlite3/constants'
+
+describe Amalgalite::SQLite3::Constants do
+
+  it "has Open constants" do
+    Amalgalite::SQLite3::Constants::Open::READONLY.should > 0
+  end
+  
+  it "has DataType constants" do
+    Amalgalite::SQLite3::Constants::DataType::BLOB.should > 0
+  end
+
+  it "has ResultCode constants" do
+  end
+
+  describe 'ResultCode' do 
+    it "has constants" do
+      Amalgalite::SQLite3::Constants::ResultCode::OK.should == 0
+    end
+
+    it "can return the constant from a number" do
+      c = Amalgalite::SQLite3::Constants::ResultCode.name_from_value( 21 )
+      c.should == "MISUSE"
+    end
+
+    it "can return the number from a name" do
+      v = Amalgalite::SQLite3::Constants::ResultCode.value_from_name( "MISUSE" )
+      v.should == 21
+    end
+  end
+
+  describe 'Status' do
+    it "has constants" do
+      Amalgalite::SQLite3::Constants::Status::MEMORY_USED.should == 0
+    end
+
+    it "can return the constant from a number" do
+      c = Amalgalite::SQLite3::Constants::Status.name_from_value( 3 )
+      c.should == "SCRATCH_USED"
+    end
+    
+    it "can return the number from a name" do
+      v = Amalgalite::SQLite3::Constants::Status.value_from_name( "memory_used" )
+      v.should == 0
+    end
+  end
+
+  describe 'DBStatus' do
+    it "has constants" do
+      Amalgalite::SQLite3::Constants::DBStatus::LOOKASIDE_USED.should == 0
+    end
+
+    it "can return the constant from a number" do
+      c = Amalgalite::SQLite3::Constants::DBStatus.name_from_value( 0 )
+      c.should == "LOOKASIDE_USED"
+    end
+    
+    it "can return the number from a name" do
+      v = Amalgalite::SQLite3::Constants::DBStatus.value_from_name( "lookaside_used" )
+      v.should == 0
+    end
+  end
+end

data/spec/sqlite3/database_status_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..",  "spec_helper.rb"))
+require 'amalgalite/sqlite3'
+require 'rbconfig'
+
+describe "Amalgalite::SQLite3::Database::Status" do
+  before(:each) do
+    @db = Amalgalite::Database.new( "lookaside-test.db" )
+    @db.execute(" create table t(a, b)")
+    20.times do |x|
+      @db.execute("insert into t(a, b) values (?,?);", x, x+1)
+    end
+  end
+
+  after(:each) do
+    @db.close
+    FileUtils.rm_f "lookaside-test.db" 
+  end
+
+
+  it "knows how much lookaside memory it has used" do
+    @db.api.status.lookaside_used.highwater.should > 0
+    @db.api.status.lookaside_used.current.should >= 0
+  end
+
+  it "can reset the highwater value" do
+    stat = @db.api.status.lookaside_used
+    before = stat.highwater
+    before.should > 0
+
+    stat.reset!
+    after = stat.highwater
+
+    after.should eql(0)
+    after.should_not eql(before)
+  end
+end

data/spec/sqlite3/status_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper.rb"))
+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 >= 0
+    Amalgalite::SQLite3.status.memory_used.highwater.should >= 0
+  end
+
+  it "can reset the highwater value" do
+    before = Amalgalite::SQLite3.status.memory_used.highwater
+    Amalgalite::SQLite3.status.memory_used.reset!
+    Amalgalite::SQLite3.status.memory_used.highwater.should > 0
+    after = Amalgalite::SQLite3.status.memory_used.highwater
+    after.should_not eql(before)
+  end
+end

data/spec/sqlite3/version_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"..","spec_helper.rb"))
+require 'amalgalite/sqlite3/version'
+
+describe "Amalgalite::SQLite3::Version" do
+  it "should have the sqlite3 version" do
+    Amalgalite::SQLite3::VERSION.should =~ /\d\.\d\.\d/
+    Amalgalite::SQLite3::Version.to_s.should =~ /\d\.\d\.\d/
+    Amalgalite::SQLite3::Version.to_i.should eql(3006016)
+    Amalgalite::SQLite3::Version::MAJOR.should eql(3)
+    Amalgalite::SQLite3::Version::MINOR.should eql(6)
+    Amalgalite::SQLite3::Version::RELEASE.should eql(16)
+    Amalgalite::SQLite3::Version.to_a.should have(3).items
+  end
+end

data/spec/sqlite3_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+require 'amalgalite/sqlite3'
+require 'rbconfig'
+
+describe "Amalgalite::SQLite3" do
+  it "is threadsafe is ruby is compiled with pthread support, in this case that is (#{Config::CONFIG['configure_args'].include?( "--enable-pthread" )})" do
+    Amalgalite::SQLite3.threadsafe?.should eql(Config::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,161 @@
+require 'rubygems'
+require 'spec'
+
+require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
+
+require 'amalgalite'
+
+describe Amalgalite::Statement do
+  before(:each) do
+    @db = Amalgalite::Database.new( SpecInfo.test_db )
+    @schema_sql = IO.read( SpecInfo.test_schema_file )
+    @iso_db_file = SpecInfo.make_iso_db
+    @iso_db = Amalgalite::Database.new( SpecInfo.make_iso_db )
+  end
+
+  after(:each) do
+    @db.close
+    File.unlink SpecInfo.test_db if File.exist?( SpecInfo.test_db )
+    
+    @iso_db.close
+    File.unlink @iso_db_file if File.exist?( @iso_db_file )
+  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 "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
+    db = Amalgalite::Database.new( SpecInfo.test_db )
+    stmt = @db.prepare( @schema_sql )
+    stmt.execute
+    stmt.remaining_sql.size.should > 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|
+      rows = 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