sqlpostgres 1.2.4

data/lib/sqlpostgres/NullConnection.rb

@@ -0,0 +1,22 @@
+module SqlPostgres
+
+  # This is a special connection that is used when there isn't a real
+  # one.  Any attempt to use it causes a NoConnection exception.
+
+  class NullConnection
+
+    # Raises NoConnection
+
+    def method_missing(method, *args)
+      raise NoConnection
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgBit.rb

@@ -0,0 +1,73 @@
+require 'sqlpostgres/PgType'
+
+module SqlPostgres
+
+  # This class holds the value of a "bit" column.
+
+  class PgBit < PgType
+
+    # Return an array of 0's and 1's with the bits.
+
+    attr_reader :bits
+
+    class << self
+
+      # Create a PgBit from a string in Postgres format (ie
+      # "(1,2)").
+
+      def from_sql(s)
+        if s =~ /^[01]*$/
+          PgBit.new(s)
+        else
+          raise ArgumentError, "Invalid bit: #{s.inspect}"
+        end
+      end
+
+    end
+
+    # Constructor.  Takes either an array of bits, a bunch of bits, or
+    # a string.  These are all equivalent:
+    #   PgBit.new([0, 1, 0, 1])
+    #   PgBit.new(0, 1, 0, 1)
+    #   PgBit.new("0101")
+
+    def initialize(*args)
+      args = args.flatten
+      if args.size == 1 && args[0].is_a?(String)
+        @bits = bits_from_sql(args[0])
+      else
+        @bits = args
+      end
+    end
+
+    # Return a string representation (ie "01011").
+
+    def to_s
+      bits.join
+    end
+
+    protected
+
+    def parts
+      [bits]
+    end
+
+    private
+
+    def column_type
+      'bit'
+    end
+
+    def bits_from_sql(s)
+      s.scan(/./).collect do |d| d.to_i end
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgBox.rb

@@ -0,0 +1,37 @@
+require 'sqlpostgres/PgTwoPoints'
+
+module SqlPostgres
+
+  # This class holds the value of a "point" column.
+
+  class PgBox < PgTwoPoints
+
+    class << self
+
+      # Create a PgBox from a string in Postgres format
+
+      def from_sql(s)
+        if s =~ /^(\(.*\)),(\(.*\))$/
+          PgBox.new(PgPoint.from_sql($1), PgPoint.from_sql($2))
+        else
+          raise ArgumentError, "Invalid box: #{s.inspect}"
+        end
+      end
+
+    end
+
+    private
+
+    def column_type
+      'box'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgCidr.rb

@@ -0,0 +1,21 @@
+require 'sqlpostgres/PgWrapper'
+
+module SqlPostgres
+
+  # This class holds the value of an "cidr" column.
+
+  class PgCidr < PgWrapper
+
+    def column_type
+      'cidr'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgCircle.rb

@@ -0,0 +1,75 @@
+require 'sqlpostgres/PgType'
+
+module SqlPostgres
+
+  # This class holds the value of a "circle" column.
+
+  class PgCircle < PgType
+
+    # Return the center (PgPoint)
+
+    attr_reader :center
+
+    # Return the radius
+
+    attr_reader :radius
+
+    class << self
+
+      # Create a PgCircle from a string in Postgres format
+
+      def from_sql(s)
+        if s =~ /^<(.*),(.*)>$/
+          PgCircle.new(PgPoint.from_sql($1), $2.to_f)
+        else
+          raise ArgumentError, "Invalid circle: #{s.inspect}"
+        end
+      end
+
+    end
+
+    # Constructor
+
+    def initialize(*args)
+      case args.size
+      when 0
+        @center = PgPoint.new
+        @radius = 0
+      when 2
+        @center = args[0]
+        @radius = args[1]
+      when 3
+        @center = PgPoint.new(*args[0..1])
+        @radius = args[2]
+      else
+        raise ArgumentError, "Incorrect number of arguments: #{args.size}"
+      end
+    end
+
+    # Return a string representation (ie "<(1, 2), 3>").
+
+    def to_s
+      "<%s, %g>" % parts
+    end
+
+    protected
+
+    def parts
+      [center, radius]
+    end
+
+    private
+
+    def column_type
+      'circle'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgInet.rb

@@ -0,0 +1,21 @@
+require 'sqlpostgres/PgWrapper'
+
+module SqlPostgres
+
+  # This class holds the value of an "inet" column.
+
+  class PgInet < PgWrapper
+
+    def column_type
+      'inet'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgInterval.rb

@@ -0,0 +1,208 @@
+require 'sqlpostgres/PgType'
+
+module SqlPostgres
+
+  # This class holds the value of an "interval" column.  Instances are
+  # immutable.  
+  #
+  # The fields of a PgInterval are:
+  # * millennia (integer, default 0)
+  # * centuries (integer, default 0)
+  # * decades (integer, default 0)
+  # * years (integer, default 0)
+  # * months (integer, default 0)
+  # * weeks (integer, default 0)
+  # * days (integer, default 0)
+  # * hours (integer, default 0)
+  # * minutes (integer, default 0)
+  # * seconds (integer or float, default 0)
+  # * ago (boolean, default false)
+  #
+  # These fields are set by passing has args to the constructor and can
+  # be retrieved using simple accessors:
+  #
+  #** Example: interval
+  #   interval = PgInterval.new('hours'=>1, 'minutes'=>30)
+  #   p interval.hours                                      # 1
+  #   p interval.minutes                                    # 30
+  #   p interval.seconds                                    # 0
+  #**
+
+  class PgInterval < PgType
+
+    private
+
+    DATE_FIELDS = [
+      "millennia", "centuries", "decades",
+      "years", "months", "weeks", "days",
+    ]
+
+    TIME_FIELDS = ["hours", "minutes", "seconds"]
+
+    FIELDS = DATE_FIELDS + TIME_FIELDS + ["ago"]
+
+    public
+
+    for field in FIELDS
+      eval <<-EOS
+      def #{field}
+        @values["#{field}"]
+      end
+      EOS
+    end
+
+    class << self
+
+      # Convert a Postgres string (ie "2 days 12:00:00") to a
+      # PgInterval instance.
+
+      def from_sql(s)
+        begin
+          args = {}
+          words = s.split
+          raise ArgumentError if words.empty?
+          while !words.empty?
+            word = words.shift
+            case word
+            when /(-)?(\d{2}):(\d{2})(?::(\d{2}(\.\d+)?))?/
+              sign = if $1 then -1 else +1 end
+              args['hours'] = sign * $2.to_i
+              args['minutes'] = sign * $3.to_i
+              args['seconds'] = sign * $4.to_f
+            when /\d+/
+              n = word.to_i
+              units = words.shift
+              case units
+              when 'day', 'days'
+                args['days'] = n
+              when 'mon', 'mons'
+                args['months'] = n
+              when 'year', 'years'
+                args['years'] = n
+              else
+                raise ArgumentError
+              end
+            else
+              raise ArgumentError
+            end
+          end
+        rescue ArgumentError
+          raise ArgumentError, "Syntax error in interval: #{s.inspect}"
+        end
+        PgInterval.new(args)
+      end
+
+    end
+
+    # Constructor.
+    #
+    # [args]
+    #   The values of the days, minutes, and so on, as a hash.
+    #   Each value is an Integer except for ago, which is a boolean.  
+    #
+    #   The keys are:
+    #   * millennia
+    #   * centuries
+    #   * decades
+    #   * years
+    #   * months
+    #   * weeks
+    #   * days
+    #   * hours
+    #   * minutes
+    #   * seconds
+    #
+    #   Any integer not specified defaults to 0; any boolean not specified
+    #   defaults to false.
+
+    def initialize(args = {})
+      args = args.dup
+      @values = Hash[*FIELDS.collect do |field|
+          [field, args.delete(field) || default(field)]
+        end.flatten]
+      raise ArgumentError, args.inspect unless args.empty?
+    end
+
+    # Convert to Postgres format (ie "1 day 12:00:00")
+
+    def to_s
+      s = (to_s_pieces(DATE_FIELDS) + [to_s_time_piece]).compact.join(' ')
+      if s == ""
+        "0 days"
+      else
+        s
+      end + (ago ? " ago" : "")
+    end
+
+    protected
+
+    def parts
+      @values.values
+    end
+
+    private
+
+    def column_type
+      'interval'
+    end
+
+    def singularize(units)
+      units.gsub(/ia$/, 'ium').gsub(/ies$/, 'y').gsub(/s$/, '')
+    end
+
+    def default(field)
+      if field == 'ago'
+        false
+      else
+        0
+      end
+    end
+
+    def to_s_pieces(fields)
+      fields.collect do |field|
+        value = @values[field]
+        if value == 0
+          nil
+        else
+          if value == 1
+            "#{value} #{singularize(field)}"
+          else
+            "#{value} #{field}"
+          end
+        end
+      end
+    end
+
+    def to_s_time_piece
+      h, m, s = hours, minutes, seconds
+      if hours == 0 && minutes == 0 && seconds == 0
+        nil
+      else
+        allNegative = hours <= 0 && minutes <= 0 && seconds <= 0
+        allPositive = hours >= 0 && minutes >= 0 && seconds >= 0
+        if allNegative || allPositive
+          format = "%s%02d:%02d"
+          sign = if allNegative then "-" else "" end
+          if s != 0
+            if s.is_a?(Float)
+              format << ":%09.6f"
+            else
+              format << ":%02d"
+            end
+          end
+          format % [sign, hours.abs, minutes.abs, seconds.abs]
+        else
+          to_s_pieces(TIME_FIELDS)
+        end
+      end
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgLineSegment.rb

@@ -0,0 +1,37 @@
+require 'sqlpostgres/PgTwoPoints'
+
+module SqlPostgres
+
+  # This class holds the value of a "line segment" column.
+
+  class PgLineSegment < PgTwoPoints
+
+    class << self
+
+      # Create a PgLineSegment from a string in Postgres format
+
+      def from_sql(s)
+        if s =~ /^\[(\(.*\)),(\(.*\))\]$/
+          PgLineSegment.new(PgPoint.from_sql($1), PgPoint.from_sql($2))
+        else
+          raise ArgumentError, "Invalid lseg: #{s.inspect}"
+        end
+      end
+
+    end
+
+    private
+
+    def column_type
+      'lseg'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgMacAddr.rb

@@ -0,0 +1,21 @@
+require 'sqlpostgres/PgWrapper'
+
+module SqlPostgres
+
+  # This class holds the value of an "macaddr" column.
+
+  class PgMacAddr < PgWrapper
+
+    def column_type
+      'macaddr'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgPath.rb

@@ -0,0 +1,64 @@
+require 'sqlpostgres/PgType'
+
+module SqlPostgres
+
+  # This class holds the value of a "path" column.
+
+  class PgPath < PgType
+
+    attr_reader :points
+    attr_reader :closed
+
+    class << self
+
+      # Create a PgPath from a string in Postgres format
+
+      def from_sql(s)
+        if s =~ /^(\[)\(.*\)(,\(.*\))?\]$/ || s =~ /^(\()\(.*\)(,\(.*\))?\)$/
+          closed = $1 == "("
+          points = s.scan(/\([^(]*?\)/).collect do |t|
+            PgPoint.from_sql(t)
+          end
+          PgPath.new(closed, *points)
+        else
+          raise ArgumentError, "Invalid path: #{s.inspect}"
+        end
+      end
+
+    end
+
+    def initialize(closed = true, *points)
+      @points = points
+      @closed = closed
+    end
+
+    def to_s
+      s = points.join(", ")
+      if closed
+        "(#{s})"
+      else
+        "[#{s}]"
+      end
+    end
+
+    protected
+
+    def parts
+      [closed, points]
+    end
+
+    private
+
+    def column_type
+      'path'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgPoint.rb

@@ -0,0 +1,65 @@
+require 'sqlpostgres/PgType'
+
+module SqlPostgres
+
+  # This class holds the value of a "point" column.
+
+  class PgPoint < PgType
+
+    # Return the x coordinate
+
+    attr_reader :x
+
+    # Return the y coordinate
+
+    attr_reader :y
+
+    class << self
+
+      # Create a PgPoint from a string in Postgres format (ie
+      # "(1,2)").
+
+      def from_sql(s)
+        if s =~ /^\((.*?),(.*\))$/
+          PgPoint.new($1.to_f, $2.to_f)
+        else
+          raise ArgumentError, "Invalid point: #{s.inspect}"
+        end
+      end
+
+    end
+
+    # Constructor taking the x and y coordinate
+
+    def initialize(x = 0, y = 0)
+      @x = x
+      @y = y
+    end
+
+    # Return a string representation (ie "(1, 2)").
+
+    def to_s
+      "(%g, %g)" % parts
+    end
+
+    protected
+
+    def parts
+      [x, y]
+    end
+
+    private
+
+    def column_type
+      'point'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/lib/sqlpostgres/PgPolygon.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), "PgType")
+
+module SqlPostgres
+
+  # This class holds the value of a "point" column.
+
+  class PgPolygon < PgType
+
+    attr_reader :points
+
+    class << self
+
+      # Create a PgPolygon from a string in Postgres format
+
+      def from_sql(s)
+        if s =~ /^(\()\(.*\)(,\(.*\))?\)$/
+          points = s.scan(/\([^(]*?\)/).collect do |t|
+            PgPoint.from_sql(t)
+          end
+          PgPolygon.new(*points)
+        else
+          raise ArgumentError, "Invalid polygon: #{s.inspect}"
+        end
+      end
+
+    end
+
+    def initialize(*points)
+      @points = points
+    end
+
+    def to_s
+      "(#{points.join(", ")})"
+    end
+
+    protected
+
+    def parts
+      points
+    end
+
+    private
+
+    def column_type
+      'polygon'
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End: