do_sqlite3 0.2.5 → 0.9.2

data/ext/extconf.rb

@@ -1,11 +1,35 @@
-ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
+# ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
+#
+# require 'mkmf'
+#
+# SWIG_WRAP = "sqlite3_api_wrap.c"
+#
+# dir_config( "sqlite3", "/usr/local" )
+#
+# if have_header( "sqlite3.h" ) && have_library( "sqlite3", "sqlite3_open" )
+#   create_makefile( "sqlite3_c" )
+# end
 
+if RUBY_PLATFORM =~ /darwin/
+  ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
+
+  # On PowerPC the defaults are fine
+  ENV["RC_ARCHS"] = '' if `uname -m` =~ /^Power Macintosh/
+end
+
+# Loads mkmf which is used to make makefiles for Ruby extensions
 require 'mkmf'
 
-SWIG_WRAP = "sqlite3_api_wrap.c"
+# Give it a name
+extension_name = 'do_sqlite3_ext'
+
+dir_config("sqlite3")
 
-dir_config( "sqlite3", "/usr/local" )
+# NOTE: use GCC flags unless Visual C compiler is used
+$CFLAGS << ' -Wall ' unless RUBY_PLATFORM =~ /mswin/
 
+# Do the work
+# create_makefile(extension_name)
 if have_header( "sqlite3.h" ) && have_library( "sqlite3", "sqlite3_open" )
-  create_makefile( "sqlite3_c" )
+  create_makefile(extension_name)
 end

data/lib/do_sqlite3.rb

@@ -1,210 +1,5 @@
-require 'sqlite3_c'
-require 'data_objects'
-
-module DataObject
-  module Sqlite3
-    
-    QUOTE_STRING = "\""
-    QUOTE_COLUMN = "'"
-    
-    class Connection < DataObject::Connection
-      
-      attr_reader :db
-      
-      def initialize(connection_string)
-        @state = STATE_CLOSED        
-        @connection_string = connection_string
-        @conn = Hash[*connection_string.split(" ").map {|x| x.split("=")}.flatten]["dbname"]
-      end
-
-      def open
-        r, d = Sqlite3_c.sqlite3_open(@conn)
-        unless r == Sqlite3_c::SQLITE_OK
-          raise ConnectionFailed, "Unable to connect to database with provided connection string. \n#{Sqlite3_c.sqlite3_errmsg(d)}"
-        else
-          @db = d
-        end
-        @state = STATE_OPEN
-        true
-      end
-
-      def close
-        Sqlite3_c.sqlite3_close(@db)
-        @state = STATE_CLOSED
-        true
-      end
-      
-      def create_command(text)
-        Command.new(self, text)
-      end
-      
-      def begin_transaction
-        Transaction.new(self)
-      end
-
-    end
-
-    class Transaction < DataObject::Transaction
-
-      attr_reader :connection
-
-      def initialize(conn)
-        @connection = conn
-        exec_sql("BEGIN")
-      end
 
-      # Commits the transaction
-      def commit
-        exec_sql("COMMIT")
-      end
-
-      # Rolls back the transaction
-      def rollback(savepoint = nil)
-        raise NotImplementedError, "SQLite3 does not support savepoints" if savepoint
-        exec_sql("ROLLBACK")
-      end
-
-      # Creates a savepoint for rolling back later (not commonly supported)
-      def save(name)
-        raise NotImplementedError, "SQLite3 does not support savepoints"
-      end
-
-      def create_command(*args)
-        @connection.create_command(*args)
-      end
-
-      protected
-
-      def exec_sql(sql)
-        @connection.logger.debug { sql }
-        result, reader = Sqlite3_c.sqlite3_prepare_v2(@connection.db, sql, sql.size + 1)
-        exec_result = Sqlite3_c.sqlite3_step(reader)
-        Sqlite3_c.sqlite3_finalize(reader)
-        exec_result
-      end
-
-    end
-    
-    class Reader < DataObject::Reader
-      
-      def initialize(db, reader)
-        @reader = reader
-        result = Sqlite3_c.sqlite3_step(reader)        
-        rows_affected, field_count = Sqlite3_c.sqlite3_changes(db), Sqlite3_c.sqlite3_column_count(reader)
-        if field_count == 0
-          @records_affected = rows_affected
-          close
-        else
-          @field_count = field_count
-          @fields, @field_types = [], []
-          i = 0
-          while(i < @field_count)
-            @field_types.push(Sqlite3_c.sqlite3_column_type(reader, i))
-            @fields.push(Sqlite3_c.sqlite3_column_name(reader, i))
-            i += 1
-          end
-          case result
-          when Sqlite3_c::SQLITE_BUSY, Sqlite3_c::SQLITE_ERROR, Sqlite3_c::SQLITE_MISUSE
-            raise ReaderError, "An error occurred while trying to get the next row\n#{Sqlite3_c.sqlite3_errmsg(db)}"
-          else
-            @has_rows = result == Sqlite3_c::SQLITE_ROW
-            @state = STATE_OPEN
-            close unless @has_rows
-          end
-        end
-      end
-      
-      def real_close
-        Sqlite3_c.sqlite3_finalize(@reader)
-      end
-      
-      def name(idx)
-        super
-        @fields[idx]
-      end
-      
-      def get_index(name)
-        super
-        @fields.index(name)
-      end
-      
-      def null?(idx)
-        super
-        item(idx).nil?
-      end
-      
-      def item(idx)
-        super
-        case @field_types[idx]
-        when 1 # SQLITE_INTEGER
-          Sqlite3_c.sqlite3_column_int(@reader, idx).to_i
-        when 2 # SQLITE_FLOAT
-          Sqlite3_c.sqlite3_column_double(@reader, idx)
-        else
-          Sqlite3_c.sqlite3_column_text(@reader, idx)
-        end
-      end
-      
-      def each
-        return unless has_rows?
-        
-        while(true) do
-          yield
-          break unless Sqlite3_c.sqlite3_step(@reader) == Sqlite3_c::SQLITE_ROW
-        end
-      end
-      
-    end
-    
-    class Command < DataObject::Command
-      
-      def execute_reader(*args)
-        super
-        sql = escape_sql(args)
-        @connection.logger.debug { sql }
-        result, ptr = Sqlite3_c.sqlite3_prepare_v2(@connection.db, sql, sql.size + 1)
-        unless result == Sqlite3_c::SQLITE_OK
-          raise QueryError, "Your query failed.\n#{Sqlite3_c.sqlite3_errmsg(@connection.db)}\nQUERY: \"#{sql}\""
-        else
-          reader = Reader.new(@connection.db, ptr)
-          
-          if block_given?
-            return_value = yield(reader)
-            reader.close
-            return_value
-          else
-            reader
-          end
-        end
-      end
-      
-      def execute_non_query(*args)
-        super
-        sql = escape_sql(args)
-        @connection.logger.debug { sql }
-        result, reader = Sqlite3_c.sqlite3_prepare_v2(@connection.db, sql, -1)
-        unless result == Sqlite3_c::SQLITE_OK
-          Sqlite3_c.sqlite3_finalize(reader)
-          raise QueryError, "Your query failed.\n#{Sqlite3_c.sqlite3_errmsg(@connection.db)}\nQUERY: \"#{sql}\""
-        else
-          exec_result = Sqlite3_c.sqlite3_step(reader)
-          Sqlite3_c.sqlite3_finalize(reader)
-          if exec_result == Sqlite3_c::SQLITE_DONE
-            ResultData.new(@connection, Sqlite3_c.sqlite3_changes(@connection.db), Sqlite3_c.sqlite3_last_insert_rowid(@connection.db))
-          else
-            raise QueryError, "Your query failed or you tried to execute a SELECT query through execute_non_reader\n#{Sqlite3_c.sqlite3_errmsg(@connection.db)}\nQUERY: \"#{@text}\""
-          end
-        end
-      end
-      
-      def quote_symbol(value)
-        value.to_s
-      end
-      
-      def quote_boolean(value)
-        value ? '1' : '0'
-      end
-    end
-    
-  end
-end
+require 'rubygems'
+require 'data_objects'
+require 'do_sqlite3_ext'
+require 'do_sqlite3/transaction'

data/lib/do_sqlite3/transaction.rb

@@ -0,0 +1,36 @@
+
+module DataObjects
+
+  module Sqlite3
+
+    class Transaction < DataObjects::Transaction
+
+      def begin
+        cmd = "BEGIN"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def commit
+        cmd = "COMMIT"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def rollback
+        cmd = "ROLLBACK"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def rollback_prepared
+        cmd = "ROLLBACK"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def prepare
+        # Eek, I don't know how to do this. Lets hope a commit arrives soon...
+      end
+
+    end
+
+  end
+
+end

data/spec/integration/do_sqlite3_spec.rb

@@ -0,0 +1,244 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe "DataObjects::Sqlite3" do
+  include Sqlite3SpecHelpers
+
+  it "should raise error on bad connection string" do
+    lambda { DataObjects::Connection.new("sqlite3:///ac0d9iopalmsdcasd/asdc9pomasd/test.db") }.should raise_error("unable to open database file")
+  end
+end
+
+NOW = DateTime.now
+
+describe "DataObjects::Sqlite3::Result" do
+  include Sqlite3SpecHelpers
+
+  before(:all) do
+    @connection = DataObjects::Connection.new("sqlite3://#{File.expand_path(File.dirname(__FILE__))}/test.db")
+  end
+
+  it "should raise an error for a bad query" do
+    command = @connection.create_command("INSER INTO table_which_doesnt_exist (id) VALUES (1)")
+    lambda { command.execute_non_query }.should raise_error('near "INSER": syntax error')
+
+    command = @connection.create_command("INSERT INTO table_which_doesnt_exist (id) VALUES (1)")
+    lambda { command.execute_non_query }.should raise_error("no such table: table_which_doesnt_exist")
+
+    command = @connection.create_command("SELECT * FROM table_which_doesnt_exist")
+    lambda { command.execute_reader }.should raise_error("no such table: table_which_doesnt_exist")
+  end
+
+  it "should return the affected rows and insert_id" do
+    command = @connection.create_command("DROP TABLE users")
+    command.execute_non_query rescue nil
+    command = @connection.create_command("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, type TEXT, age INTEGER, created_at DATETIME, balance DECIMAL default '0.00')")
+    result = command.execute_non_query
+    command = @connection.create_command("INSERT INTO users (name) VALUES ('test')")
+    result = command.execute_non_query
+    result.insert_id.should == 1
+    result.to_i.should == 1
+  end
+
+  it "should do a reader query" do
+    command = @connection.create_command("SELECT * FROM users")
+    reader = command.execute_reader
+
+    lambda { reader.values }.should raise_error
+
+    while ( reader.next! )
+      lambda { reader.values }.should_not raise_error
+      reader.values.should be_a_kind_of(Array)
+    end
+
+    lambda { reader.values }.should raise_error
+
+    reader.close
+  end
+
+  it "should do a paramaterized reader query" do
+    command = @connection.create_command("SELECT * FROM users WHERE id = ?")
+    reader = command.execute_reader(1)
+    reader.next!
+
+    reader.values[0].should == 1
+
+    reader.next!
+
+    lambda { reader.values }.should raise_error
+
+    reader.close
+  end
+
+  it "should do a custom typecast reader" do
+    command = @connection.create_command("SELECT name, id FROM users")
+    command.set_types [String, String]
+    reader = command.execute_reader
+
+    while ( reader.next! )
+      reader.fields.should == ["name", "id"]
+      reader.values.each { |v| v.should be_a_kind_of(String) }
+    end
+
+    reader.close
+
+  end
+
+  it "should handle a null value" do
+    id = insert("INSERT INTO users (name) VALUES (NULL)")
+    select("SELECT name from users WHERE name is null") do |reader|
+      reader.values[0].should == nil
+    end
+  end
+
+  it "should not convert empty strings to null" do
+    id = insert("INSERT INTO users (name) VALUES ('')")
+    select("SELECT name FROM users WHERE id = ?", [String], id) do |reader|
+      reader.values.first.should == ''
+    end
+  end
+
+  it "should raise an error when you pass too many or too few types for the expected result set" do
+    lambda { select("SELECT name, id FROM users", [String, Integer, String]) }.should raise_error(Sqlite3Error)
+  end
+
+  it "should do a custom typecast reader with Class" do
+    class Person; end
+
+    id = insert("INSERT INTO users (name, age, type) VALUES (?, ?, ?)", 'Sam', 30, Person)
+
+    select("SELECT name, age, type FROM users WHERE id = ?", [String, Integer, Class], id) do |reader|
+      reader.fields.should == ["name", "age", "type"]
+      reader.values.should == ["Sam", 30, Person]
+    end
+
+    exec("DELETE FROM users WHERE id = ?", id)
+  end
+
+  [
+    NOW.strftime('%Y-%m-%dT%H:%M:%S'),
+    NOW.strftime('%Y-%m-%d %H:%M:%S')
+  ].each do |raw_value|
+    it "should return #{NOW.to_s} using the LOCAL timezone when typecasting '#{raw_value}'" do
+
+      # Insert a timezone-less DateTime into the DB
+      id = insert("INSERT INTO users (name, age, type, created_at) VALUES (?, ?, ?, ?)", 'Sam', 30, Person, raw_value)
+
+      select("SELECT created_at FROM users WHERE id = ?", [DateTime], id) do |reader|
+        reader.values.last.to_s.should == NOW.to_s
+      end
+
+      exec("DELETE FROM users WHERE id = ?", id)
+    end
+  end
+
+  it "should return DateTimes using the same timezone that was used to insert it" do
+    pending "improved support for timezone checking"
+
+    dates = [
+      NOW,
+      NOW.new_offset( (-11 * 3600).to_r / 86400), # GMT -11:00
+      NOW.new_offset( (-9 * 3600 + 10 * 60).to_r / 86400), # GMT -9:10
+      NOW.new_offset( (-8 * 3600).to_r / 86400), # GMT -08:00
+      NOW.new_offset( (+3 * 3600).to_r / 86400), # GMT +03:00
+      NOW.new_offset( (+5 * 3600 + 30 * 60).to_r / 86400)  # GMT +05:30 (New Delhi)
+    ]
+
+    dates.each do |date|
+      id = insert("INSERT INTO users (name, age, type, created_at) VALUES (?, ?, ?, ?)", 'Sam', 30, Person, date)
+
+      select("SELECT created_at FROM users WHERE id = ?", [DateTime], id) do |reader|
+        reader.values.last.year.should == date.year
+        reader.values.last.month.should == date.month
+        reader.values.last.day.should == date.day
+        reader.values.last.hour.should == date.hour
+        reader.values.last.min.should == date.min
+        reader.values.last.sec.should == date.sec
+        reader.values.last.zone.should == date.zone
+      end
+
+      exec("DELETE FROM users WHERE id = ?", id)
+    end
+  end
+
+  it "should return a BigDecimal" do
+    balance = BigDecimal.new('10000000000.00')
+
+    id = insert("INSERT INTO users (name, age, type, created_at, balance) VALUES (?, ?, ?, ?, ?)", 'Scott', 27, Person, DateTime.now, balance)
+
+    select("SELECT balance FROM users WHERE id = ?", [BigDecimal], id) do |reader|
+      reader.values.last.should == balance
+    end
+  end
+
+  describe "quoting" do
+
+    before do
+      @connection.create_command("DROP TABLE IF EXISTS sail_boats").execute_non_query
+      @connection.create_command("CREATE TABLE sail_boats ( id INTEGER PRIMARY KEY, name VARCHAR(50), port VARCHAR(50), notes VARCHAR(50), vintage BOOLEAN )").execute_non_query
+      command = @connection.create_command("INSERT INTO sail_boats (id, name, port, name, vintage) VALUES (?, ?, ?, ?, ?)")
+      command.execute_non_query(1, "A", "C", "Fortune Pig!", false)
+      command.execute_non_query(2, "B", "B", "Happy Cow!", true)
+      command.execute_non_query(3, "C", "A", "Spoon", true)
+    end
+
+    it "should quote a String" do
+      command = @connection.create_command("INSERT INTO users (name) VALUES (?)")
+      result = command.execute_non_query("John Doe")
+      result.to_i.should == 1
+    end
+
+    it "should quote multiple values" do
+      command = @connection.create_command("INSERT INTO users (name, age) VALUES (?, ?)")
+      result = command.execute_non_query("Sam Smoot", 1)
+      result.to_i.should == 1
+    end
+
+
+    it "should handle boolean columns gracefully" do
+      command = @connection.create_command("INSERT INTO sail_boats (id, name, port, name, vintage) VALUES (?, ?, ?, ?, ?)")
+      result = command.execute_non_query(4, "Scooner", "Port au Prince", "This is one gangster boat!", true)
+      result.to_i.should == 1
+    end
+
+    it "should quote an Array" do
+      command = @connection.create_command("SELECT id, notes FROM sail_boats WHERE (id IN ?)")
+      reader = command.execute_reader([1, 2, 3])
+
+      i = 1
+      while(reader.next!)
+        reader.values[0].should == i
+        i += 1
+      end
+    end
+
+    it "should quote an Array with NULL values returned" do
+      command = @connection.create_command("SELECT id, NULL AS notes FROM sail_boats WHERE (id IN ?)")
+      reader = command.execute_reader([1, 2, 3])
+
+      i = 1
+      while(reader.next!)
+        reader.values[0].should == i
+        i += 1
+      end
+    end
+
+    it "should quote an Array with NULL values returned AND set_types called" do
+      command = @connection.create_command("SELECT id, NULL AS notes FROM sail_boats WHERE (id IN ?)")
+      command.set_types [ Integer, String ]
+
+      reader = command.execute_reader([1, 2, 3])
+
+      i = 1
+      while(reader.next!)
+        reader.values[0].should == i
+        i += 1
+      end
+    end
+
+    after do
+      @connection.create_command("DROP TABLE sail_boats").execute_non_query
+    end
+
+  end # describe "quoting"
+end