sqlpostgres 1.2.4

data/lib/sqlpostgres/PgTime.rb

@@ -0,0 +1,77 @@
+require 'sqlpostgres/PgType'
+
+module SqlPostgres
+
+  # This class holds the value of a "time" column.
+
+  class PgTime < PgType
+
+    # Return the hour (0..23)
+
+    attr_reader :hour
+
+    # Return the minute (0..59)
+
+    attr_reader :minute
+
+    # Return the second (0..59)
+
+    attr_reader :second
+
+    class << self
+
+      # Create a PgTime from a string in Postgres format (ie "12:00:00").
+
+      def from_sql(s)
+        PgTime.new(*s.split(":").collect do |p| p.to_i end)
+      end
+
+    end
+
+    # Constructor taking hour (0..23), minute (0..59), and second (0..59)
+
+    def initialize(hour = 0, minute = 0, second = 0)
+      @hour = hour
+      @minute = minute
+      @second = second
+    end
+
+    # Return a string representation (ie "12:00:00").
+
+    def to_s
+      "%02d:%02d:%02d" % [@hour, @minute, @second]
+    end
+
+    # Convert to an instance of Time on date 1970/01/01, local time zone.
+
+    def to_local_time
+      Time.local(1970, 1, 1, @hour, @minute, @second)
+    end
+
+    # Convert to an instance of Time on date 1970/01/01, utc time zone.
+
+    def to_utc_time
+      Time.utc(1970, 1, 1, @hour, @minute, @second)
+    end
+
+    protected
+
+    def parts
+      [hour, minute, second]
+    end
+
+    private
+
+    def column_type
+      'time'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgTimeWithTimeZone.rb

@@ -0,0 +1,98 @@
+require 'sqlpostgres/PgType'
+
+module SqlPostgres
+
+  # This class holds the value of a "time" column.
+
+  class PgTimeWithTimeZone < PgType
+
+    # Return the hour (0..23)
+
+    attr_reader :hour
+
+    # Return the minute (0..59)
+
+    attr_reader :minute
+
+    # Return the second (0..59)
+
+    attr_reader :second
+
+    # Return the hours of the time-zone offset.
+
+    attr_reader :zone_hours
+
+    # Return the minutes of the time-zone offset.
+
+    attr_reader :zone_minutes
+
+    class << self
+
+      # Create a PgTimeWithTimeZone from a string in Postgres format
+      # (ie "12:00:00+0800").
+
+      def from_sql(s)
+        if s =~ /^(\d+):(\d+):(\d+)((?:\+|-)\d+)(?::(\d+))?$/
+          PgTimeWithTimeZone.new($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i)
+        else
+          raise ArgumentError, "Invalid time with time zone: #{s.inspect}"
+        end
+      end
+
+    end
+
+    # Constructor.
+    #
+    # [hour]
+    #   0..23
+    # [minute]
+    #   0..59
+    # [second}
+    #   0..59
+    # [zone_hours]
+    #   The hours of the time-zone offset (-23..23)
+    # [zone_minutes]
+    #   The seconds of the time-zone offset (0..60)
+
+    def initialize(hour = 0, minute = 0, second = 0, 
+                   zone_hours = 0, zone_minutes = 0)
+      @hour = hour
+      @minute = minute
+      @second = second
+      @zone_hours = zone_hours
+      @zone_minutes = zone_minutes
+    end
+
+    # Return a string representation (ie "12:00:00-07:00").
+
+    def to_s
+      "%02d:%02d:%02d%+03d:%02d" % parts
+    end
+
+    # Convert to sql format (ie "timestamp '2001-01-01 12:00:00'").
+
+    def to_sql
+      "time with time zone '#{to_s}'"
+    end
+
+    protected
+
+    def parts
+      [@hour, @minute, @second, @zone_hours, @zone_minutes]
+    end
+
+    private
+
+    def column_type
+      'time with time zone'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgTimestamp.rb

@@ -0,0 +1,93 @@
+require 'sqlpostgres/PgType'
+
+module SqlPostgres
+
+  # This class holds the value of a "timestamp" column.
+
+  class PgTimestamp < PgType
+
+    attr_reader :year
+    attr_reader :month
+    attr_reader :day
+    attr_reader :hour
+    attr_reader :minute
+    attr_reader :second
+    attr_reader :microseconds
+
+    class << self
+
+      # Convert from Postgres (ie '2001-01-01 12:00:01') to a PgTimestamp
+
+      def from_sql(s)
+        PgTimestamp.new(*s.gsub(/\D/, ' ').split.collect do |q| q.to_i end)
+      end
+
+    end
+
+    # Constructor taking all the pieces.
+
+    def initialize(year = 0, month = 0, day = 0, 
+                   hour = 0, minute = 0, second = 0,
+                   microseconds = 0)
+      @year = year
+      @month = month
+      @day = day
+      @hour = hour
+      @minute = minute
+      @second = second
+      @microseconds = microseconds
+    end
+
+    # Convert to a string (ie '2001-01-01 12:00:00').
+
+    def to_s
+      "%04d-%02d-%02d %02d:%02d:%02d.%05d" % parts
+    end
+
+    # Convert to sql format (ie "timestamp '2001-01-01 12:00:00'").
+
+    def to_sql
+      "timestamp '#{to_s}'"
+    end
+
+    # Convert to an instance of Time in the local time zone.
+    #
+    # Note: Time can't take all the values that PgTimestamp can, so
+    # this method can easily raise an exception.  Only use it if
+    # you're sure that the PgTimestamp will fit in a Time.
+
+    def to_local_time
+      Time.local(@year, @month, @day, @hour, @minute, @second)
+    end
+
+    # Convert to an instance of Time in the utc time zone.  
+    #
+    # Note: Time can't take all the values that PgTimestamp can, so
+    # this method can easily raise an exception.  Only use it if
+    # you're sure that the PgTimestamp will fit in a Time.
+
+    def to_utc_time
+      Time.utc(@year, @month, @day, @hour, @minute, @second)
+    end
+
+    protected
+
+    def parts
+      [@year, @month, @day, @hour, @minute, @second, @microseconds]
+    end
+
+    private
+
+    def column_type
+      'timestamp'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgTwoPoints.rb

@@ -0,0 +1,54 @@
+require 'sqlpostgres/PgType'
+
+module SqlPostgres
+
+  # This is the base class for data types which have two points
+
+  class PgTwoPoints < PgType
+
+    # Return the first endpoint
+
+    attr_reader :p1
+
+    # Return the second endpoint
+
+    attr_reader :p2
+
+    # Constructor.  Takes either 0 arguments, which sets both endpoints
+    # to (0, 0), or 2 PgPoint arguments, or 4 float arguments.
+
+    def initialize(*args)
+      case args.size
+      when 0
+        @p1 = PgPoint.new
+        @p2 = PgPoint.new
+      when 2
+        @p1 = args[0]
+        @p2 = args[1]
+      when 4
+        @p1 = PgPoint.new(*args[0..1])
+        @p2 = PgPoint.new(*args[2..3])
+      end
+    end
+
+    # Return a string representation (ie "((1, 2), (3, 4))").
+
+    def to_s
+      "(%s, %s)" % [p1, p2]
+    end
+
+    protected
+
+    def parts
+      [p1, p2]
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgType.rb

@@ -0,0 +1,34 @@
+module SqlPostgres
+
+  # This is the base class for the classes that represent column types.
+
+  class PgType
+
+    # Return true if +other+ is is equal to this object.
+
+    def eql?(other)
+      other.is_a?(self.class) && parts == other.parts
+    end
+    alias_method :==, :eql?
+
+    # Return the hash code.
+
+    def hash
+      parts.to_s.hash
+    end
+
+    # Return the SQL representation.
+
+    def to_sql
+      "#{column_type} '#{to_s}'"
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgWrapper.rb

@@ -0,0 +1,41 @@
+require 'sqlpostgres/PgType'
+
+module SqlPostgres
+
+  # This PgType is the base class of wrapper types that are merely
+  # wrappers around String.  Its purpose is to identify the type of
+  # String (is it a mac address?  An inet address? etc).
+
+  class PgWrapper < PgType
+
+    class << self
+
+      def from_sql(sql)
+        self.new(sql)
+      end
+
+    end
+
+    def initialize(value)
+      @value = value
+    end
+
+    def to_s
+      @value
+    end
+
+    protected
+
+    def parts
+      [@value]
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/Savepoint.rb

@@ -0,0 +1,98 @@
+module SqlPostgres
+
+  # This class handles a savepoint.
+  #
+  # Example:
+  #** example: savepoint
+  #   Transaction.new(connection) do
+  #   
+  #     insert = Insert.new('foo', connection)
+  #     insert.insert('i', 1)
+  #     insert.exec
+  #   
+  #     Savepoint.new('bar', connection) do |sp|
+  #       insert = Insert.new('foo', connection)
+  #       insert.insert('i', 2)
+  #       sp.abort
+  #     end
+  #   
+  #     insert = Insert.new('foo', connection)
+  #     insert.insert('i', 3)
+  #     insert.exec
+  #   
+  #   end
+  #   
+  #   p connection.query("select i from foo order by i") #[["1"], ["3"]]
+  #**
+
+  class Savepoint
+
+    # Create an SQL savepoint, yield, and then commit the savepoint.
+    # If an exception occurs, the savepoint is aborted.
+    #
+    # If no connection is given, then the default connection is used.
+
+    def initialize(name, connection = Connection.default)
+      @name = name
+      @state = :open
+      @finished = false
+      @connection = connection
+      @connection.exec("savepoint #{name}")
+      begin
+        result = yield(self)
+        commit
+        result
+      rescue Exception
+        abort
+        raise
+      end
+    end
+
+    # Commit this savepoit.  This is done for you unless an
+    # exception occurs within the block you passed to "new".  Call
+    # this when you want to commit the savepoint before raising an
+    # exception -- in other words, when you want to keep your database
+    # changes even though an exception is about to occur.  
+
+    def commit
+      unless @finished
+        do_commit
+      end
+    end
+
+    # Abort this savepoint.  This is done for you when an exception
+    # occurs within the block you passed to "new".  Call this when you
+    # want to abort a savepoint without throwing an exception.
+    
+    def abort
+      unless @finished
+        do_abort
+      end
+    end
+
+    private
+
+    def do_commit
+      release_savepoint
+      @finished = true
+    end
+
+    def do_abort
+      @connection.exec("rollback to #{@name}")
+      release_savepoint
+      @finished = true
+    end
+
+    def release_savepoint
+      @connection.exec("release savepoint #{@name}")
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End: