libsql 0.1.0

data/spec/sqlite3/database_status_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'libsql/sqlite3'
+require 'rbconfig'
+
+describe "::Libsql::SQLite3::Database::Status" do
+  before(:each) do
+    @db = ::Libsql::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 be > 0
+    @db.api.status.lookaside_used.current.should be >= 0
+  end
+
+  it "can reset the highwater value" do
+    stat = @db.api.status.lookaside_used
+    before = stat.highwater
+    before.should be > 0
+
+    stat.reset!
+    after = stat.highwater
+
+    after.should eql(0)
+    after.should_not eql(before)
+  end
+end

data/spec/sqlite3/libsql_version_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'libsql/sqlite3/libsql_version'
+
+describe "::Libsql::SQLite3::LibsqlVersion" do
+  it "should have the libsql version" do
+    expect(::Libsql::SQLite3::LIBSQL_VERSION).to match(/\d+\.\d+\.\d+/)
+    expect(::Libsql::SQLite3::LibsqlVersion.to_s).to match(/\d+\.\d+\.\d+/)
+    expect(::Libsql::SQLite3::LibsqlVersion.runtime_version).to match( /\d+\.\d+\.\d+/ )
+    expect(::Libsql::SQLite3::LibsqlVersion.compiled_version).to match( /\d+\.\d+\.\d+/ )
+
+    ::Libsql::SQLite3::LIBSQL_VERSION.should be == "0.2.1"
+    ::Libsql::SQLite3::LibsqlVersion.compiled_version.should be == "0.2.1"
+    ::Libsql::SQLite3::LibsqlVersion.runtime_version.should be == "0.2.1"
+    ::Libsql::SQLite3::LibsqlVersion.to_s.should be == "0.2.1"
+  end
+end

data/spec/sqlite3/status_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'libsql/sqlite3'
+require 'rbconfig'
+
+describe "::Libsql::SQLite3::Status" do
+  it "knows how much memory it has used" do
+    ::Libsql::SQLite3.status.memory_used.current.should be >= 0
+    ::Libsql::SQLite3.status.memory_used.highwater.should be >= 0
+  end
+
+  it "can reset the highwater value" do
+    before = ::Libsql::SQLite3.status.memory_used.highwater
+    before.should be > 0
+
+    current = ::Libsql::SQLite3.status.memory_used.current
+    ::Libsql::SQLite3.status.memory_used.reset!
+    ::Libsql::SQLite3.status.memory_used.highwater.should be == current
+
+    after = ::Libsql::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 'libsql/sqlite3/version'
+
+describe "::Libsql::SQLite3::Version" do
+  it "should have the sqlite3 version" do
+    expect(::Libsql::SQLite3::VERSION).to match(/\d+\.\d+\.\d+/)
+    expect(::Libsql::SQLite3::Version.to_s).to match( /\d+\.\d+\.\d+/ )
+    expect(::Libsql::SQLite3::Version.runtime_version).to match( /\d+\.\d+\.\d+/ )
+
+    ::Libsql::SQLite3::Version.to_i.should eql(3042000)
+    ::Libsql::SQLite3::Version.runtime_version_number.should eql(3042000)
+
+    ::Libsql::SQLite3::Version::MAJOR.should eql(3)
+    ::Libsql::SQLite3::Version::MINOR.should eql(42)
+    ::Libsql::SQLite3::Version::RELEASE.should eql(0)
+    expect(::Libsql::SQLite3::Version.to_a.size).to eql(3)
+
+    ::Libsql::SQLite3::Version.compiled_version.should be == "3.42.0"
+    ::Libsql::SQLite3::Version.compiled_version_number.should be == 3042000
+    ::Libsql::SQLite3::Version.compiled_matches_runtime?.should be == true
+  end
+
+  it "should have the sqlite3 source id" do
+    source_id = "2023-03-11 23:21:21 dc9f025dc43cb8008e7d8d644175d8b2d084e602a1513803c40c513d1e99alt1"
+    ::Libsql::SQLite3::Version.compiled_source_id.should be == source_id
+    ::Libsql::SQLite3::Version.runtime_source_id.should be == source_id
+  end
+end

data/spec/sqlite3_spec.rb

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

data/spec/statement_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe ::Libsql::Statement do
+  before(:each) do
+    @db = ::Libsql::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( ::Libsql::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(::Libsql::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 = ::Libsql::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 = ::Libsql::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 'libsql/type_maps/storage_map'
+
+describe ::Libsql::TypeMaps::StorageMap do
+  before(:each) do
+    @map = ::Libsql::TypeMaps::StorageMap.new
+  end
+
+  describe "#bind_type_of" do
+
+    it "Float is bound to DataType::FLOAT" do
+      @map.bind_type_of( 3.14 ).should == ::Libsql::SQLite3::Constants::DataType::FLOAT
+    end
+
+    it "Integer is bound to DataType::INTGER" do
+      @map.bind_type_of( 42 ).should == ::Libsql::SQLite3::Constants::DataType::INTEGER
+    end
+
+    it "nil is bound to DataType::NULL" do
+      @map.bind_type_of( nil ).should == ::Libsql::SQLite3::Constants::DataType::NULL
+    end
+
+    it "::Libsql::Blob is bound to DataType::BLOB" do
+      @map.bind_type_of( ::Libsql::Blob.new( :string => "testing mapping", :column => true )  ).should == ::Libsql::SQLite3::Constants::DataType::BLOB
+    end
+
+    it "everything else is bound to DataType::TEXT" do
+      @map.bind_type_of( "everything else" ).should == ::Libsql::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 'libsql'
+require 'libsql/trace_tap'
+require 'libsql/profile_tap'
+require 'libsql/taps/console'
+require 'stringio'
+
+describe ::Libsql::TraceTap do
+  it "wraps up an object and delegates the 'trace' method to a method on that object" do
+    s = StringIO.new
+    tt = ::Libsql::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{ ::Libsql::TraceTap.new( Object.new ) }.should raise_error( ::Libsql::Error )
+  end
+end
+
+describe ::Libsql::ProfileTap do
+  it "raises an error if an the wrapped object does not respond to the indicated method"  do
+    lambda{ ::Libsql::ProfileTap.new( Object.new ) }.should raise_error( ::Libsql::Error )
+  end
+end
+
+describe ::Libsql::Taps::StringIO do
+  it "dumps profile information" do
+    s = ::Libsql::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
+    ::Libsql::Taps::Stdout.new
+  end
+
+  it "has a stderr tap" do
+    ::Libsql::Taps::Stderr.new
+  end
+end
+
+describe ::Libsql::ProfileSampler do
+  it "aggregates samples" do
+    s = ::Libsql::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 'libsql/type_maps/text_map'
+
+describe ::Libsql::TypeMaps::TextMap do
+  before(:each) do
+    @map = ::Libsql::TypeMaps::TextMap.new
+  end
+
+  describe "#bind_type_of" do
+    it "returnes text for everything" do
+      @map.bind_type_of( 3.14 ).should == ::Libsql::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 'libsql/type_map'
+
+describe ::Libsql::TypeMap do
+  it "#bind_type_of raises NotImplemented error" do
+    tm = ::Libsql::TypeMap.new
+    lambda { tm.bind_type_of( Object.new ) }.should raise_error( NotImplementedError )
+  end
+
+  it "#result_value_of raises NotImplemented error" do
+    tm = ::Libsql::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 'libsql/version'
+
+describe "::Libsql::VERSION" do
+  it "should have a version string" do
+    expect(::Libsql::VERSION).to match( /\d+\.\d+\.\d+/ )
+  end
+end

data/tasks/custom.rake

@@ -0,0 +1,134 @@
+#-----------------------------------------------------------------------
+# 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 libsql 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/libsql/c/libsql*.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 the latest version of libsql"
+  task :update_libsql, [:version] do |task, args|
+    require 'uri'
+    require 'open-uri'
+
+    asset_regex = /\Alibsql-amalgamation-(\d+\.\d+\.\d+)\.tar\.gz\Z/
+
+    asset = nil
+    require 'debug'
+
+    if args[:version] then
+      all_releases_uri = "https://api.github.com/repos/libsql/libsql/releases"
+      all_releases_json  = ::URI.parse(all_releases_uri).read
+      all_releases_parsed = JSON.parse(all_releases_json)
+      version_release = all_releases_parsed.find { |p| p['tag_name'] == "libsql-#{args[:version]}" }
+      if version_release then
+        assets_url = version_release['assets_url']
+        assets_json = ::URI.parse(assets_url).read
+        assets_parsed = JSON.parse(assets_json)
+        asset = assets_parsed.find { |a| a['name'] =~ asset_regex }
+      else
+        msg = [
+        "Unable to find release for `libsql-#{args[:version]}`. Found releases for:"
+        ]
+        all_releases_parsed.map{ |p| p['tag_name'] }.each do |tag|
+          msg << "  #{tag}"
+        end
+
+        abort msg.join("\n")
+      end
+    else
+      latest_uri = "https://api.github.com/repos/libsql/libsql/releases/latest"
+      latest_json = ::URI.parse(latest_uri).read
+      latest_parsed = JSON.parse(latest_json)
+      asset = latest_parsed['assets'].find { |a| a['name'] =~ asset_regex }
+    end
+
+    asset_name = asset['name']
+    tarball_uri = ::URI.parse(asset['browser_download_url'])
+    puts "Downloading from #{tarball_uri}"
+    file = "tmp/#{File.basename(tarball_uri.path)}"
+    puts "              to #{file}"
+
+    FileUtils.mkdir "tmp" unless File.directory?( "tmp" )
+    if File.exist?(file) then
+      puts "  #{file} already exists.."
+    else
+      File.open( file, "wb+") do |f|
+        tarball_uri.open do |input|
+          f.write( input.read )
+        end
+      end
+    end
+
+    puts "extracting"
+    upstream_files = %w[ sqlite3.h sqlite3.c ]
+
+    require 'rubygems'
+    # Using the built in rubygems tar reader since we know it exists
+    ::Zlib::GzipReader.open(file) do |gz|
+      ::Gem::Package::TarReader.new(gz) do |reader|
+        reader.each do |entry|
+          next unless entry.file?
+          bname = File.basename(entry.full_name)
+          if upstream_files.include?(bname) then
+            dest_path = File.join( "ext", "libsql", "c", bname )
+            puts "updating #{dest_path}"
+            File.open(dest_path, "w+") do |dest_file|
+              dest_file.write(entry.read)
+            end
+          end
+        end
+      end
+    end
+  end
+end