torque-postgresql 0.2.16 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6b3476419620f407fcfbfedf49a8e14b14673c4
-  data.tar.gz: 086f8999ac9c845a3c794a225ee170e0af593f26
+  metadata.gz: 0b0809f9b876678e23210f46f24f06fd04191a0f
+  data.tar.gz: 854147b9660c9f30979224d3d92949ddeb0dcae0
 SHA512:
-  metadata.gz: bc22219a6090c31d8c4192de419d49e073cfc470391f0f39c18b223f33cfd788f0d5b332e26c71f5a4d0b117c61e62d29a3741e5414e0e4c56f3d59493eef75b
-  data.tar.gz: 87838a9c5454a50140d8221099a9f0dce25ae9ab808a1dd7f7d1304e0b1f8b336aa48db83ea12a83d78fa4dc99b9dc20d84013da017d80153a2ca847c15588cc
+  metadata.gz: a8a7c3422d3592263efdb14a76063a6bfd78fb573cf6bc904b1a8053c0baa5272924576a61b87319d28ef8b44c9de6562ef98c669f16733c6e9c4fa1a5246787
+  data.tar.gz: 4b5c5dec025229542565c9ba2f5de62b983cf442bb040d547012e7c0a55e52f3c0093a6c720b3aa78d0437dc8ce67e965ead58f6b5cf903868ad034a07233136

data/README.rdoc

@@ -16,7 +16,7 @@ A short rundown of some of the major features:
 It creates a separated class to hold each enum set that can be used by multiple
 models, it also keeps the database consistent. The enum type is known to have
 better performance against string- and integer-like enums.
-{PostgreSQL Docs}[https://www.postgresql.org/docs/9.2/static/datatype-enum.html]
+{PostgreSQL Docs}[https://www.postgresql.org/docs/9.6/static/datatype-enum.html]
 
    create_enum :roles, %i(visitor manager admin)
 
@@ -28,11 +28,84 @@ better performance against string- and integer-like enums.
 
   {Learn more}[link:classes/Torque/PostgreSQL/Attributes/Enum.html]
 
+* Enum set type manager
+
+The enum type is known to have a better performance against string- and integer-
+like enums. Now with the array option, which behaves like binary assignment,
+each record can have multiple enum values.
+{PostgreSQL Docs}[https://www.postgresql.org/docs/9.6/static/datatype-enum.html]
+
+   create_enum :permissions, %i(read write exec)
+
+   add_column :posts, :creator_permissions, :permissions, array: true
+
+   Enum::PermissionsSet.new(3) # [:read, :write]
+
+   post.creator_permissions.write?
+
+  {Learn more}[link:classes/Torque/PostgreSQL/Attributes/EnumSet.html]
+
+* Period complex queries
+
+This provides extended and complex calculations over date and time ranges. In a
+few words, you can now store `start_time` and `finish_time` in the same column
+and relies on the methods provided here to fo your magic.
+{PostgreSQL Docs}[https://www.postgresql.org/docs/9.6/functions-range.html]
+
+   add_column :events, :period, :tsrange
+   add_column :events, :interval, :interval
+
+   Event.create(title: 'Test', period: ['2019-01-01 12:00:00', '2019-01-01 14:00:00'], interval: 15.minutes)
+
+   Event.overlapping('2019-01-01 13:00:00', '2019-01-01 15:00:00').count
+
+   Event.not_real_overlapping('2019-01-01 11:00:00', '2019-01-01 13:00:00').empty?
+
+  {Learn more}[link:classes/Torque/PostgreSQL/Attributes/Builder/Period.html]
+
+* Has many array association
+
+The idea is simple, one table stores all the ids and the other one says that
+`has many` records on that table because its records ids exist in the column of
+the array. Like: `Tag has many Videos connected through an array`.
+{PostgreSQL Docs}[https://www.postgresql.org/docs/9.6/arrays.html]
+
+   add_column :videos, :tag_ids, :bigint, array: true
+
+   Tag.has_many :videos, array: true
+
+   Tag.videos.size
+
+   Tag.videos << another_video
+
+  {Learn more}[link:classes/Torque/PostgreSQL/Reflection/AbstractReflection.html]
+
+* Belongs to many association
+
+The original `belongs_to` associations define a `SingularAssociation`, which
+means that it could be extended with `array: true`. In this case, I decided to
+create my own `CollectionAssociation` called `belongs_to_many`, which behaves
+similar to the single one, but storing and returning a list of records.
+
+With this, now you can say things like `Project belongs to many employees`,
+which is more syntactically correct than `Project has many employees`
+{PostgreSQL Docs}[https://www.postgresql.org/docs/9.6/arrays.html]
+
+   add_column :videos, :tag_ids, :bigint, array: true
+
+   Video.belongs_to_many :tags
+
+   Video.tags.size
+
+   Video.tags << Tag.new(title: 'rails')
+
+  {Learn more}[link:classes/Torque/PostgreSQL/Reflection/BelongsToManyReflection.html]
+
 * Distinct On
 
 MySQL-like group by statement on queries. It keeps only the first row of each
 set of rows where the given expressions evaluate to equal.
-{PostgreSQL Docs}[https://www.postgresql.org/docs/9.5/static/sql-select.html#SQL-DISTINCT]
+{PostgreSQL Docs}[https://www.postgresql.org/docs/9.6/static/sql-select.html#SQL-DISTINCT]
 
    User.distinct_on(:name).all
 
@@ -42,7 +115,7 @@ set of rows where the given expressions evaluate to equal.
 
 Provides a way to write auxiliary statements for use in a larger query. It's
 reconfigured on the model, and then can be used during querying process.
-{PostgreSQL Docs}[https://www.postgresql.org/docs/9.1/static/queries-with.html]
+{PostgreSQL Docs}[https://www.postgresql.org/docs/9.6/static/queries-with.html]
 
    class User < ActiveRecord::Base
      auxiliary_statement :last_comment do |cte|

data/lib/torque-postgresql.rb

@@ -1 +1,2 @@
 require 'torque/postgresql'
+require 'torque/range'

data/lib/torque/postgresql.rb

@@ -4,23 +4,29 @@ require 'active_model'
 require 'active_record'
 require 'active_support'
 
+require 'active_support/core_ext/date/acts_like'
+require 'active_support/core_ext/time/zones'
 require 'active_support/core_ext/hash/compact'
 require 'active_record/connection_adapters/postgresql_adapter'
 
 require 'torque/postgresql/config'
 require 'torque/postgresql/version'
 require 'torque/postgresql/collector'
+require 'torque/postgresql/geometry_builder'
 
 require 'torque/postgresql/i18n'
 require 'torque/postgresql/arel'
 require 'torque/postgresql/adapter'
+require 'torque/postgresql/associations'
 require 'torque/postgresql/attributes'
+require 'torque/postgresql/autosave_association'
 require 'torque/postgresql/auxiliary_statement'
 require 'torque/postgresql/base'
 require 'torque/postgresql/inheritance'
 require 'torque/postgresql/coder'
 require 'torque/postgresql/migration'
 require 'torque/postgresql/relation'
+require 'torque/postgresql/reflection'
 require 'torque/postgresql/schema_cache'
 require 'torque/postgresql/schema_dumper'
 

data/lib/torque/postgresql/adapter.rb

@@ -9,7 +9,6 @@ require_relative 'adapter/schema_statements'
 module Torque
   module PostgreSQL
     module Adapter
-
       include Quoting
       include ColumnDumper unless Torque::PostgreSQL::AR521
       include DatabaseStatements
@@ -18,10 +17,9 @@ module Torque
       # Get the current PostgreSQL version as a Gem Version.
       def version
         @version ||= Gem::Version.new(
-          select_value('SELECT version()')
-            .match(/#{Adapter::ADAPTER_NAME} ([\d\.]+)/)[1])
+          select_value('SELECT version()').match(/#{Adapter::ADAPTER_NAME} ([\d\.]+)/)[1]
+        )
       end
-
     end
 
     ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend Adapter

data/lib/torque/postgresql/adapter/database_statements.rb

@@ -3,7 +3,7 @@ module Torque
     module Adapter
       module DatabaseStatements
 
-        EXTENDED_DATABASE_TYPES = %i(enum interval)
+        EXTENDED_DATABASE_TYPES = %i(enum enum_set interval)
 
         # Switch between dump mode or not
         def dump_mode!
@@ -35,7 +35,11 @@ module Torque
         # Change some of the types being mapped
         def initialize_type_map(m = type_map)
           super
+          m.register_type 'box', OID::Box.new
+          m.register_type 'circle', OID::Circle.new
           m.register_type 'interval', OID::Interval.new
+          m.register_type 'line', OID::Line.new
+          m.register_type 'segment', OID::Segment.new
         end
 
         # :nodoc:
@@ -57,7 +61,8 @@ module Torque
 
           query = <<-SQL
             SELECT      a.typelem AS oid, t.typname, t.typelem,
-                        t.typdelim, t.typbasetype, t.typtype
+                        t.typdelim, t.typbasetype, t.typtype,
+                        t.typarray
             FROM        pg_type t
             INNER JOIN  pg_type a ON (a.oid = t.typarray)
             LEFT JOIN   pg_catalog.pg_namespace n ON n.oid = t.typnamespace
@@ -76,14 +81,9 @@ module Torque
 
           execute_and_clear(query, 'SCHEMA', []) do |records|
             records.each do |row|
-              typtype = row['typtype']
-              type = begin
-                case
-                when typtype == 'e' then OID::Enum.create(row)
-                end
+              case row['typtype']
+              when 'e' then OID::Enum.create(row, type_map)
               end
-
-              type_map.register_type row['oid'].to_i, type
             end
           end
         end
@@ -156,6 +156,20 @@ module Torque
           SQL
         end
 
+        # Extracts the value from a PostgreSQL column default definition.
+        def extract_value_from_default(default)
+          case default
+            # Array elements
+          when /\AARRAY\[(.*)\]\z/
+            # TODO: Improve this since it's not the most safe approach
+            eval(default.gsub(/ARRAY|::\w+(\[\])?/, ''))
+          else
+            super
+          end
+        rescue SyntaxError
+          # If somethin goes wrong with the eval, just return nil
+        end
+
       end
     end
   end

data/lib/torque/postgresql/adapter/oid.rb

@@ -1,5 +1,11 @@
+require_relative 'oid/box'
+require_relative 'oid/circle'
 require_relative 'oid/enum'
+require_relative 'oid/enum_set'
 require_relative 'oid/interval'
+require_relative 'oid/line'
+require_relative 'oid/range'
+require_relative 'oid/segment'
 
 module Torque
   module PostgreSQL
@@ -7,8 +13,13 @@ module Torque
       module OID
       end
 
-      ActiveRecord::Type.register(:enum, OID::Enum, adapter: :postgresql)
+      ActiveRecord::Type.register(:box,      OID::Box,      adapter: :postgresql)
+      ActiveRecord::Type.register(:circle,   OID::Circle,   adapter: :postgresql)
+      ActiveRecord::Type.register(:enum,     OID::Enum,     adapter: :postgresql)
+      ActiveRecord::Type.register(:enum_set, OID::EnumSet,  adapter: :postgresql)
       ActiveRecord::Type.register(:interval, OID::Interval, adapter: :postgresql)
+      ActiveRecord::Type.register(:line,     OID::Line,     adapter: :postgresql)
+      ActiveRecord::Type.register(:segment,  OID::Segment,  adapter: :postgresql)
     end
   end
 end

data/lib/torque/postgresql/adapter/oid/box.rb

@@ -0,0 +1,28 @@
+module Torque
+  module PostgreSQL
+    class Box < Struct.new(:x1, :y1, :x2, :y2)
+      def points
+        klass = Torque::PostgreSQL.config.geometry.point_class
+        [
+          klass.new(x1, y1),
+          klass.new(x1, y2),
+          klass.new(x2, y1),
+          klass.new(x2, y2),
+        ]
+      end
+    end
+
+    config.geometry.box_class ||= ::ActiveRecord.const_set('Box', Class.new(Box))
+
+    module Adapter
+      module OID
+        class Box < Torque::PostgreSQL::GeometryBuilder
+
+          PIECES = %i[x1 y1 x2 y2].freeze
+          FORMATION = '((%s,%s),(%s,%s))'.freeze
+
+        end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/oid/circle.rb

@@ -0,0 +1,37 @@
+module Torque
+  module PostgreSQL
+    class Circle < Struct.new(:x, :y, :r)
+      alias radius r
+      alias radius= r=
+
+      def center
+        point_class.new(x, y)
+      end
+
+      def center=(value)
+        parts = value.is_a?(point_class) ? [value.x, value.y] : value[0..1]
+        self.x = parts.first
+        self.y = parts.last
+      end
+
+      private
+
+        def point_class
+          Torque::PostgreSQL.config.geometry.point_class
+        end
+    end
+
+    config.geometry.circle_class ||= ::ActiveRecord.const_set('Circle', Class.new(Circle))
+
+    module Adapter
+      module OID
+        class Circle < Torque::PostgreSQL::GeometryBuilder
+
+          PIECES = %i[x y r].freeze
+          FORMATION = '<(%s,%s),%s>'.freeze
+
+        end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/oid/enum.rb

@@ -6,12 +6,16 @@ module Torque
 
           attr_reader :name, :klass
 
-          def self.create(row)
-            new(row['typname'])
-          end
+          def self.create(row, type_map)
+            name    = row['typname']
+            oid     = row['oid'].to_i
+            arr_oid = row['typarray'].to_i
+
+            oid_klass     = Enum.new(name)
+            oid_set_klass = EnumSet.new(name, oid_klass.klass)
 
-          def self.auto_initialize?
-            Torque::PostgreSQL.config.enum.initializer
+            type_map.register_type(oid,     oid_klass)
+            type_map.register_type(arr_oid, oid_set_klass)
           end
 
           def initialize(name)

data/lib/torque/postgresql/adapter/oid/enum_set.rb

@@ -0,0 +1,44 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        class EnumSet < Enum
+
+          attr_reader :enum_klass
+
+          def initialize(name, enum_klass)
+            @name  = name + '[]'
+            @klass = Attributes::EnumSet.lookup(name, enum_klass)
+            @enum_klass = enum_klass
+          end
+
+          def type
+            :enum_set
+          end
+
+          def serialize(value)
+            return if value.blank?
+            value = cast_value(value)
+            value.map(&:to_s) unless value.blank?
+          end
+
+          # Always use symbol values for schema dumper
+          def type_cast_for_schema(value)
+            cast_value(value).map(&:to_sym).inspect
+          end
+
+          private
+
+            def cast_value(value)
+              return if value.blank?
+              return value if value.is_a?(@klass)
+              @klass.new(value)
+            rescue Attributes::EnumSet::EnumError
+              nil
+            end
+
+        end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/oid/line.rb

@@ -0,0 +1,59 @@
+module Torque
+  module PostgreSQL
+    class Line < Struct.new(:slope, :intercept)
+      alias c intercept
+      alias c= intercept=
+
+      def a=(value)
+        self.slope = vertical? \
+          ? Float::INFINITY \
+          : Rational(value, b)
+      end
+
+      def a
+        slope.numerator
+      end
+
+      def b=(value)
+        self.slope = value.zero? \
+          ? Float::INFINITY \
+          : Rational(a, value)
+      end
+
+      def b
+        vertical? ? 0 : slope.denominator
+      end
+
+      def horizontal?
+        slope.zero?
+      end
+
+      def vertical?
+        !slope.try(:infinite?).eql?(nil)
+      end
+    end
+
+    config.geometry.line_class ||= ::ActiveRecord.const_set('Line', Class.new(Line))
+
+    module Adapter
+      module OID
+        class Line < Torque::PostgreSQL::GeometryBuilder
+
+          PIECES = %i[a b c].freeze
+          FORMATION = '{%s,%s,%s}'.freeze
+
+          protected
+
+            def build_klass(*args)
+              return nil if args.empty?
+              check_invalid_format!(args)
+
+              a, b, c = args.try(:first, pieces.size)&.map(&:to_f)
+              slope = b.zero? ? Float::INFINITY : Rational(a, b)
+              config_class.new(slope, c)
+            end
+        end
+      end
+    end
+  end
+end