torque-postgresql 0.1.7 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e2b7ce3a0529219858f1d5f92553a4326bf22344
-  data.tar.gz: 8b012bc439db2dd8110d19a6c387e5046a4af67a
+  metadata.gz: 979764ebdcc3d060ce4aab1c28de3dc4f0aff8b1
+  data.tar.gz: e522c438e3d8d04f61d761d5738217b471724075
 SHA512:
-  metadata.gz: c95aa9ac2d48a6328d77cbe888c970e5994b675203f86dceb0ab7a068604850e42b0e0f1b6349807dd09fdc1977c2cfe21a3db5c55d0af36b331cfc7913863dd
-  data.tar.gz: 8466225dd5f79f98c6837f00f854244ed15251da90f2441238426a486d9d4ca018b7a4f4ef53a7e3d6e3bbeb4f266394d63cdc3acfb9670a92b278999bb2ef4e
+  metadata.gz: ccbc5797fdac9fecf2208acda837db28990235576848a22d389664237f45d6cc9d2cbfe6101aa1992615a2daad01f4fc6e1f792c59c18ed51d32a943f93fbfbd
+  data.tar.gz: 20e7a8e8dbe6b4c4fc0eed20d84a003fc908a855da63ff7df00df2b6b9d706db21e28ecb36c5785156f663c6dc4ddb1168383c4d8e18dba1916f7b888f12ee02

data/README.rdoc

@@ -0,0 +1,74 @@
+= Torque PostgreSQL -- Add support to complex resources of PostgreSQL, like data
+types, user-defined types and auxiliary statements (CTE)
+
+This is a plugin that enhance Ruby on Rails enabling easy access to existing
+PostgreSQL advanced resources, such as data types and queries statements. Its
+features are design to be as similar as Rails architecture and they work as
+smooth as possible.
+
+100% plug-and-play, with optional configurations so that can be adapted to
+your's project design pattern.
+
+A short rundown of some of the major features:
+
+* Enum type manager
+
+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]
+
+   create_enum :roles, %i(visitor manager admin)
+
+   add_column :users, :role, :roles
+
+   Enum::Roles.admin
+
+   Users.roles
+
+  {Learn more}[link:classes/Torque/PostgreSQL/Attributes/Enum.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]
+
+   User.distinct_on(:name).all
+
+  {Learn more}[link:classes/Torque/PostgreSQL/Relation/DistinctOn.html]
+
+* Auxiliary Statements
+
+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]
+
+   class User < ActiveRecord::Base
+     auxiliary_statement :last_comment do |cte|
+       cte.query Comment.distinct_on(:user_id).order(:user_id, id: :desc)
+       cte.attributes content: :last_comment_content
+     end
+   end
+
+   user = User.with(:last_comment).first
+
+  {Learn more}[link:classes/Torque/PostgreSQL/AuxiliaryStatement.html]
+
+
+== Download and installation
+
+The latest version of Torque PostgreSQL can be installed with RubyGems:
+
+  $ gem install torque-postgresql
+
+Source code can be downloaded direct from the GitHub repository:
+
+* https://github.com/crashtech/torque-postgresql
+
+
+== License
+
+Torque PostgreSQL is released under the MIT license:
+
+* http://www.opensource.org/licenses/MIT

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

@@ -5,6 +5,11 @@ module Torque
 
         EXTENDED_DATABASE_TYPES = %i(enum interval)
 
+        # Switch between dump mode or not
+        def dump_mode!
+          @_dump_mode = !!!@_dump_mode
+        end
+
         # Check if a given type is valid.
         def valid_type?(type)
           super || extended_types.include?(type)
@@ -63,7 +68,7 @@ module Torque
               typtype = row['typtype']
               type = begin
                 case
-                when typtype == 'e'.freeze then OID::Enum.create(row)
+                when typtype == 'e' then OID::Enum.create(row)
                 end
               end
 
@@ -73,7 +78,7 @@ module Torque
         end
 
         # Gets a list of user defined types.
-        # You can even choose the +typcategory+ filter
+        # You can even choose the +category+ filter
         def user_defined_types(category = nil)
           category_condition = "AND     typtype = '#{category}'" unless category.nil?
           select_all(<<-SQL).rows.to_h
@@ -97,6 +102,43 @@ module Torque
           SQL
         end
 
+        # Get the list of inherited tables associated with their parent tables
+        def inherited_tables
+          tables = select_all(<<-SQL).rows
+            SELECT child.relname             AS table_name,
+                   array_agg(parent.relname) AS inheritances
+            FROM pg_inherits
+            JOIN pg_class parent ON pg_inherits.inhparent = parent.oid
+            JOIN pg_class child  ON pg_inherits.inhrelid  = child.oid
+            GROUP BY child.relname, pg_inherits.inhrelid
+            ORDER BY pg_inherits.inhrelid
+          SQL
+
+          tables.map do |(table, refs)|
+            [table, Coder.decode(refs)]
+          end.to_h
+        end
+
+        # Get the list of columns, and their definition, but only from the
+        # actual table, does not include columns that comes from inherited table
+        def column_definitions(table_name) # :nodoc:
+          local_condition = 'AND a.attislocal IS TRUE' if @_dump_mode
+          query(<<-SQL, 'SCHEMA')
+              SELECT a.attname, format_type(a.atttypid, a.atttypmod),
+                     pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
+             (SELECT c.collname FROM pg_collation c, pg_type t
+               WHERE c.oid = a.attcollation AND t.oid = a.atttypid AND a.attcollation <> t.typcollation),
+                     col_description(a.attrelid, a.attnum) AS comment
+                FROM pg_attribute a
+           LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+               WHERE a.attrelid = '#{quote_table_name(table_name)}'::regclass
+                 AND a.attnum > 0
+                 AND a.attisdropped IS FALSE
+                 #{local_condition}
+               ORDER BY a.attnum
+          SQL
+        end
+
       end
     end
   end

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

@@ -0,0 +1,55 @@
+module Torque
+  module PostgreSQL
+    module Adapter
+      module SchemaCreation
+
+        # Redefine original table creation command to ensure PostgreSQL standard
+        def visit_TableDefinition(o)
+          create_sql = "CREATE#{' TEMPORARY' if o.temporary}"
+          create_sql << " TABLE #{quote_table_name(o.name)}"
+
+          statements = o.columns.map{ |c| accept c }
+          statements << accept(o.primary_keys) if o.primary_keys
+
+          if supports_indexes_in_create?
+            statements.concat(o.indexes.map do |column_name, options|
+              index_in_create(o.name, column_name, options)
+            end)
+          end
+
+          if supports_foreign_keys_in_create?
+            statements.concat(o.foreign_keys.map do |to_table, options|
+              foreign_key_in_create(o.name, to_table, options)
+            end)
+          end
+
+          if o.as
+            create_sql << " AS #{@conn.to_sql(o.as)}"
+          else
+            create_sql << " (#{statements.join(', ')})"
+            add_table_options!(create_sql, table_options(o))
+
+            if o.inherits.present?
+              tables = o.inherits.map(&method(:quote_table_name))
+              create_sql << " INHERITS ( #{tables.join(' , ')} )"
+            end
+          end
+
+          create_sql
+        end
+
+        # Keep rails 5.0 and 5.1 compatibility
+        def supports_foreign_keys_in_create?
+          if defined?(super)
+            super
+          else
+            supports_foreign_keys?
+          end
+        end
+
+      end
+
+      ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaCreation.prepend SchemaCreation
+    end
+  end
+end

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

@@ -16,8 +16,33 @@ module Torque
 
       end
 
+      module TableDefinition
+        include ColumnMethods
+
+        attr_reader :inherits
+
+        def initialize(name, *args, **options)
+          old_args = []
+          old_args << options.delete(:temporary) || false
+          old_args << options.delete(:options)
+          old_args << options.delete(:as)
+          comment = options.delete(:comment)
+
+          super(name, *old_args, comment: comment)
+
+          if options.key?(:inherits)
+            @inherits = Array[options.delete(:inherits)].flatten.compact
+            @inherited_id = !(options.key?(:primary_key) || options.key?(:id))
+          end
+        end
+
+        def inherited_id?
+          @inherited_id
+        end
+      end
+
       ActiveRecord::ConnectionAdapters::PostgreSQL::Table.include ColumnMethods
-      ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.include ColumnMethods
+      ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.include TableDefinition
 
       if ActiveRecord::ConnectionAdapters::PostgreSQL.const_defined?('ColumnDefinition')
         module ColumnDefinition

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

@@ -3,6 +3,8 @@ module Torque
     module Adapter
       module SchemaStatements
 
+        TableDefinition = ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
+
         # Drops a type.
         def drop_type(name, options = {})
           force = options.fetch(:force, '').upcase
@@ -69,8 +71,26 @@ module Torque
           select_values("SELECT unnest(enum_range(NULL::#{name}))")
         end
 
+        # Rewrite the method that creates tables to easily accept extra options
+        def create_table(table_name, **options, &block)
+          td = create_table_definition(table_name, **options)
+          options[:id] = false if td.inherited_id?
+          options[:temporary] = td
+
+          super table_name, **options, &block
+        end
+
         private
 
+          # This waits for the second call to really return the table definition
+          def create_table_definition(*args, **options) # :nodoc:
+            if !args.second.kind_of?(TableDefinition)
+              TableDefinition.new(*args, **options)
+            else
+              args.second
+            end
+          end
+
           def quote_enum_values(name, values, options)
             prefix = options[:prefix]
             prefix = name if prefix === true

data/lib/torque/postgresql/adapter.rb

@@ -1,7 +1,7 @@
-
 require_relative 'adapter/database_statements'
 require_relative 'adapter/oid'
 require_relative 'adapter/quoting'
+require_relative 'adapter/schema_creation'
 require_relative 'adapter/schema_definitions'
 require_relative 'adapter/schema_dumper'
 require_relative 'adapter/schema_statements'

data/lib/torque/postgresql/arel/join_source.rb

@@ -0,0 +1,15 @@
+module Torque
+  module PostgreSQL
+    module Arel
+      module JoinSource
+        attr_accessor :only
+
+        def only?
+          only === true
+        end
+      end
+
+      ::Arel::Nodes::JoinSource.include JoinSource
+    end
+  end
+end

data/lib/torque/postgresql/arel/select_manager.rb

@@ -0,0 +1,21 @@
+module Torque
+  module PostgreSQL
+    module Arel
+      module SelectManager
+
+        def using column
+          column = ::Arel::Nodes::SqlLiteral.new(column.to_s)
+          @ctx.source.right.last.right = Using.new(column)
+          self
+        end
+
+        def only
+          @ctx.source.only = true
+        end
+
+      end
+
+      ::Arel::SelectManager.include SelectManager
+    end
+  end
+end

data/lib/torque/postgresql/arel/using.rb

@@ -0,0 +1,10 @@
+module Torque
+  module PostgreSQL
+    module Arel
+      class Using < ::Arel::Nodes::Unary
+      end
+
+      ::Arel::Nodes::Using = Using
+    end
+  end
+end

data/lib/torque/postgresql/arel/visitors.rb

@@ -2,13 +2,30 @@ module Torque
   module PostgreSQL
     module Arel
       module Visitors
+
+        # Enclose select manager with parenthesis
+        # :TODO: Remove when checking the new version of Arel
         def visit_Arel_SelectManager o, collector
           collector << '('
           visit(o.ast, collector) << ')'
         end
+
+        # Add ONLY modifier to query
+        def visit_Arel_Nodes_JoinSource(o, collector)
+          collector << 'ONLY ' if o.only?
+          super
+        end
+
+        # Add USING modifier to query
+        def visit_Torque_PostgreSQL_Arel_Using(o, collector)
+          collector << 'USING ( '
+          collector << o.expr
+          collector << ' )'
+        end
+
       end
 
-      ::Arel::Visitors::ToSql.prepend Visitors
+      ::Arel::Visitors::PostgreSQL.include Visitors
     end
   end
 end

data/lib/torque/postgresql/arel.rb

@@ -0,0 +1,4 @@
+require_relative 'arel/join_source'
+require_relative 'arel/select_manager'
+require_relative 'arel/visitors'
+require_relative 'arel/using'

data/lib/torque/postgresql/attributes/enum.rb

@@ -36,7 +36,7 @@ module Torque
             @values ||= self == Enum ? nil : begin
               conn_name = connection_specification_name
               conn = connection(conn_name)
-              conn.enum_values(type_name)
+              conn.enum_values(type_name).freeze
             end
           end
 
@@ -227,9 +227,15 @@ module Torque
         defined_enums[attribute] = subtype.klass
       end
 
+      # Define a method to find yet to define constants
       Torque::PostgreSQL.config.enum.namespace.define_singleton_method(:const_missing) do |name|
         Enum.lookup(name)
       end
+
+      # Define a helper method to get a sample value
+      Torque::PostgreSQL.config.enum.namespace.define_singleton_method(:sample) do |name|
+        Enum.lookup(name).sample
+      end
     end
   end
 end

data/lib/torque/postgresql/attributes.rb

@@ -1,4 +1,3 @@
-
 require_relative 'attributes/type_map'
 require_relative 'attributes/lazy'
 
@@ -11,14 +10,23 @@ module Torque
     module Attributes
       extend ActiveSupport::Concern
 
+      # Configure enum_save_on_bang behavior
       included do
         class_attribute :enum_save_on_bang, instance_accessor: true
         self.enum_save_on_bang = Torque::PostgreSQL.config.enum.save_on_bang
       end
 
       module ClassMethods
+
         private
 
+          # If the attributes are not loaded,
+          def method_missing(method_name, *args, &block)
+            return super unless define_attribute_methods
+            self.send(method_name, *args, &block)
+          end
+
+          # Use local type map to identify attribute decorator
           def define_attribute_method(attribute)
             type = attribute_types[attribute]
             super unless TypeMap.lookup(type, self, attribute, true)

data/lib/torque/postgresql/auxiliary_statement/settings.rb

@@ -35,11 +35,18 @@ module Torque
 
         # There are two ways of setting the query:
         # - A simple relation based on a Model
+        # - A Arel-based select manager
         # - A string or a proc that requires the table name as first argument
         def query(value = nil, command = nil)
           return @query if value.nil?
           return @query = value if relation_query?(value)
 
+          if value.is_a?(::Arel::SelectManager)
+            @query = value
+            @query_table = value.source.left.name
+            return
+          end
+
           valid_type = command.respond_to?(:call) || command.is_a?(String)
           raise ArgumentError, <<-MSG.strip.gsub(/\n +/, ' ') if command.nil?
             To use proc or string as query, you need to provide the table name

data/lib/torque/postgresql/auxiliary_statement.rb

@@ -42,6 +42,11 @@ module Torque
             obj.ancestors.include?(ActiveRecord::Base)
         end
 
+        # Identify if the query set may be used as arel
+        def arel_query?(obj)
+          !obj.nil? && obj.is_a?(::Arel::SelectManager)
+        end
+
         # Set a configuration block, if the class is already set up, just clean
         # the query and wait it to be setup again
         def configurator(block)
@@ -183,10 +188,10 @@ module Torque
       # Start a new auxiliary statement giving extra options
       def initialize(*args)
         options = args.extract_options!
-        uses_key = Torque::PostgreSQL.config.auxiliary_statement.send_arguments_key
+        args_key = Torque::PostgreSQL.config.auxiliary_statement.send_arguments_key
 
         @join = options.fetch(:join, {})
-        @uses = options.fetch(uses_key, [])
+        @args = options.fetch(args_key, {})
         @select = options.fetch(:select, {})
         @join_type = options.fetch(:join_type, join_type)
       end
@@ -214,11 +219,14 @@ module Torque
       # Ensure that all the dependencies are loaded in the base relation
       def ensure_dependencies!(base)
         requires.each do |dependent|
-          next if base.auxiliary_statements.key?(dependent)
+          dependent_klass = base.model.auxiliary_statements_list[dependent]
+          next if base.auxiliary_statements_values.any? do |cte|
+            cte.is_a?(dependent_klass)
+          end
 
           instance = AuxiliaryStatement.instantiate(dependent, base)
           instance.ensure_dependencies!(base)
-          base.auxiliary_statements[dependent] = instance
+          base.auxiliary_statements_values += [instance]
         end
       end
 
@@ -242,18 +250,19 @@ module Torque
         def mount_query
           klass = self.class
           query = klass.query
-          uses = @uses
+          args = @args
 
           # Call a proc to get the query
-          if query.respond_to?(:call)
-            query = query.call(*uses)
-            uses = []
+          if query.methods.include?(:call)
+            call_args = query.try(:arity) === 0 ? [] : [OpenStruct.new(args)]
+            query = query.call(*call_args)
+            args = []
           end
 
           # Prepare the query depending on its type
           if query.is_a?(String)
-            uses.map!(&klass.parent.connection.method(:quote))
-            ::Arel::Nodes::SqlLiteral.new("(#{query})" % uses)
+            args = args.map{ |k, v| [k, klass.parent.connection.quote(v)] }.to_h
+            ::Arel::Nodes::SqlLiteral.new("(#{query})" % args)
           elsif relation_query?(query)
             query.select(*select_columns).arel
           else

data/lib/torque/postgresql/base.rb

@@ -4,19 +4,88 @@ module Torque
       extend ActiveSupport::Concern
 
       module ClassMethods
-        delegate :distinct_on, :with, to: :all
+        delegate :distinct_on, :with, :itself_only, :cast_records, to: :all
 
-        private
+        # Wenever it's inherited, add a new list of auxiliary statements
+        # It also adds an auxiliary statement to load inherited records' relname
+        def inherited(subclass)
+          super
 
-          # Wenever it's inherited, add a new list of auxiliary statements
-          def inherited(subclass)
-            subclass.class_attribute(:auxiliary_statements_list)
-            subclass.auxiliary_statements_list = Hash.new
-            super
+          subclass.class_attribute(:auxiliary_statements_list)
+          subclass.auxiliary_statements_list = Hash.new
+          record_class = ActiveRecord::Relation._record_class_attribute
+
+          # Define helper methods to return the class of the given records
+          subclass.auxiliary_statement record_class do |cte|
+            pg_class = ::Arel::Table.new('pg_class')
+            arel_query = ::Arel::SelectManager.new(pg_class)
+            arel_query.project(pg_class['oid'], pg_class['relname'].as(record_class.to_s))
+
+            cte.query 'pg_class', arel_query.to_sql
+            cte.attributes col(record_class) => record_class
+            cte.join tableoid: :oid
+          end
+
+          # Define the dynamic attribute that returns the same information as
+          # the one provided by the auxiliary statement
+          subclass.dynamic_attribute(record_class) do
+            next self.class.table_name unless self.class.physically_inheritances?
+
+            pg_class = ::Arel::Table.new('pg_class')
+            source = ::Arel::Table.new(subclass.table_name, as: 'source')
+            quoted_id = ::Arel::Nodes::Quoted.new(self.class.connection.quote(id))
+
+            query = ::Arel::SelectManager.new(pg_class)
+            query.join(source).on(pg_class['oid'].eq(source['tableoid']))
+            query.where(source[subclass.primary_key].eq(quoted_id))
+            query.project(pg_class['relname'])
+
+            self.class.connection.select_value(query)
           end
+        end
 
         protected
 
+          # Allow optional select attributes to be loaded manually when they are
+          # not present. This is associated with auxiliary statement, which
+          # permits columns that can be loaded through CTEs, be loaded
+          # individually for a single record
+          #
+          # For instance, if you have a statement that can load an user's last
+          # comment content, by querying the comments using an auxiliary
+          # statement.
+          #   subclass.auxiliary_statement :last_comment do |cte|
+          #     cte.query Comment.order(:user_id, id: :desc)
+          #       .distinct_on(:user_id)
+          #     cte.attributes col(:content) => :last_comment
+          #     cte.join_type :left
+          #   end
+          #
+          # In case you don't use 'with(:last_comment)', you can do the
+          # following.
+          #   dynamic_attribute(:last_comment) do
+          #     comments.order(id: :desc).first.content
+          #   end
+          #
+          # This means that any auxiliary statements can have their columns
+          # granted even when they are not used
+          def dynamic_attribute(name, &block)
+            define_method(name) do
+              return read_attribute(name) if has_attribute?(name)
+              result = self.instance_exec(&block)
+
+              type_klass = ActiveRecord::Type.respond_to?(:default_value) \
+                ? ActiveRecord::Type.default_value \
+                : self.class.connection.type_map.send(:default_value)
+
+              @attributes[name.to_s] = ActiveRecord::Relation::QueryAttribute.new(
+                name.to_s, result, type_klass,
+              )
+
+              read_attribute(name)
+            end
+          end
+
           # Creates a new auxiliary statement (CTE) under the base class
           # attributes key:
           # Provides a map of attributes to be exposed to the main query.