micro_sql 0.2.0 → 0.3.0

data/Gemfile

@@ -3,12 +3,15 @@ source "http://rubygems.org"
 # Example:
 #   gem "activesupport", ">= 2.3.5"
 
+gem "pg"
+gem "sqlite3"
+
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "shoulda", ">= 0"
-  gem "rdoc", "~> 3.12"
   gem "bundler"
   gem "jeweler"
-  # gem "rcov", ">= 0"
+  gem 'simplecov', :require => false
+  gem "ruby-debug19"
 end
+

data/Gemfile.lock

@@ -1,6 +1,8 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.6)
     git (1.2.5)
     jeweler (1.8.3)
       bundler (~> 1.0)
@@ -8,14 +10,28 @@ GEM
       rake
       rdoc
     json (1.6.6)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    multi_json (1.2.0)
+    pg (0.13.2)
     rake (0.9.2.2)
     rdoc (3.12)
       json (~> 1.4)
-    shoulda (3.0.1)
-      shoulda-context (~> 1.0.0)
-      shoulda-matchers (~> 1.0.0)
-    shoulda-context (1.0.0)
-    shoulda-matchers (1.0.0)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+    simplecov (0.6.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    sqlite3 (1.3.5)
 
 PLATFORMS
   ruby
@@ -23,5 +39,7 @@ PLATFORMS
 DEPENDENCIES
   bundler
   jeweler
-  rdoc (~> 3.12)
-  shoulda
+  pg
+  ruby-debug19
+  simplecov
+  sqlite3

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/micro_sql.rb

@@ -1,4 +1,5 @@
 require "uri"
+require "logger"
 
 class MicroSql
 end
@@ -6,9 +7,16 @@ end
 require_relative "micro_sql/pg_adapter"
 require_relative "micro_sql/sqlite_adapter"
 require_relative "micro_sql/table"
-require_relative "micro_sql/settings"
+require_relative "micro_sql/key_value_table"
 
 class MicroSql
+  class Error < RuntimeError; end
+
+  (class << self; self; end).class_eval do
+    attr :logger, true
+  end
+  
+  self.logger = Logger.new(STDERR)
   
   (class << self; self; end).class_eval do
     private :new
@@ -26,15 +34,10 @@ class MicroSql
   end
   
   def ask(sql, *args)
-    r = exec(sql, *args)
-    return r unless r.is_a?(Array)
-
-    r = r.first
-    return r unless r.is_a?(Array)
-    return r unless r.length == 1
-    r.first
+    results = execute :ask, sql, *args
+    format_results_for_ask(results)
   end
-
+  
   def exec!(sql, *args)
     execute :no_prepare, sql, *args
   end
@@ -43,27 +46,122 @@ class MicroSql
     execute :prepare, sql, *args
   end
 
+  private
+  
+  def format_results_for_ask(results)
+    return results unless results.is_a?(Array)
+
+    results = results.first
+
+    return results unless results.is_a?(Array)
+    return results if results.length != 1
+
+    results.first
+  end
+
+  public
+  
   def transaction(&block)
-    @impl.transaction(&block)
+    r = nil
+    @impl.transaction do
+      r = yield
+    end
+    r
+  rescue RollbackException
+    nil
+  end
+  
+  def rollback!
+    raise RollbackException
+  end
+  
+  public
+  
+  def insert(table, *values)
+    hashes, arrays = values.partition do |value| value.is_a?(Hash) end
+
+    id1 = insert_array_values(table, arrays)
+    id2 = insert_hash_values(table, hashes)
+    
+    id1 || id2
+  end
+
+  private
+  
+  def insert_array_values(table, values)
+    width = values.map(&:length).max
+    return if width == 0 || width == nil
+    
+    sql = insert_sql(table, width, nil)
+    values.inject(0) do |r, value|
+      exec sql, *value
+    end
   end
   
-  def settings
-    @settings ||= MicroSql::SettingsTable.new(self)
+  def insert_hash_values(table, values)
+    keys = values.map(&:keys).flatten.uniq
+    return if keys.empty?
+
+    sql = insert_sql(table, keys.length, keys)
+    values.inject(0) do |r, rec|
+      exec sql, *rec.values_at(*keys)
+    end
   end
   
+  def insert_sql(table, width, keys = nil)
+    sql = "INSERT INTO #{table}"
+    sql += "(#{keys.join(",")})" if keys
+    sql += " VALUES(" + ([ "?" ] * width).join(",") + ")"
+  end
+  
+  public
+  
+  def tables
+    raise "Implementation missing: #{self.class}#tables"
+  end
+
+  def table(sql_or_name)
+    @tables ||= {}
+
+    return table_from_name(sql_or_name) if sql_or_name !~ /\s/
+
+    table = Table.new(self, sql_or_name)
+    @tables[table.table_name] = table 
+  end
+
   private
   
+  def table_from_name(name)
+    @tables[name] ||= Table.new(self, name)
+  rescue RuntimeError
+  end
+  
+  public
+  
+  def key_value_table(name)
+    @key_value_tables ||= Hash.new { |hash, key|
+      hash[key] = MicroSql::KeyValueTable.new(self, key)
+    }
+
+    @key_value_tables[name] 
+  end
+  
+  private
+  
+  class RollbackException < RuntimeError; end
+  
   def prepared_queries
     @prepared_queries ||= {}
   end
 
+  def unprepare(key)
+    @prepared_queries.delete key
+  end
+  
   def prepare(sql)
-    key = sql.to_uid.to_s
-    prepared_queries.fetch(key) 
+    key = sql
+    prepared_queries.fetch(key)
   rescue KeyError
     prepared_queries[key] = prepare_query(key, sql) 
   end
 end
-
-# url = "pg://sqdb:sqdb@localhost:5433/sqdb"
-# MicroSql.create(url)

data/lib/micro_sql/key_value_table.rb

@@ -0,0 +1,46 @@
+# -- The settings table; has support for ttl etc. ---------------------------
+
+require "json"
+
+class MicroSql::KeyValueTable < MicroSql::Table
+  def initialize(db, table_name = "settings")
+    super db, "CREATE TABLE #{table_name}(uid TEXT PRIMARY KEY, value TEXT, ttl BIGINT)"
+  end
+  
+  def [](key)
+    value, ttl = db.ask("SELECT value, ttl FROM #{table_name} WHERE uid=?", key)
+    decode(value) if !ttl || ttl < Time.now.to_i
+  end
+
+  def cached(key, ttl = nil, &block)
+    self[key] || update(key, yield, ttl)
+  end
+
+  def update(key, value, ttl = nil)
+    if value
+      encoded = encode(value)
+      ttl += Time.now.to_i if ttl
+      affected = @db.ask("UPDATE #{table_name} SET value=?, ttl=? WHERE uid=?", encoded, ttl, key)
+      if affected == 0
+        @db.ask("INSERT INTO #{table_name}(value, ttl, uid) VALUES(?,?,?)", encoded, ttl, key)
+      end
+    else
+      @db.ask("DELETE FROM #{table_name} WHERE uid=?", key)
+    end
+
+    value
+  end
+
+  alias :[]= :update
+
+  private
+  
+  def decode(io)
+    return unless io
+    JSON.parse("[#{io}]").first
+  end
+  
+  def encode(value)
+    value && value.to_json
+  end
+end

data/lib/micro_sql/pg_adapter.rb

@@ -9,57 +9,146 @@ class MicroSql::PgAdapter < MicroSql
                        :user     => uri.user, 
                        :password => uri.password, 
                        :dbname   => uri.path[1..-1]
+
+    @impl.set_notice_receiver { |result| MicroSql.logger.info(result.error_message) }
   end
 
   def tables
     exec("SELECT tablename FROM pg_tables WHERE tablename NOT LIKE 'pg_%' AND tablename NOT LIKE 'sql_%'").map(&:first)
   end
   
+  def primary_keys(table)
+    sql = <<-SQL
+    SELECT  pg_attribute.attname
+    FROM    pg_index, pg_class, pg_attribute 
+    WHERE 
+      pg_class.oid = ?::regclass AND
+      indrelid = pg_class.oid AND
+      pg_attribute.attrelid = pg_class.oid AND 
+      pg_attribute.attnum = any(pg_index.indkey) AND 
+      indisprimary
+    SQL
+    
+    exec(sql, table).map(&:first)
+  end
+  
+  def primary_key(table)
+    keys = primary_keys(table)
+    raise(Error, "No support for primary key (in table #{table})") if keys.length > 1
+    keys.first || raise(Error, "No primary key in table #{table}")
+  end
+
+  private
+
+  def insert_sql(table_name, *args)
+    "#{super} RETURNING #{table(table_name).primary_key}"
+  end
+  
+  public
+  
   def execute_batch(sql)
-    sql.split(";").each { exec(part) }
+    sql.split(";").each { |part|
+      exec!(part) 
+    }
   end
   
   private
 
   def execute(flag, sql, *args)
-    statement = prepare(sql) if flag == :prepare
-    result = if statement
-      @impl.exec_prepared(statement, args)
+    execute_(flag, sql, *args)
+  rescue PG::Error
+    raise Error, $!.message
+  end
+  
+  def execute_(flag, sql, *args)
+    adjusted_sql = replace_placeholders(sql)
+
+    result = if adjusted_sql && (flag == :prepare || flag == :ask) && prepared_statement = prepare(adjusted_sql) 
+      @impl.exec_prepared(prepared_statement, args)
     else
-      @impl.exec(sql, args)
+      @impl.exec(adjusted_sql || sql, args)
     end
 
-    if sql =~ /^\s*(UPDATE|DELETE|INSERT)/i
+    case sql
+    when /^\s*UPDATE\b/
       return result.cmd_tuples
+    when /^\s*DELETE\b/
+      return result.cmd_tuples
+    when /^\s*INSERT\b/
+      # postgresql has a different way of returning newly inserted ids; e.g.
+      #   "INSERT ... RETURNING id"
+      # The returned id value is returned to the pg driver the same as
+      # a SELECT would be. We therefore evaluate only the first record.
+      flag = :insert
+      records = result.values
+    else
+      records = result.values
+      records = records[0,1] if flag == :ask
     end
 
-    types = (0 ... result.num_fields).map do |i| 
-      # Get the type of the second column of the result 'res'
-      @impl.exec( "SELECT format_type($1,$2)", [result.ftype(i), result.fmod(i)] ).getvalue( 0, 0 )
+    result = convert_records result, records
+  
+    flag == :insert ? format_results_for_ask(result) : result
+  end
+
+  module Conversion
+    extend self
+    
+    def nop; end
+    
+    def string(s); s; end
+    def unknown(s); s; end
+    def integer(s); s.to_i; end
+  end
+
+  def conversion_for(ftype, fmod)
+    sym = case ftype
+    when 16                 then :boolean
+    when 17                 then :bytea
+    when 19                 then :nop
+    when 20, 21, 22, 23, 26 then :integer
+    when 25                 then :nop           # "text"
+    when 700, 701           then :float
+    when 790, 1700          then :big_decimal
+    when 1083, 1266         then :string_to_time
     end
+  
+    return sym if sym && Conversion.respond_to?(sym)
+    raise "Unsupported conversion #{sym.inspect}" if sym
+    
+    typename = @impl.exec( "SELECT format_type($1,$2)", [ftype, fmod] ).getvalue( 0, 0 )
+    
+    return :nop if typename == "unknown"
+    raise "Unsupported format_type #{typename.inspect} (ftype, fmod: #{ftype}, #{fmod})"
+  end
+  
+  def convert_records(result, records)
+    # Get the type of the result columns
+    converters = (0 ... result.num_fields).map do |i| 
+      conversion = conversion_for result.ftype(i), result.fmod(i)
+      [ conversion, i ] unless conversion == :nop
+    end.compact
 
-    result.values.map do |rec|
-      types.each_with_index do |type, idx|
-        case type
-        when "text", "name"           then :nop
-        when "integer", "bigint"      then rec[idx] = rec[idx] && rec[idx].to_i
-        else  raise "Unknown column type #{type}: #{rec[idx].inspect}"
-        end
+    records.map do |record|
+      converters.each do |type, idx|
+        record[idx] = Conversion.send type, record[idx]
       end
-      
-      rec
+      record
     end
   end
-  
-  def prepare_query(key, sql)
+
+  def replace_placeholders(sql)
     idx = 0
     query = sql.gsub("?") do 
       idx += 1
       "$#{idx}" 
     end
-
-    return nil if idx == 0
-    @impl.prepare(key, query)
+    
+    idx == 0 ? nil : query
+  end
+  
+  def prepare_query(key, sql)
+    @impl.prepare(key, sql)
     key
   end
 end

data/lib/micro_sql/sqlite_adapter.rb

@@ -4,7 +4,7 @@ class MicroSql::SqliteAdapter < MicroSql
   def initialize(url)
     uri = URI.parse(url)
     @impl = SQLite3::Database.new(uri.path)
-    exec "PRAGMA synchronous = OFF"
+    exec! "PRAGMA synchronous = OFF"
   end
   
   def execute_batch(sql)
@@ -15,17 +15,27 @@ class MicroSql::SqliteAdapter < MicroSql
     exec("SELECT name FROM sqlite_master WHERE type=?", "table").map(&:first)
   end
   
-  def exec(sql, *args)
-    results = prepare(sql).execute!(*args)
+  private
+  
+  def execute(prepare, sql, *args)
+    prepared_query = prepare(sql)
+    execute_prepared_query sql, prepared_query, *args
+  ensure
+    unprepare(sql) if prepare == :no_prepare
+  end
+  
+  def execute_prepared_query(sql, query, *args)
+    results = query.execute!(*args)
     case sql
-    when /^\s*INSERT/i          then @impl.last_insert_row_id
-    when /^\s*(UPDATE|DELETE)/i then @impl.changes
-    else                        results
+    when /^\s*INSERT/i then @impl.last_insert_row_id
+    when /^\s*UPDATE/i then @impl.changes
+    when /^\s*DELETE/i then @impl.changes
+    else                    results
     end
+  rescue SQLite3::ConstraintException
+    raise Error, $!.message
   end
 
-  private
-
   def prepare_query(key, sql)
     @impl.prepare(sql)
   end

data/lib/micro_sql/table.rb

@@ -5,15 +5,26 @@ class MicroSql::Table
   
   def initialize(db, sql)
     @db = db
-    if sql =~ /\s*CREATE TABLE\s+([^\( ]+)/
+
+    if sql !~ /\s/
+      # no space: sql must be the table_name
+      @table_name = sql
+      raise "No such table: '#{@table_name}'" unless exists?
+    elsif sql =~ /\s*CREATE TABLE\s+([^\( ]+)/
       @table_name = $1
+      raise ArgumentError, "Cannot determine table_name from SQL: #{sql}" unless table_name
+      build(sql) unless exists?
     end
-    
-    raise ArgumentError, "Cannot determine table_name from SQL: #{sql}" unless table_name
-    
-    build(sql) unless exists?
   end
 
+  def insert(*values)
+    db.insert table_name, *values
+  end
+
+  def primary_key
+    @primary_key ||= db.primary_key(table_name)
+  end
+  
   private
 
   def exists?
@@ -21,7 +32,7 @@ class MicroSql::Table
   end
 
   def build(sql)
-    LOGGER.warn "Create table #{table_name}"
+    MicroSql.logger.info "Create table #{table_name}"
     db.execute_batch(sql)
   end
 end

data/micro_sql.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "micro_sql"
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["radiospiel"]
-  s.date = "2012-03-30"
+  s.date = "2012-04-02"
   s.description = "You only need a single method to talk to your database..."
   s.email = "eno@open-lab.org"
   s.extra_rdoc_files = [
@@ -25,13 +25,16 @@ Gem::Specification.new do |s|
     "Rakefile",
     "VERSION",
     "lib/micro_sql.rb",
+    "lib/micro_sql/key_value_table.rb",
     "lib/micro_sql/pg_adapter.rb",
-    "lib/micro_sql/settings.rb",
     "lib/micro_sql/sqlite_adapter.rb",
     "lib/micro_sql/table.rb",
     "micro_sql.gemspec",
+    "script/watchr",
     "test/helper.rb",
-    "test/test_micro_sql.rb"
+    "test/test_micro_sql.rb",
+    "test/test_micro_sql_pg.rb",
+    "test/test_micro_sql_sqlite3.rb"
   ]
   s.homepage = "http://github.com/radiospiel/micro_sql"
   s.licenses = ["MIT"]
@@ -43,21 +46,27 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<shoulda>, [">= 0"])
-      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_runtime_dependency(%q<pg>, [">= 0"])
+      s.add_runtime_dependency(%q<sqlite3>, [">= 0"])
       s.add_development_dependency(%q<bundler>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<ruby-debug19>, [">= 0"])
     else
-      s.add_dependency(%q<shoulda>, [">= 0"])
-      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<pg>, [">= 0"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
       s.add_dependency(%q<bundler>, [">= 0"])
       s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<ruby-debug19>, [">= 0"])
     end
   else
-    s.add_dependency(%q<shoulda>, [">= 0"])
-    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<pg>, [">= 0"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
     s.add_dependency(%q<bundler>, [">= 0"])
     s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<ruby-debug19>, [">= 0"])
   end
 end
 

data/script/watchr

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'rb-fsevent'
+
+if ARGV.length < 2
+  STDERR.puts "watchr dir ruby-parameter(s)..."
+  abort
+end
+
+paths = ARGV.shift.split(",")
+$args = ARGV.dup
+
+
+def do_ruby
+  STDERR.puts $args.join(" ")
+  STDERR.puts "=" * 80
+  
+  system(*$args)
+end
+
+puts "Initial run"
+do_ruby
+
+fsevent = FSEvent.new
+fsevent.watch paths do |directories|
+  puts "Detected change inside: #{directories.inspect}"
+  do_ruby
+end
+fsevent.run

data/test/helper.rb

@@ -7,12 +7,20 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
+
+require 'ruby-debug'
+require 'simplecov'
 require 'test/unit'
-require 'shoulda'
+SimpleCov.start do
+  add_filter "test/helper.rb"
+end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'micro_sql'
 
+MicroSql.logger.level = Logger::WARN
+
 class Test::Unit::TestCase
 end
+

data/test/test_micro_sql.rb

@@ -1,7 +1,9 @@
 require 'helper'
 
 class TestMicroSql < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
-    flunk "hey buddy, you should probably rename this file and start testing for real"
+  def test_assert_creation_with_unsupported_url
+    assert_raise(NameError) {  
+      MicroSql.create "xy://abc"
+    }
   end
 end

data/test/test_micro_sql_pg.rb

@@ -0,0 +1,139 @@
+load "#{File.dirname(__FILE__)}/helper.rb"
+
+class TestMicroSqlPg < Test::Unit::TestCase
+  PG_URL = "pg://micro_sql:micro_sql@localhost/micro_sql_test"
+
+  def db
+    @db ||= MicroSql.create(PG_URL).tap do |db|
+      db.tables.each { |table_name| db.exec("DROP TABLE #{table_name}") }
+    end
+  end
+  
+  def test_assert_create_tables
+    db.execute_batch <<-SQL
+    CREATE TABLE t1(idx INTEGER PRIMARY KEY, b TEXT);
+    CREATE TABLE t2(a INTEGER, b TEXT);
+    SQL
+
+    assert_equal %w(t1 t2), db.tables.sort
+  end
+  
+  def test_ask_and_exec
+    db.execute_batch <<-SQL
+      DROP SEQUENCE IF EXISTS t1_idx_seq;
+      CREATE SEQUENCE t1_idx_seq;
+      CREATE TABLE t1(idx INTEGER PRIMARY KEY NOT NULL DEFAULT nextval('t1_idx_seq'), b TEXT);
+      ALTER SEQUENCE t1_idx_seq OWNED BY t1.idx
+    SQL
+
+    # -- insert
+    r = db.ask("INSERT INTO t1 (idx,b) VALUES(12, '') RETURNING idx")
+    assert_equal 12, r
+    assert_equal 13, db.exec("INSERT INTO t1 (idx,b) VALUES(13, '') RETURNING idx")
+
+    assert_raise(MicroSql::Error) {  
+      assert_equal 1, db.exec("INSERT INTO t1 (idx,b) VALUES(13, '') RETURNING idx")
+    }
+    assert_raise(MicroSql::Error) {  
+      assert_equal 1, db.ask("INSERT INTO t1 (idx,b) VALUES(13, '') RETURNING idx")
+    }
+    
+    # -- update
+
+    assert_equal 1, db.ask("UPDATE t1 SET b = 'b' WHERE idx=12")
+    assert_equal 2, db.ask("UPDATE t1 SET b = 'c'")
+    assert_equal 0, db.ask("UPDATE t1 SET b = 'b' WHERE idx=12345")
+    
+    # assert_equal 1, db.exec("INSERT INTO t1 (idx,b) VALUES(13, '')")
+    # assert_equal(13, r)
+    # 
+
+    # -- delete
+    assert_equal 1, db.ask("DELETE FROM t1 WHERE idx=12")
+    assert_equal 0, db.exec("DELETE FROM t1 WHERE idx=12")
+    assert_equal 1, db.exec("DELETE FROM t1 WHERE idx=13")
+  end
+
+  def test_type_conversion
+    assert_equal(1, db.ask("SELECT 1"))
+    assert_equal('1', db.ask("SELECT '1'"))
+  end
+
+  def test_row_conversion
+    assert_equal(1, db.ask("SELECT 1"))
+    assert_equal([1, 2], db.ask("SELECT 1, 2"))
+  end
+
+  def test_arguments
+    db.ask "CREATE TABLE t1(idx INTEGER PRIMARY KEY, b TEXT)"
+    assert_equal nil, db.ask("SELECT idx FROM t1 WHERE idx=?", 12)
+
+    db.ask("INSERT INTO t1 (idx,b) VALUES(12, 'twelve')")
+    db.ask("INSERT INTO t1 (idx,b) VALUES(13, 'thirteen')")
+    db.ask("INSERT INTO t1 (idx,b) VALUES(0, NULL)")
+  
+    assert_equal 3, db.ask("SELECT COUNT(*) FROM t1")
+    assert_equal 12, db.ask("SELECT idx FROM t1 WHERE idx=12")
+    assert_equal 12, db.ask("SELECT idx FROM t1 WHERE idx=?", 12)
+    assert_equal 12, db.ask("SELECT idx FROM t1 WHERE b=?", "twelve")
+    assert_equal 12, db.ask("SELECT idx FROM t1 WHERE b=? AND idx=?", "twelve", 12)
+  end
+
+  def test_transaction
+    db.ask "CREATE TABLE t1(idx INTEGER PRIMARY KEY, b TEXT)"
+    
+    count = db.transaction do
+      db.ask("INSERT INTO t1 (idx,b) VALUES(12, 'twelve')")
+      db.ask("SELECT COUNT(*) FROM t1")
+    end
+    assert_equal 1, count
+     
+    assert_equal 1, db.ask("SELECT COUNT(*) FROM t1")
+
+    db.transaction do
+      db.ask("INSERT INTO t1 (idx,b) VALUES(13, 'twelve')")
+      assert_equal 2, db.ask("SELECT COUNT(*) FROM t1")
+      db.rollback!
+    end
+    
+    assert_equal 1, db.ask("SELECT COUNT(*) FROM t1")
+  end
+
+  def test_insert
+    assert_equal([], db.tables)
+    t1 = db.table "CREATE TABLE t1(idx INTEGER PRIMARY KEY, b TEXT)"
+    
+    assert_equal(["t1"], db.tables)
+    assert_equal("t1", t1.table_name)
+
+    assert_equal nil, db.table("t2")
+
+    t1.insert [1, "1"], [2, "2"]
+    assert_equal [[1], [2]], db.exec("SELECT idx FROM t1")
+
+    assert_equal(3, t1.insert([3, "3"]))
+
+    assert_equal(4, t1.insert(:idx => 4))
+  end
+
+  def test_kv_table
+    kv = db.key_value_table("kv")
+    assert_equal [ "kv" ], db.tables
+
+    kv["x"] = "y"
+    assert_equal 1, db.ask("SELECT COUNT(*) FROM kv")
+    assert_equal "y", kv["x"]
+
+    kv["x"] = nil
+    assert_equal 0, db.ask("SELECT COUNT(*) FROM kv")
+    assert_equal nil, kv["x"]
+
+    count = 0
+    
+    r = kv.cached "x" do "y" end 
+    assert_equal(r, "y")
+
+    r = kv.cached "x" do raise "Yo"; "y" end
+    assert_equal(r, "y")
+  end
+end

data/test/test_micro_sql_sqlite3.rb

@@ -0,0 +1,173 @@
+require 'helper'
+require 'tmpdir'
+require 'fileutils'
+
+class TestMicroSqlite3 < Test::Unit::TestCase
+  attr :tmpdir
+  
+  def setup
+    @tmpdir = Dir.mktmpdir
+  end
+
+  def teardown
+    FileUtils.rm_rf(@tmpdir) if @tmpdir
+  end
+
+  def db
+    @db ||= MicroSql.create "#{tmpdir}/test.sqlite3"
+  end
+  
+  def test_assert_creation_of_db_file_from_url
+    path = "#{tmpdir}/db.sqlite3"
+    assert !File.exists?(path)
+
+    url = "sqlite://#{path}"
+    db = MicroSql.create url
+    assert File.exists?(path)
+  end
+  
+  def test_assert_creation_of_db_file_from_path
+    path = "#{tmpdir}/db.sqlite3"
+    assert !File.exists?(path)
+
+    db = MicroSql.create path
+    assert File.exists?(path)
+  end
+  
+  def test_assert_create_tables
+    db.execute_batch <<-SQL
+    CREATE TABLE t1(idx INTEGER PRIMARY KEY, b INTEGER);
+    CREATE TABLE t2(a INTEGER, b INTEGER);
+    SQL
+
+    assert_equal %w(t1 t2), db.tables.sort
+  end
+  
+  def test_ask_and_exec
+    db.ask "CREATE TABLE t1(idx INTEGER PRIMARY KEY, b INTEGER)"
+
+    # -- insert
+    assert_equal 12, db.ask("INSERT INTO t1 (idx,b) VALUES(12, '')")
+    assert_equal 13, db.exec("INSERT INTO t1 (idx,b) VALUES(13, '')")
+
+    assert_raise(MicroSql::Error) {  
+      assert_equal 1, db.exec("INSERT INTO t1 (idx,b) VALUES(13, '')")
+    }
+    assert_raise(MicroSql::Error) {  
+      assert_equal 1, db.ask("INSERT INTO t1 (idx,b) VALUES(13, '')")
+    }
+    
+    # -- update
+
+    assert_equal 1, db.ask("UPDATE t1 SET b = 'b' WHERE idx=12")
+    assert_equal 2, db.ask("UPDATE t1 SET b = 'c'")
+    assert_equal 0, db.ask("UPDATE t1 SET b = 'b' WHERE idx=12345")
+    
+    # assert_equal 1, db.exec("INSERT INTO t1 (idx,b) VALUES(13, '')")
+    # assert_equal(13, r)
+    # 
+
+    # -- delete
+    assert_equal 1, db.ask("DELETE FROM t1 WHERE idx=12")
+    assert_equal 0, db.exec("DELETE FROM t1 WHERE idx=12")
+    assert_equal 1, db.exec("DELETE FROM t1 WHERE idx=13")
+  end
+
+  def test_preparation
+    assert_equal(0, db.send(:prepared_queries).length)
+
+    db.exec("SELECT 1")
+    assert_equal(1, db.send(:prepared_queries).length)
+
+    db.ask("SELECT 2")
+    assert_equal(2, db.send(:prepared_queries).length)
+
+    db.ask("SELECT 2")
+    assert_equal(2, db.send(:prepared_queries).length)
+
+    db.exec!("SELECT 3")
+    assert_equal(2, db.send(:prepared_queries).length)
+  end
+
+  def test_type_conversion
+    assert_equal(1, db.ask("SELECT 1"))
+    assert_equal('1', db.ask("SELECT '1'"))
+  end
+
+  def test_row_conversion
+    assert_equal(1, db.ask("SELECT 1"))
+    assert_equal([1, 2], db.ask("SELECT 1, 2"))
+  end
+
+  def test_arguments
+    db.ask "CREATE TABLE t1(idx INTEGER PRIMARY KEY, b INTEGER)"
+    db.ask("INSERT INTO t1 (idx,b) VALUES(12, 'twelve')")
+    db.ask("INSERT INTO t1 (idx,b) VALUES(13, 'thirteen')")
+    db.ask("INSERT INTO t1 (idx,b) VALUES(0, NULL)")
+  
+    assert_equal 3, db.ask("SELECT COUNT(*) FROM t1")
+    assert_equal 12, db.ask("SELECT idx FROM t1 WHERE idx=?", 12)
+    assert_equal 12, db.ask("SELECT idx FROM t1 WHERE b=?", "twelve")
+    assert_equal 12, db.ask("SELECT idx FROM t1 WHERE b=? AND idx=?", "twelve", 12)
+    assert_equal 0, db.ask("SELECT idx FROM t1 WHERE b IS ?", nil)
+    assert_equal nil, db.ask("SELECT idx FROM t1 WHERE b=?", nil) # b=NULL is never true but always NULL
+  end
+
+  def test_transaction
+    db.ask "CREATE TABLE t1(idx INTEGER PRIMARY KEY, b INTEGER)"
+    
+    count = db.transaction do
+      db.ask("INSERT INTO t1 (idx,b) VALUES(12, 'twelve')")
+      db.ask("SELECT COUNT(*) FROM t1")
+    end
+    assert_equal 1, count
+     
+    assert_equal 1, db.ask("SELECT COUNT(*) FROM t1")
+
+    db.transaction do
+      db.ask("INSERT INTO t1 (idx,b) VALUES(13, 'twelve')")
+      assert_equal 2, db.ask("SELECT COUNT(*) FROM t1")
+      db.rollback!
+    end
+    
+    assert_equal 1, db.ask("SELECT COUNT(*) FROM t1")
+  end
+
+  def test_insert
+    assert_equal([], db.tables)
+    t1 = db.table "CREATE TABLE t1(idx INTEGER PRIMARY KEY, b TEXT)"
+    
+    assert_equal(["t1"], db.tables)
+    assert_equal("t1", t1.table_name)
+
+    assert_equal nil, db.table("t2")
+
+    t1.insert [1, "1"], [2, "2"]
+    assert_equal [[1], [2]], db.exec("SELECT idx FROM t1")
+
+    assert_equal(3, t1.insert([3, "3"]))
+
+    assert_equal(4, t1.insert(:idx => 4))
+  end
+
+  def test_kv_table
+    kv = db.key_value_table("kv")
+    assert_equal [ "kv" ], db.tables
+
+    kv["x"] = "y"
+    assert_equal 1, db.ask("SELECT COUNT(*) FROM kv")
+    assert_equal "y", kv["x"]
+
+    kv["x"] = nil
+    assert_equal 0, db.ask("SELECT COUNT(*) FROM kv")
+    assert_equal nil, kv["x"]
+
+    count = 0
+    
+    r = kv.cached "x" do "y" end 
+    assert_equal(r, "y")
+
+    r = kv.cached "x" do raise "Yo"; "y" end
+    assert_equal(r, "y")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: micro_sql
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,33 +9,33 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-30 00:00:00.000000000Z
+date: 2012-04-02 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: shoulda
-  requirement: &70301986679420 !ruby/object:Gem::Requirement
+  name: pg
+  requirement: &70130046726220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
-  version_requirements: *70301986679420
+  version_requirements: *70130046726220
 - !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: &70301986678800 !ruby/object:Gem::Requirement
+  name: sqlite3
+  requirement: &70130046701360 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '3.12'
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
-  version_requirements: *70301986678800
+  version_requirements: *70130046701360
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70301986678140 !ruby/object:Gem::Requirement
+  requirement: &70130046688900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,32 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70301986678140
+  version_requirements: *70130046688900
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &70301986677540 !ruby/object:Gem::Requirement
+  requirement: &70130046663760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70130046663760
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70130046580920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70130046580920
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &70130046570120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70301986677540
+  version_requirements: *70130046570120
 description: You only need a single method to talk to your database...
 email: eno@open-lab.org
 executables: []
@@ -71,13 +93,16 @@ files:
 - Rakefile
 - VERSION
 - lib/micro_sql.rb
+- lib/micro_sql/key_value_table.rb
 - lib/micro_sql/pg_adapter.rb
-- lib/micro_sql/settings.rb
 - lib/micro_sql/sqlite_adapter.rb
 - lib/micro_sql/table.rb
 - micro_sql.gemspec
+- script/watchr
 - test/helper.rb
 - test/test_micro_sql.rb
+- test/test_micro_sql_pg.rb
+- test/test_micro_sql_sqlite3.rb
 homepage: http://github.com/radiospiel/micro_sql
 licenses:
 - MIT
@@ -93,7 +118,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4072090889044300624
+      hash: -292595813074764874
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/lib/micro_sql/settings.rb

@@ -1,56 +0,0 @@
-# -- The settings table; has support for ttl etc. ---------------------------
-
-require "json"
-
-class MicroSql::SettingsTable < MicroSql::Table
-  def initialize(db)
-    super db, "CREATE TABLE settings(uid TEXT PRIMARY KEY, value TEXT, ttl BIGINT)"
-  end
-  
-  def [](key)
-    value, ttl = db.ask("SELECT value, ttl FROM settings WHERE uid=?", key)
-    decode(value) if !ttl || ttl < Time.now.to_i
-  end
-
-  def cached(key, ttl, &block)
-    update(key, yield, ttl)
-  end
-
-  def update(key, value, ttl = nil)
-    if value
-      encoded = encode(value)
-      ttl += Time.now.to_i if ttl
-      affected = @db.ask("UPDATE settings SET value=?, ttl=? WHERE uid=?", encoded, ttl, key)
-      if affected == 0
-        @db.ask("INSERT INTO settings(value, ttl, uid) VALUES(?,?,?)", encoded, ttl, key)
-      end
-    else
-      @db.ask("DELETE FROM settings WHERE uid=?", key)
-    end
-
-    value
-  end
-
-  alias :[]= :update
-
-  def decode(io)
-    return unless io
-    JSON.parse("[#{io}]").first
-  end
-  
-  def encode(value)
-    value && value.to_json
-  end
-end
-
-require "forwardable"
-
-class MicroSql::Settings
-  def initialize(url)
-    @db = MicroSql.create(url)
-    @settings_table = MicroSql::SettingsTable.new @db
-  end
-
-  extend Forwardable
-  delegate [ :[], :cached, :update, :[]= ] => :@settings_table
-end