datamapper 0.1.1 → 0.2.0

data/plugins/dataobjects/do_postgres.rb

@@ -0,0 +1,181 @@
+require 'postgres_c'
+require 'do'
+
+module DataObject
+  module Postgres
+    TYPES = Hash[*Postgres_c.constants.select {|x| x.include?("OID")}.map {|x| [Postgres_c.const_get(x), x.gsub(/_?OID$/, "")]}.flatten]
+    QUOTE_STRING = "'"
+    QUOTE_COLUMN = "\""
+    
+    class Connection < DataObject::Connection
+      attr_reader :db
+      
+      def initialize(connection_string)
+        @state = STATE_CLOSED        
+        @connection_string = connection_string
+      end
+      
+      def open
+        @db = Postgres_c.PQconnectdb(@connection_string)
+        if Postgres_c.PQstatus(@db) != Postgres_c::CONNECTION_OK
+          raise ConnectionFailed, "The connection with connection string #{@connection_string} failed\n#{Postgres_c.PQerrorMessage(@db)}"
+        end
+        @state = STATE_OPEN
+        true
+      end
+      
+      def close
+        Postgres_c.PQfinish(@db)
+        @state = STATE_CLOSED
+        true
+      end
+      
+      def create_command(text)
+        Command.new(self, text)
+      end
+      
+    end
+    
+    class Reader < DataObject::Reader
+      
+      def initialize(db, reader)
+        @reader = reader
+        case Postgres_c.PQresultStatus(reader)
+        when Postgres_c::PGRES_COMMAND_OK
+          @records_affected = Postgres_c.PQcmdTuples(reader).to_i
+          close
+        when Postgres_c::PGRES_TUPLES_OK
+          @fields, @field_types = [], []
+          @field_count = Postgres_c.PQnfields(@reader)
+          i = 0
+          while(i < @field_count)
+            @field_types.push(Postgres_c.PQftype(@reader, i))
+            @fields.push(Postgres_c.PQfname(@reader, i))
+            i += 1
+          end
+          @rows = Postgres_c.PQntuples(@reader)
+          @has_rows = @rows > 0
+          @cursor = 0
+          @state = STATE_OPEN
+        end
+      end
+      
+      def close
+        if @state != STATE_CLOSED
+          Postgres_c.PQclear(@reader)
+          @state = STATE_CLOSED
+          true
+        else
+          false
+        end
+      end
+      
+      def data_type_name(col)
+        
+      end
+      
+      def name(col)
+        super
+        Postgres_c.PQfname(@reader, col)
+      end
+      
+      def get_index(name)
+        super
+        @fields.index(name)
+      end
+
+      def null?(idx)
+        super
+        Postgres_c.PQgetisnull(@reader, @cursor, idx) != 0
+      end
+      
+      def item(idx)
+        super
+        val = Postgres_c.PQgetvalue(@reader, @cursor, idx)
+        typecast(val, @field_types[idx])
+      end
+      
+      def next
+        super   
+        if @cursor >= @rows - 1
+          @cursor = nil
+          close
+          return nil
+        end
+        @cursor += 1
+        true
+      end
+      
+      protected
+      def native_type(col)
+        TYPES[Postgres_c.PQftype(@reader, col)]
+      end
+      
+      def typecast(val, field_type)
+        return nil if val.nil?
+        case TYPES[field_type]
+          when "BOOL"
+            val == "t"
+          when "INT2", "INT4", "OID", "TID", "XID", "CID", "INT8"
+            val.to_i
+          when "FLOAT4", "FLOAT8", "NUMERIC", "CASH"
+            val.to_f
+          when "TIMESTAMP", "TIMETZ", "TIMESTAMPTZ"
+            DateTime.parse(val)
+          when "TIME"
+            DateTime.parse(val).to_time
+          when "DATE"
+            Date.parse(val)
+          else
+            val
+        end
+      end
+      
+    end
+    
+    class ResultData < DataObject::ResultData
+      
+      def last_insert_row
+        @last_insert_row ||= begin
+          reader = @conn.create_command("select lastval()").execute_reader
+          reader.item(0).to_i
+        rescue QueryError
+          raise NoInsertError, "You tried to get the last inserted row without doing an insert\n#{Postgres_c.PQerrorMessage(@conn.db)}"
+        ensure
+          reader and reader.close
+        end
+      end      
+      
+    end
+    
+    class Command < DataObject::Command
+      
+      def execute_reader
+        super
+        reader = Postgres_c.PQexec(@connection.db, @text)
+        unless [Postgres_c::PGRES_COMMAND_OK, Postgres_c::PGRES_TUPLES_OK].include?(Postgres_c.PQresultStatus(reader))
+          raise QueryError, "Your query failed.\n#{Postgres_c.PQerrorMessage(@connection.db)}QUERY: \"#{@text}\""
+        end
+        Reader.new(@connection.db, reader)
+      end
+      
+      def execute_non_query
+        super
+        results = Postgres_c.PQexec(@connection.db, @text)
+        status = Postgres_c.PQresultStatus(results)
+        if status == Postgres_c::PGRES_TUPLES_OK
+          Postgres_c.PQclear(results)
+          raise QueryError, "Your query failed or you tried to execute a SELECT query through execute_non_reader\n#{Postgres_c.PQerrorMessage(@connection.db)}\nQUERY: \"#{@text}\""
+        elsif status != Postgres_c::PGRES_COMMAND_OK
+          Postgres_c.PQclear(results)
+          raise QueryError, "Your query failed.\n#{Postgres_c.PQerrorMessage(@connection.db)}\nQUERY: \"#{@text}\""
+        end
+        rows_affected = Postgres_c.PQcmdTuples(results).to_i
+        Postgres_c.PQclear(results)
+        ResultData.new(@connection, rows_affected)
+      end
+      
+    end
+    
+  end
+end

data/plugins/dataobjects/do_sqlite3.rb

@@ -0,0 +1,153 @@
+require 'sqlite3_c'
+require 'do'
+
+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, "The connection with connection string #{@connection_string} failed\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
+      
+    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 close
+        if @state != STATE_CLOSED
+          Sqlite3_c.sqlite3_finalize(@reader)
+          @state = STATE_CLOSED
+          true
+        else
+          false
+        end
+      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 next
+        result = Sqlite3_c.sqlite3_step(@reader)
+        unless result == Sqlite3_c::SQLITE_ROW
+          close
+          nil
+        else
+          true
+        end
+      end
+      
+    end
+    
+    class Command < DataObject::Command
+      
+      def execute_reader
+        super
+        result, reader = Sqlite3_c.sqlite3_prepare_v2(@connection.db, @text, @text.size + 1)
+        unless result == Sqlite3_c::SQLITE_OK
+          raise QueryError, "Your query failed.\n#{Sqlite3_c.sqlite3_errmsg(@connection.db)}\nQUERY: \"#{@text}\""
+        else
+          Reader.new(@connection.db, reader)
+        end
+      end
+      
+      def execute_non_query
+        super
+        result, reader = Sqlite3_c.sqlite3_prepare_v2(@connection.db, @text, -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: \"#{@text}\""
+        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
+      
+    end
+    
+  end
+end

data/plugins/dataobjects/spec/do_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Connectable", :shared => true do
+  before :each do
+    @c = $adapter_module::Connection.new($connection_string)
+    @c.open
+  end
+  
+  after :each do
+    @c.close
+  end
+end
+
+describe "DO::Connection" do
+  it_should_behave_like "Connectable"
+  
+  it "should be able to be opened" do
+    @c.should be_is_a($adapter_module::Connection)
+    @c.state.should == 0
+  end
+
+  it "should be able to create a related command" do
+    @c.open
+    cmd = @c.create_command("select * from table1")
+    cmd.connection.should == @c
+  end
+  
+end
+
+describe "DO::Command" do
+  it_should_behave_like "Connectable"
+
+  def delete_3
+    cmd = @c.create_command("DELETE from table1 where id > 2")
+    cmd.execute_non_query
+  end
+
+  it "should be able to be executed if it's a select" do
+    cmd = @c.create_command("select * from table1")
+    r = cmd.execute_reader
+    r.has_rows?.should be_true
+    r.close
+  end
+  
+  it "should be able to be executed if it's not a select" do
+    begin
+      cmd = @c.create_command("INSERT into table1(#{$escape}int#{$escape}) VALUES(7)")
+      result = cmd.execute_non_query
+      result.to_i.should == 1
+      result.class.to_s.should include("ResultData")
+      result.last_insert_row.should == 3
+    ensure
+      delete_3
+    end
+  end
+  
+  it "should throw an error if a select is passed to execute_non_query" do
+    cmd = @c.create_command("SELECT * from table1")
+    lambda { cmd.execute_non_query }.should raise_error(DataObject::QueryError)
+  end
+  
+  it "should immediately close the reader and populate records_affected if a modification is passed to execute_reader" do
+    if $adapter_module.to_s == "DataObject::Postgres"
+      cmd = @c.create_command("INSERT into table1(#{$escaped_columns}) VALUES(NULL, now(), false, now(), NULL)")      
+    else
+      cmd = @c.create_command("INSERT into table1(#{$escaped_columns}) VALUES(NULL, CURRENT_TIME, 0, CURRENT_DATE, NULL)")
+    end
+    r = cmd.execute_reader
+    r.records_affected.should == 1
+    lambda { r.name(0) }.should raise_error(DataObject::ReaderClosed)
+    delete_3
+  end
+  
+end
+
+describe "DO::Reader" do
+  
+  before :each do
+    @c = $adapter_module::Connection.new($connection_string)
+    @c.open
+    cmd = @c.create_command("select * from table1")
+    @r = cmd.execute_reader    
+  end
+  
+  after :each do
+    @c.close
+  end
+  
+  it "should be able to get the field count" do
+    @r.field_count.should == 6
+  end
+  
+  it "should be able to get field names" do
+    @r.name(0).should == "id"
+    @r.name(1).should == "int"
+    @r.name(2).should == "time"
+    @r.name(3).should == "bool"
+    @r.name(4).should == "date"
+    @r.name(5).should == "str"
+    @r.name(6).should == nil
+  end
+  
+  it "should be able to get field indexes" do
+    @r.get_index("id").should == 0
+    @r.get_index("int").should == 1
+    @r.get_index("time").should == 2
+    @r.get_index("bool").should == 3
+    @r.get_index("date").should == 4
+    @r.get_index("foo").should == nil
+  end
+
+  it "should be able to determine whether a particular field is null" do
+    @r.null?(0).should == false
+    @r.null?(1).should == true
+  end
+  
+  it "should be able to get a typecasted version of a particular field" do
+    case $adapter_module.to_s
+    when "DataObject::Sqlite3"
+      @r.item(0).should == 1
+      @r.item(1).should == nil
+      @r.item(2).class.should == String
+      @r.item(3).should == 0
+      @r.item(4).class.should == String
+    when "DataObject::Mysql"
+      @r.item(0).should == 1
+      @r.item(1).should == nil
+      @r.item(2).class.should == DateTime
+      @r.item(3).should == false
+      @r.item(4).class.should == Date
+    end
+  end
+  
+  it "should allow the use of the object being returned even after the reader is closed" do
+    val = @r.item(5)
+    val.should == "foo"
+  end
+  
+  it "should be able to get to the next row" do
+    @r.next.should == true
+    @r.item(0).should == 2
+  end
+  
+  it "should return nil and close the reader when the cursor reaches the end" do
+    @r.next
+    @r.next.should == nil
+    lambda { @r.name(0) }.should raise_error(DataObject::ReaderClosed)
+  end
+  
+end