do_postgres 0.2.4 → 0.9.2

data/ext/extconf.rb

@@ -1,7 +1,18 @@
-ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
+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
 
 require 'mkmf'
 
+# be polite: you can't force existance of uname functionality on all
+# platforms.
+if RUBY_PLATFORM =~ /darwin/
+  ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
+end
+
 def config_value(type)
   ENV["POSTGRES_#{type.upcase}"] || pg_config(type)
 end
@@ -11,7 +22,8 @@ def pg_config(type)
 end
 
 def have_build_env
-  have_library('pq') && have_header('libpq-fe.h') && have_header('libpq/libpq-fs.h')
+  (have_library('pq') || have_library('libpq')) &&
+    have_header('libpq-fe.h') && have_header('libpq/libpq-fs.h')
 end
 
 dir_config('pgsql', config_value('include'), config_value('lib'))
@@ -23,9 +35,9 @@ compat_functions = %w(PQescapeString PQexecParams)
 if have_build_env
   required_libraries.each(&method(:have_library))
   desired_functions.each(&method(:have_func))
-  $CFLAGS << ' -Wall '
-  dir_config("postgres_c")
-  create_makefile("postgres_c")
+  $CFLAGS << ' -Wall ' unless RUBY_PLATFORM =~ /mswin/
+  create_makefile("do_postgres_ext")
 else
   puts 'Could not find PostgreSQL build environment (libraries & headers): Makefile not created'
-end
+  exit(1)
+end

data/ext/type-oids.h

@@ -0,0 +1,76 @@
+#define BOOLOID			16
+#define BYTEAOID		17
+#define CHAROID			18
+#define NAMEOID			19
+#define INT8OID			20
+#define INT2OID			21
+#define INT2VECTOROID	22
+#define INT4OID			23
+#define REGPROCOID		24
+#define TEXTOID			25
+#define OIDOID			26
+#define TIDOID		27
+#define XIDOID 28
+#define CIDOID 29
+#define OIDVECTOROID	30
+#define PG_TYPE_RELTYPE_OID 71
+#define PG_ATTRIBUTE_RELTYPE_OID 75
+#define PG_PROC_RELTYPE_OID 81
+#define PG_CLASS_RELTYPE_OID 83
+#define XMLOID 142
+#define POINTOID		600
+#define LSEGOID			601
+#define PATHOID			602
+#define BOXOID			603
+#define POLYGONOID		604
+#define LINEOID			628
+#define FLOAT4OID 700
+#define FLOAT8OID 701
+#define ABSTIMEOID		702
+#define RELTIMEOID		703
+#define TINTERVALOID	704
+#define UNKNOWNOID		705
+#define CIRCLEOID		718
+#define CASHOID 790
+#define MACADDROID 829
+#define INETOID 869
+#define CIDROID 650
+#define INT4ARRAYOID		1007
+#define FLOAT4ARRAYOID 1021
+#define ACLITEMOID		1033
+#define CSTRINGARRAYOID		1263
+#define BPCHAROID		1042
+#define VARCHAROID		1043
+#define DATEOID			1082
+#define TIMEOID			1083
+#define TIMESTAMPOID	1114
+#define TIMESTAMPTZOID	1184
+#define INTERVALOID		1186
+#define TIMETZOID		1266
+#define BITOID	 1560
+#define VARBITOID	  1562
+#define NUMERICOID		1700
+#define REFCURSOROID	1790
+#define REGPROCEDUREOID 2202
+#define REGOPEROID		2203
+#define REGOPERATOROID	2204
+#define REGCLASSOID		2205
+#define REGTYPEOID		2206
+#define REGTYPEARRAYOID 2211
+#define TSVECTOROID		3614
+#define GTSVECTOROID	3642
+#define TSQUERYOID		3615
+#define REGCONFIGOID	3734
+#define REGDICTIONARYOID	3769
+#define RECORDOID		2249
+#define CSTRINGOID		2275
+#define ANYOID			2276
+#define ANYARRAYOID		2277
+#define VOIDOID			2278
+#define TRIGGEROID		2279
+#define LANGUAGE_HANDLEROID		2280
+#define INTERNALOID		2281
+#define OPAQUEOID		2282
+#define ANYELEMENTOID	2283
+#define ANYNONARRAYOID	2776
+#define ANYENUMOID		3500

data/lib/do_postgres.rb

@@ -1,246 +1,5 @@
-require 'postgres_c'
-require 'data_objects'
-
-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, "Unable to connect to database with provided connection string. \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
-      
-      def begin_transaction
-        Transaction.new(self)
-      end
-
-    end
-
-    class Transaction < Connection
-
-      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)
-        exec_sql("ROLLBACK#{savepoint ? " TO " + savepoint : ""}")
-      end
-
-      # Creates a savepoint for rolling back later (not commonly supported)
-      def save(name)
-        exec_sql("SAVEPOINT #{name}")
-      end
-
-      def create_command(*args)
-        @connection.create_command(*args)
-      end
-
-      protected
-
-      def exec_sql(sql)
-        @connection.logger.debug(sql)
-        Postgres_c.PQexec(@connection.db, "COMMIT")
-      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? || val == "NULL"
-        case TYPES[field_type]
-          when "BOOL"
-            val == "t"
-          when "INT2", "INT4", "OID", "TID", "XID", "CID", "INT8"
-            val == '' ? nil : 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
-      
-      def quote_string(value)
-        if value =~ /[\x00-\x80]/
-          raise "String cannot contain $Text$ in the body" if value.include?("$Text$")
-          "$Text$#{value}$Text$"
-        else
-          super
-        end
-      end
-      
-    end
-    
-  end
-end
+require 'rubygems'
+require 'data_objects'
+require 'do_postgres_ext'
+require 'do_postgres/transaction'

data/lib/do_postgres/transaction.rb

@@ -0,0 +1,37 @@
+
+module DataObjects
+
+  module Postgres
+
+    class Transaction < DataObjects::Transaction
+
+      def begin
+        cmd = "BEGIN"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def commit
+        cmd = "COMMIT PREPARED '#{id}'"
+        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 PREPARED '#{id}'"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def prepare
+        cmd = "PREPARE TRANSACTION '#{id}'"
+        connection.create_command(cmd).execute_non_query
+      end
+
+    end
+
+  end
+
+end

data/spec/integration/do_postgres_spec.rb

@@ -0,0 +1,202 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+#
+#
+# Create a postgres db named do_test that accepts connections
+# from localhost from your current user (without password) to enable this spec.
+#
+# You also need to allow passwordless access from localhost-
+# locate the following line in your pg_hba.conf file:
+#
+#  # IPv4 local connections:
+#  host    all         all         127.0.0.1/32          md5
+#
+# and replace 'md5' with 'trust' for these specs to work
+#
+#
+
+describe "DataObjects::Postgres::Connection" do
+  include PostgresSpecHelpers
+
+  it "should connect to the db" do
+    connection = DataObjects::Connection.new("postgres://localhost/do_test")
+  end
+end
+
+describe "DataObjects::Postgres::Command" do
+  include PostgresSpecHelpers
+
+  before :all do
+    @connection = ensure_users_table_and_return_connection
+  end
+
+  it "should create a command" do
+    @connection.create_command("CREATE TABLE users").should be_a_kind_of(DataObjects::Postgres::Command)
+  end
+
+  it "should set types" do
+    command = @connection.create_command("SELECT id, name FROM users")
+    command.set_types [Integer, String]
+    command.instance_variable_get("@field_types").should == [Integer, String]
+  end
+
+  it "should execute a non query" do
+    command = @connection.create_command("INSERT INTO users (name) VALUES ('Test')")
+    result = command.execute_non_query
+    result.should be_a_kind_of(DataObjects::Postgres::Result)
+  end
+
+  it "should execute a reader" do
+    command = @connection.create_command("SELECT * FROM users")
+    reader = command.execute_reader
+    reader.should be_a_kind_of(DataObjects::Postgres::Reader)
+    reader.close.should == true
+  end
+end
+
+describe "DataObjects::Postgres::Result" do
+  include PostgresSpecHelpers
+
+  before :all do
+    @connection = ensure_users_table_and_return_connection
+  end
+
+  it "should raise errors on bad queries" do
+    command = @connection.create_command("INSER INTO users (name) VALUES ('Test')")
+    lambda { command.execute_non_query }.should raise_error
+    command = @connection.create_command("INSERT INTO users (non_existant_field) VALUES ('Test')")
+    lambda { command.execute_non_query }.should raise_error
+  end
+
+  it "should not have an insert_id without RETURNING" do
+    command = @connection.create_command("INSERT INTO users (name) VALUES ('Test')")
+    result = command.execute_non_query
+    result.insert_id.should == 0;
+    result.to_i.should == 1;
+  end
+
+  it "should have an insert_id when RETURNING" do
+    command = @connection.create_command("INSERT INTO users (name) VALUES ('Test') RETURNING id")
+    result = command.execute_non_query
+    result.insert_id.should_not == 0;
+    result.to_i.should == 1;
+  end
+end
+
+describe "DataObjects::Postgres::Reader" do
+  include PostgresSpecHelpers
+
+  before :all do
+    @connection = ensure_users_table_and_return_connection
+    @connection.create_command("INSERT INTO users (name) VALUES ('Test')").execute_non_query
+    @connection.create_command("INSERT INTO users (name) VALUES ('Test')").execute_non_query
+    @connection.create_command("INSERT INTO users (name) VALUES ('Test')").execute_non_query
+  end
+
+  it "should raise errors on bad queries" do
+    command = @connection.create_command("SELT * FROM users")
+    lambda { command.execute_reader }.should raise_error
+    command = @connection.create_command("SELECT * FROM non_existant_table")
+    lambda { command.execute_reader }.should raise_error
+  end
+
+  it "should open and close a reader" do
+    command = @connection.create_command("SELECT * FROM users LIMIT 3")
+    command.set_types [Integer, String]
+    reader = command.execute_reader
+    reader.close
+  end
+
+  it "should typecast a value from the postgres type" do
+    command = @connection.create_command("SELECT id, name, registered, money FROM users ORDER BY id DESC LIMIT 3")
+    reader = command.execute_reader
+    reader.send(:instance_variable_get, "@field_count").should == 4
+    reader.send(:instance_variable_get, "@row_count").should == 3
+    while ( reader.next!)
+      reader.values[0].should be_a_kind_of(Integer)
+      reader.values[1].should be_a_kind_of(String)
+      reader.values[2].should == false
+      reader.values[3].should == 1908.56
+    end
+    reader.close
+  end
+
+  it "should typecast from set_types" do
+    command = @connection.create_command("SELECT id, name FROM users ORDER BY id LIMIT 1")
+    command.set_types [Integer, String]
+    reader = command.execute_reader
+    reader.next!
+    reader.values[0].should be_a_kind_of(Integer)
+    reader.values[1].should be_a_kind_of(String)
+    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 typecast a date field" do
+    command = @connection.create_command("SELECT created_on FROM users WHERE created_on is not null LIMIT 1")
+    reader = command.execute_reader
+    reader.next!
+    reader.values[0].should be_a_kind_of(Date)
+  end
+
+  it "should typecast a BigDecimal field" do
+    money_in_the_bank = BigDecimal.new('1.29')
+
+    id = insert("INSERT INTO users (name, money) VALUES (?, ?)", "MC Hammer", money_in_the_bank)
+    select("SELECT money FROM users WHERE id = ?", [BigDecimal], id) do |reader|
+      reader.values.first.should == money_in_the_bank
+    end
+  end
+
+  it "should typecast a timestamp field" do
+    command = @connection.create_command("SELECT created_at FROM users WHERE created_at is not null LIMIT 1")
+    reader = command.execute_reader
+    reader.next!
+    dt = reader.values[0]
+    reader.values[0].should be_a_kind_of(DateTime)
+
+    command = @connection.create_command("SELECT created_at::date as date FROM users WHERE created_at is not null LIMIT 1")
+    reader = command.execute_reader
+    reader.next!
+    reader.values[0].should be_a_kind_of(Date)
+
+  end
+
+  it "should work on a join" do
+
+    user = @connection.create_command("SELECT * FROM users WHERE id = 1").execute_reader
+    user.next!
+
+    @connection.create_command("INSERT INTO companies (name) VALUES ('ELEC')").execute_non_query
+    reader = @connection.create_command(<<-EOF).execute_reader
+      SELECT u.* FROM users AS u
+      LEFT JOIN companies AS c
+        ON u.company_id=c.id
+      WHERE c.name='ELEC'
+    EOF
+    reader.next!
+    reader.values.should == user.values
+  end
+
+  it "should typecast a time field" do
+    pending "Time fields have no date information, and don't work with Time"
+    command = @connection.create_command("SELECT born_at FROM users LIMIT 1")
+    reader = command.execute_reader
+    reader.next!
+    reader.values[0].should be_a_kind_of(Time)
+  end
+end