sqlpostgres 1.2.4

data/lib/sqlpostgres/Update.rb

@@ -0,0 +1,188 @@
+module SqlPostgres
+
+  # This class creates and executes an SQL update statement.
+  #
+  # Example:
+  #** Example: update
+  #   update = Update.new('foo', connection)
+  #   update.set('i', 2)
+  #   p update.statement    # "update foo set i = 2"
+  #   update.exec
+  #**
+
+  class Update
+
+    # Create an update statement.
+    #
+    # [table]
+    #   The table name
+    # [connection]
+    #   The connection to use.  If nil, use the default connection instead.
+
+    def initialize(table, connection = Connection.default)
+      @table = table
+      @connection = connection
+      @set_clauses = []
+      @conditions = []
+      @only = false
+    end
+
+    # Add "only" to this statement.  This is a postgres extension
+    # which causes the update to *not* apply to derived tables.
+    #
+    # Example:
+    #** Example: update_only
+    #   update = Update.new('foo')
+    #   update.only
+    #   update.set('i', 0)
+    #   p update.statement    # "update only foo set i = 0"
+    #**
+
+    def only
+      @only = true
+    end
+
+    # Set a column to a value.
+    #
+    # [column]
+    #   The column name
+    # [value]
+    #   The value to set the column to.  Ruby data types are converted
+    #   to SQL automatically using #escape_sql.
+    #
+    # Example showing a few different types:
+    #** Example: update_set
+    #   update = Update.new('foo')
+    #   update.set('name', 'Fred')
+    #   update.set('hire_date', Time.local(2002, 1, 1))
+    #   p update.statement      # "update foo set name = E'Fred', hire_date = 
+    #                           # timestamp '2002-01-01 00:00:00.000000'"
+    #**
+    #
+    # Example showing a subselect:
+    #** Example: update_set_subselect
+    #   select = Select.new
+    #   select.select('j')
+    #   select.from('bar')
+    #   select.where(["i = foo.i"])
+    #   update = Update.new('foo')
+    #   update.set('i', select)
+    #   p update.statement         # "update foo set i = (select j from bar 
+    #                              # where i = foo.i)"
+    #**
+    #
+    # Example showing an expression:
+    #** Example: update_set_expression
+    #   update = Update.new('foo')
+    #   update.set('i', ['i + 1'])
+    #   p update.statement           # "update foo set i = i + 1"
+    #**
+
+    def set(column, value)
+      @set_clauses << [column, Translate.escape_sql(value)].join(' = ')
+    end
+
+    # Set a bytea column.  You must use this function, not #set, when
+    # updating a bytea column.  That's because bytea columns need
+    # special escaping.
+    #
+    # [column]
+    #   The column name
+    # [value]
+    #   The value to add.
+    #
+    # Example:
+    #** Example: update_set_bytea
+    #   update = Update.new('foo')
+    #   update.set_bytea('name', "\000\377")
+    #   p update.statement      # "update foo set name = E'\\\\000\\\\377'"
+    #**
+
+    def set_bytea(column, value)
+      @set_clauses << [column, Translate.escape_bytea(value)].join(' = ')
+    end
+
+    # Set a column to an array.
+    #
+    # [column]
+    #   The column name
+    # [value]
+    #   The value to set the column to.  Ruby data types are converted
+    #   to SQL automatically using #escape_array.
+    #
+    # Example:
+    #** Example: update_set_array
+    #   update = Update.new('foo')
+    #   update.set_array('i', [1, 2, 3])
+    #   p update.statement      # "update foo set i = ARRAY[1, 2, 3]"
+    #**
+
+    def set_array(column, value)
+      @set_clauses << [column, Translate.escape_array(value)].join(' = ')
+    end
+
+    # Add a where clause to the statement.
+    #
+    # [expression]
+    #   A string or array, converted using #substitute_values
+    #
+    # Example:
+    #** Example: update_where
+    #   update = Update.new('foo')
+    #   update.set('i', 1)
+    #   update.where(['t = %s', "bar"])
+    #   p update.statement     # "update foo set i = 1 where t = E'bar'"
+    #**
+
+    def where(condition)
+      @conditions << Translate.substitute_values(condition)
+    end
+
+    # Return the SQL statement.  Especially useful for debugging.
+
+    def statement
+      "update#{only_option} #{@table} set #{set_clause_list}#{where_clause}"
+    end
+
+    # Execute the statement.
+    #
+    # [connection]
+    #   If present, the connection to use.
+    #   If nil, uses the connection passed to new or, if no connection was
+    #   passed to new, uses the default connection.
+
+    def exec(connection = @connection)
+      connection.exec(statement)
+    end
+
+    private
+
+    def set_clause_list
+      @set_clauses.join(', ')
+    end
+
+    def where_clause
+      if @conditions.empty?
+        ""
+      else
+        " where #{@conditions.join(' and ')}"
+      end
+    end
+
+    def only_option
+      if @only
+        " only"
+      else
+        ""
+      end
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres.rb

@@ -0,0 +1,67 @@
+require 'pg'
+
+# sqlpostgres is a wrapper around the venerable Ruby postgres library.
+# sqlpostgres builds and executes insert, update and select
+# statements.  sqlpostgres statements are easier to read and maintain
+# than raw SQL.  Ruby data types are automatically converted to and
+# from SQL data types, and results are returned as an array of hashes
+# rather than an array of arrays.
+#
+# Here's a small example showing some inserts, an update, and a
+# select:
+#
+#** Example: simple
+#   require "sqlpostgres"
+#   
+#   include SqlPostgres
+#   
+#   Connection.open do |connection|
+#     connection.exec("create temporary table foo (t text)")
+#     
+#     insert = Insert.new('foo', connection)
+#     insert.insert('t', 'Smith')
+#     insert.exec
+#     
+#     insert = Insert.new('foo', connection)
+#     insert.insert('t', 'Jones')
+#     insert.exec
+#     
+#     update = Update.new('foo', connection)
+#     update.set('t', "O'Brien")
+#     update.where(["t = %s", "Smith"])
+#     update.exec  
+#     
+#     select = Select.new(connection)
+#     select.select('t')
+#     select.from('foo')
+#     select.order_by('t')
+#     p select.exec  # [{"t"=>"Jones"}, {"t"=>"O'Brien"}]
+#     
+#   end
+#**
+#
+# All classes and functions in this library are in the SqlPostgres module.
+# Users of this library should either use the module name as a prefix:
+#
+#** Example: use_prefix
+#   require 'sqlpostgres'
+#   insert = SqlPostgres::Insert.new('foo')
+#**
+#
+# or include the module:
+#
+#** Example: include_module
+#   require 'sqlpostgres'
+#   include SqlPostgres
+#   insert = Insert.new('foo')
+#**
+
+for path in Dir[File.join(File.dirname(__FILE__), 'sqlpostgres', '*.rb')]
+  require File.expand_path(path)
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/Assert.rb

@@ -0,0 +1,72 @@
+module Assert
+
+  class BlownAssert < Exception
+
+    attr_accessor :message
+
+    def initialize(message = "")
+      @message = message
+    end
+
+    def to_s
+      @message
+    end
+  end
+
+  def assert(condition)
+    fail("Assert failed") unless condition
+  end
+
+  def assertEquals(actual, expected)
+    return if expected === actual
+    fail("Expected:\n#{expected.inspect}\nbut got\n#{actual.inspect}")
+  end
+  module_function :assertEquals
+
+  def assertGreater(actual, expected)
+    return if actual > expected
+    fail("Expected > #{expected.inspect} but got #{actual.inspect}")
+  end
+
+  def assertGreaterOrEqual(actual, expected)
+    return if actual >= expected
+    fail("Expected >= #{expected.inspect} but got #{actual.inspect}")
+  end
+
+  def assertException(exceptionClass, exceptionString = nil)
+    begin
+      yield
+    rescue exceptionClass => e
+      assertEquals(e.to_s, exceptionString) unless exceptionString.nil?
+    else
+      fail("Exception #{exceptionClass} not thrown")
+    end
+  end
+
+  def assertInfo(info)
+    begin
+      yield
+    rescue Exception => e
+      newMessage = "#{info}: #{e}"
+      if e.is_a? BlownAssert
+        e.message = newMessage
+        raise
+      else
+        newMessage << "\nOriginal backtrace:\n#{e.backtrace.join("\n")}"
+        raise e.exception(newMessage)
+      end
+    end
+  end
+
+  def fail(why)
+    raise BlownAssert, why
+  end
+  module_function :fail
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/Connection.test.rb

@@ -0,0 +1,246 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+
+require 'MockPGconn'
+require 'RandomThings'
+
+class ConnectionTest < Test
+
+  include SqlPostgres
+  include RandomThings
+  include TestConfig
+  include TestUtil
+
+  def test_ConnectionNewWrap
+    Connection.mockPgClass do
+      rawConnection = MockPGconn.new
+      assertEquals(MockPGconn.state[:encoding], nil)
+      connection = Connection.new('connection'=>rawConnection)
+      assertEquals(rawConnection.state[:encoding], 'unicode')
+    end
+  end
+
+  def test_ConnectionNewWithBlock
+    assertException(ArgumentError, "Block not allowed") do
+      Connection.new do |connection|
+      end
+    end
+  end
+
+  def testOpen_RealConnection
+    s = Connection.open(testDbArgs) do |connection|
+      assertEquals(connection.query("select 1;"), [["1"]])
+      "foo"
+    end
+    assertEquals(s, "foo")
+  end
+
+  def testOpen_RealConnection_SelectDatabase
+    dbName = "sqlpostgres_test1"
+    Connection.open(testDbArgs) do |connection1|
+      connection1.exec("create database #{dbName}")
+      begin
+        Connection.open('db_name'=>dbName) do |connection2|
+           rows = connection2.query("select current_database();")
+           assertEquals(rows[0][0], dbName)
+        end
+        sleep(0.1) # I don't know why, but it seems to take some time
+                   # for the connection to be closed
+      ensure
+        connection1.exec("drop database #{dbName}")
+      end
+    end
+  end
+
+  def testClose
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:open], true)
+      connection.close
+      assertEquals(MockPGconn.state[:open], false)
+      connection.close
+      assertEquals(MockPGconn.state[:open], false)
+    end
+  end
+
+  def testOpen_DefaultArgs
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:open], true)
+      assertEquals(MockPGconn.state[:openArgs],
+                   ["localhost", 5432, "", "", "", nil, nil])
+    end
+  end
+
+  def testConstructor
+    Connection.mockPgClass do
+      dbName = randomString
+      hostName = randomString
+      port = randomInteger
+      login = randomString
+      password = randomString
+      options = randomString
+      tty = randomString
+      connection = Connection.new('host_name'=>hostName,
+                                  'port'=>port,
+                                  'options'=>options,
+                                  'tty'=>tty,
+                                  'db_name'=>dbName,
+                                  'login'=>login,
+                                  'password'=>password)
+      assertEquals(MockPGconn.state[:open], true)
+      assertEquals(MockPGconn.state[:openArgs], 
+                   [hostName, port, options, tty, dbName, login, password])
+      assertEquals(MockPGconn.state[:encoding], 'unicode')
+    end
+  end
+
+  def testOpen
+    Connection.mockPgClass do
+      statement = randomString
+      Connection.open do |connection|
+        assertEquals(MockPGconn.state[:open], true)
+        connection.exec(statement)
+      end
+      assertEquals(MockPGconn.state[:statements], [statement])
+      assertEquals(MockPGconn.state[:open], false)
+    end
+  end
+
+  def testOpen_CloseOnException
+    Connection.mockPgClass do
+      statement = randomString
+      assertException(RuntimeError, "Foo") do
+        Connection.open do |connection|
+          assertEquals(MockPGconn.state[:open], true)
+          raise "Foo"
+        end
+      end
+      assertEquals(MockPGconn.state[:open], false)
+    end
+  end
+
+  def testOpen_CloseOnException_ExceptionDuringClose
+    Connection.mockPgClass do
+      statement = randomString
+      MockPGconn.state[:close_exception] = RuntimeError.new("Can't close")
+      assertException(RuntimeError, "Foo") do
+        Connection.open do |connection|
+          assertEquals(MockPGconn.state[:open], true)
+          raise "Foo"
+        end
+      end
+      assertEquals(MockPGconn.state[:open], false)
+    end
+  end
+
+  def testOpen_ExceptionDuringClose
+    Connection.mockPgClass do
+      statement = randomString
+      MockPGconn.state[:close_exception] = RuntimeError.new("Can't close")
+      assertException(RuntimeError, "Can't close") do
+        Connection.open do |connection|
+          assertEquals(MockPGconn.state[:open], true)
+        end
+      end
+      assertEquals(MockPGconn.state[:open], false)
+    end
+  end
+
+  def testDefaultConnection
+    default = randomWhatever
+    Connection.default = default
+    assertEquals(Connection.default, default)
+    Connection.default = nil
+    assert(Connection.default.is_a?(NullConnection))
+  end
+
+  def testExec
+    statement = randomString
+    result = randomWhatever
+    Connection.mockPgClass do
+      MockPGconn.state[:results] = [result]
+      connection = Connection.new
+      assertEquals(connection.exec(statement), result)
+      assertEquals(MockPGconn.state[:statements], [statement])
+    end
+  end
+
+  def testExec_Exception
+    Connection.mockPgClass do
+      MockPGconn.state[:results] = [RuntimeError.new("Foo")]
+      connection = Connection.new
+      assertException(RuntimeError, "Foo") do
+        connection.exec("foo")
+      end
+    end
+  end
+
+  def testExec_PGError
+    testCases = [
+      [false, "Foo\n"],
+      [true, "Foo\nThe offending statement is: \"bar\""],
+    ]
+    for statement_in_exception, message in testCases 
+      Connection.mockPgClass do
+        MockPGconn.state[:results] = [PGError.new("Foo\n")]
+        connection = Connection.new
+        connection.statement_in_exception = statement_in_exception
+        assertException(PGError, message) do
+          connection.exec("bar")
+        end
+      end
+    end
+  end
+
+  def testQuery
+    statement = randomString
+    rows = randomWhatever
+    Connection.mockPgClass do
+      result = Object.new
+      class << result
+        attr_accessor :result
+      end
+      result.result = rows
+      MockPGconn.state[:results] = [result]
+      assertEquals(Connection.new.query(statement), rows)
+      assertEquals(MockPGconn.state[:statements], [statement])
+    end
+  end
+
+  def testStatement_In_Exception
+    for value in [false, true]
+      connection = Connection.new(testDbArgs.merge('statement_in_exception'=>value))
+      assertEquals(connection.statement_in_exception, value)
+    end
+  end
+
+  def testRealException
+    Connection.open(testDbArgs) do |connection|
+      assertException(PGError, /ERROR:  (Attribute "foo" not found|column "foo" does not exist)/) do 
+        connection.exec("select foo;")
+      end
+    end
+  end
+
+  def testPgconn
+    Connection.mockPgClass do
+      Connection.open(testDbArgs) do |connection|
+        assertEquals(connection.pgconn, MockPGconn.state[:connection])
+      end
+    end
+  end
+
+end
+
+ConnectionTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End: