datamapper 0.2.3 → 0.2.4

data/plugins/dataobjects/do_postgres.rb

@@ -1,196 +0,0 @@
-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 real_close
-        Postgres_c.PQclear(@reader)
-      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 each
-        return unless has_rows?
-        
-        while(true) do
-          yield
-          break unless self.next
-        end
-      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) rescue nil
-          when "TIME"
-            DateTime.parse(val).to_time rescue nil
-          when "DATE"
-            Date.parse(val) rescue nil
-          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(*args)
-        super
-        sql = escape_sql(args)
-        @connection.logger.debug { sql }
-        ptr = Postgres_c.PQexec(@connection.db, sql)
-        unless [Postgres_c::PGRES_COMMAND_OK, Postgres_c::PGRES_TUPLES_OK].include?(Postgres_c.PQresultStatus(ptr))
-          raise QueryError, "Your query failed.\n#{Postgres_c.PQerrorMessage(@connection.db)}QUERY: \"#{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 }
-        results = Postgres_c.PQexec(@connection.db, sql)
-        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: \"#{sql}\""
-        elsif status != Postgres_c::PGRES_COMMAND_OK
-          Postgres_c.PQclear(results)
-          raise QueryError, "Your query failed.\n#{Postgres_c.PQerrorMessage(@connection.db)}\nQUERY: \"#{sql}\""
-        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

@@ -1,157 +0,0 @@
-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)
-        logger.debug { 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 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)
-        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)
-        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
-      
-    end
-    
-  end
-end

data/plugins/dataobjects/spec/do_spec.rb

@@ -1,150 +0,0 @@
-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

data/plugins/dataobjects/spec/spec_helper.rb

@@ -1,81 +0,0 @@
-require 'spec'
-$:.push File.join(File.dirname(__FILE__), '..')
-require 'do'
-
-adapter = (ENV["ADAPTER"] || "sqlite3").dup
-
-require "do_#{adapter}"
-
-adapter_module = adapter.dup
-adapter_module[0] = adapter_module[0].chr.upcase
-$adapter_module = DataObject.const_get(adapter_module)
-
-$connection_string = case adapter
-when "sqlite3"
-  "dbname=do_rb"
-when "mysql"
-  "socket=/tmp/mysql.sock user=root dbname=do_rb"
-when "postgres"
-  "dbname=do_rb"
-end
-
-$escape          = $adapter_module::QUOTE_COLUMN
-$escaped_columns = ["int", "time", "bool", "date", "str"].map {|x| "#{$escape}#{x}#{$escape}"}.join(", ")
-$quote = quote   = $adapter_module::QUOTE_STRING
-
-begin
-  c = $adapter_module::Connection.new($connection_string)
-  c.open
-  cmd = c.create_command("DROP TABLE table1")
-  cmd.execute_non_query rescue nil
-  if adapter == "mysql"
-    sql = <<-SQL
-    CREATE TABLE table1 (
-      `id` serial NOT NULL,
-      `int` int(11) default NULL,
-      `time` timestamp,
-      `bool` tinyint(1) default NULL,
-      `date` date default NULL,
-      `str` varchar(20) default NULL,
-      PRIMARY KEY (`id`)
-    );
-    SQL
-  elsif adapter == "sqlite3"
-    sql = <<-SQL
-    CREATE TABLE table1 (
-      `id` integer NOT NULL PRIMARY KEY AUTOINCREMENT,
-      `int` int(11) default NULL,
-      `time` timestamp,
-      `bool` tinyint(1) default NULL,
-      `date` date default NULL,
-      `str` varchar(20) default NULL
-    );
-    SQL
-  elsif adapter == "postgres"
-    sql = <<-SQL
-    CREATE TABLE table1 (
-      "id" serial NOT NULL,
-      "int" integer default NULL,
-      "time" timestamp,
-      "bool" boolean default NULL,
-      "date" date default NULL,
-      "str" varchar(20) default NULL,
-      PRIMARY KEY ("id")
-    );
-    SQL
-  end
-  cmd2 = c.create_command(sql)
-  cmd2.execute_non_query
-  insert1 = adapter == "postgres" ? 
-    "INSERT into table1(#{$escaped_columns}) VALUES(NULL, #{quote}#{Time.now.to_s_db}#{quote}, false, #{quote}#{Date.today.to_s}#{quote}, #{quote}foo#{quote})" :
-    "INSERT into table1(#{$escaped_columns}) VALUES(NULL, #{quote}#{Time.now.to_s_db}#{quote}, 0, #{quote}#{Date.today.to_s}#{quote}, #{quote}foo#{quote})"
-  cmd3 = c.create_command(insert1)
-  cmd3.execute_non_query
-  insert2 = adapter == "postgres" ?
-    "INSERT into table1(#{$escaped_columns}) VALUES(17, #{quote}#{Time.now.to_s_db}#{quote}, true, NULL, NULL)" :
-    "INSERT into table1(#{$escaped_columns}) VALUES(17, #{quote}#{Time.now.to_s_db}#{quote}, 1, NULL, NULL)"
-  cmd4 = c.create_command(insert2)    
-  cmd4.execute_non_query
-ensure
-  c.close if defined?(c) && c
-end

data/plugins/dataobjects/swig_mysql/extconf.rb

@@ -1,45 +0,0 @@
-require 'mkmf'
-require 'open3'
-
-def config_value(type)
-  ENV["MYSQL_#{type.upcase}"] || mysql_config(type)
-end
-
-def mysql_config(type)
-
-  sin, sout, serr = Open3.popen3("mysql_config5 --#{type}")
-  
-  unless serr.read.empty?
-    sin, sout, serr = Open3.popen3("mysql_config --#{type}")
-  end
-  
-  unless serr.read.empty?
-    raise "mysql_config not found"
-  end
-  
-  sout.readline.chomp[2..-1]
-end
-
-$inc, $lib = dir_config('mysql', config_value('include'), config_value('libs_r')) 
-
-def have_build_env
-  libs = ['m', 'z', 'socket', 'nsl']
-  while not find_library('mysqlclient', 'mysql_query', config_value('libs'), $lib, "#{$lib}/mysql") do
-    exit 1 if libs.empty?
-    have_library(libs.shift)
-  end
-  true
-  # have_header('mysql.h')
-end
-
-required_libraries = [] #%w(m z socket nsl)
-desired_functions = %w(mysql_ssl_set)
-# compat_functions = %w(PQescapeString PQexecParams)
-
-if have_build_env
-  $CFLAGS << ' -Wall '
-  dir_config("mysql_c")
-  create_makefile("mysql_c")
-else
-  puts 'Could not find MySQL build environment (libraries & headers): Makefile not created'
-end