torque-postgresql 3.0.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc0fe29b7ec2c1478b6718efaddbb7ba2be2c6fd18dc56dc5e52ca52575811dd
-  data.tar.gz: b1f7c28054bb9ed68ebc2506ca71cb0d4c42563102438f39202d638278d45ee9
+  metadata.gz: c677b1f2b2cdf150a4e8e9a817cd7a9a6e46680a353c3125aeb7ab65e1b85348
+  data.tar.gz: 72a25a13491d9349a813484be40c43cacc767355060ba16375da7b7f41739249
 SHA512:
-  metadata.gz: a13fa4357d31fed2106ebcef94ff51decb7003e30a1f0a2fe5af83ceb3d18cc7d909fcf1c6f65ea63c7c11eccb1e312d7c85ff66d16125d50bd10b1e1772ab14
-  data.tar.gz: 7f2a2951c337e2326ad0c808423f6017b11086538a8bcd0b40078729e26b02232f7b97c39de96ab70e81c5eac5382ce7f0aff9965e4fbd36571b4b89bcdcbcab
+  metadata.gz: 1b6bdeeb8ca02a6027a79fc0d896716603792c1d4cee95131995ef944075f13b983a583a22eb4e3b6b590b8430b7b4eb4469522cf76b47daa30b8c2dd35a7318
+  data.tar.gz: eca4f269833a0823442f247cb065f14fe412c85063e5df8e751a20a366fd296f02db3ad2720b02d7a4169c73b38c1bbfe29160f292671a8a5cf0a23b4ffa9261

data/README.rdoc

@@ -128,6 +128,23 @@ reconfigured on the model, and then can be used during querying process.
 
   {Learn more}[link:classes/Torque/PostgreSQL/AuxiliaryStatement.html]
 
+* Multiple Schemas
+
+Allows models and modules to have a schema associated with them, so that
+developers can better organize their tables into schemas and build features in
+a way that the database can better represent how they are separated.
+
+   create_schema "internal", force: :cascade
+
+   module Internal
+     class User < ActiveRecord::Base
+       self.schema = 'internal'
+     end
+   end
+
+   Internal::User.all
+
+  {Learn more}[link:classes/Torque/PostgreSQL/Adapter/DatabaseStatements.html]
 
 == Download and installation
 

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

@@ -12,6 +12,26 @@ module Torque
           @_dump_mode = !!!@_dump_mode
         end
 
+        # List of schemas blocked by the application in the current connection
+        def schemas_blacklist
+          @schemas_blacklist ||= Torque::PostgreSQL.config.schemas.blacklist +
+            (@config.dig(:schemas, 'blacklist') || [])
+        end
+
+        # List of schemas used by the application in the current connection
+        def schemas_whitelist
+          @schemas_whitelist ||= Torque::PostgreSQL.config.schemas.whitelist +
+            (@config.dig(:schemas, 'whitelist') || [])
+        end
+
+        # A list of schemas on the search path sanitized
+        def schemas_search_path_sanitized
+          @schemas_search_path_sanitized ||= begin
+            db_user = @config[:username] || ENV['USER'] || ENV['USERNAME']
+            schema_search_path.split(',').map { |item| item.strip.sub('"$user"', db_user) }
+          end
+        end
+
         # Check if a given type is valid.
         def valid_type?(type)
           super || extended_types.include?(type)
@@ -22,6 +42,17 @@ module Torque
           EXTENDED_DATABASE_TYPES
         end
 
+        # Checks if a given schema exists in the database. If +filtered+ is
+        # given as false, then it will check regardless of whitelist and
+        # blacklist
+        def schema_exists?(name, filtered: true)
+          return user_defined_schemas.include?(name.to_s) if filtered
+
+          query_value(<<-SQL) == 1
+            SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = '#{name}'
+          SQL
+        end
+
         # Returns true if type exists.
         def type_exists?(name)
           user_defined_types.key? name.to_s
@@ -124,18 +155,41 @@ module Torque
         # Get the list of inherited tables associated with their parent tables
         def inherited_tables
           tables = query(<<-SQL, 'SCHEMA')
-            SELECT child.relname             AS table_name,
-                   array_agg(parent.relname) AS inheritances
+            SELECT inhrelid::regclass  AS table_name,
+                   inhparent::regclass 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
+            ORDER BY inhrelid
           SQL
 
-          tables.map do |(table, refs)|
-            [table, PG::TextDecoder::Array.new.decode(refs)]
-          end.to_h
+          tables.each_with_object({}) do |(child, parent), result|
+            (result[child] ||= []) << parent
+          end
+        end
+
+        # Get the list of schemas that were created by the user
+        def user_defined_schemas
+          query_values(user_defined_schemas_sql, 'SCHEMA')
+        end
+
+        # Build the query for allowed schemas
+        def user_defined_schemas_sql
+          conditions = []
+          conditions << <<-SQL if schemas_blacklist.any?
+            nspname NOT LIKE ANY (ARRAY['#{schemas_blacklist.join("', '")}'])
+          SQL
+
+          conditions << <<-SQL if schemas_whitelist.any?
+            nspname LIKE ANY (ARRAY['#{schemas_whitelist.join("', '")}'])
+          SQL
+
+          <<-SQL.squish
+            SELECT nspname
+            FROM pg_catalog.pg_namespace
+            WHERE 1=1 AND #{conditions.join(' AND ')}
+            ORDER BY oid
+          SQL
         end
 
         # Get the list of columns, and their definition, but only from the

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

@@ -13,21 +13,15 @@ module Torque
           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)
+            statements.concat(o.indexes.map { |c, o| index_in_create(o.name, c, o) })
           end
 
           if supports_foreign_keys?
-            statements.concat(o.foreign_keys.map do |to_table, options|
-              foreign_key_in_create(o.name, to_table, options)
-            end)
+            statements.concat(o.foreign_keys.map { |fk| accept fk })
           end
 
           if respond_to?(:supports_check_constraints?) && supports_check_constraints?
-            statements.concat(o.check_constraints.map do |expression, options|
-              check_constraint_in_create(o.name, expression, options)
-            end)
+            statements.concat(o.check_constraints.map { |chk| accept chk })
           end
 
           create_sql << "(#{statements.join(', ')})" \

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

@@ -12,6 +12,11 @@ module Torque
           stream
         end
 
+        def extensions(stream) # :nodoc:
+          super
+          user_defined_schemas(stream)
+        end
+
         # Translate +:enum_set+ into +:enum+
         def schema_type(column)
           column.type == :enum_set ? :enum : super
@@ -20,8 +25,23 @@ module Torque
         private
 
           def tables(stream) # :nodoc:
+            around_tables(stream) { dump_tables(stream) }
+          end
+
+          def around_tables(stream)
+            functions(stream) if fx_functions_position == :beginning
+
+            yield
+
+            functions(stream) if fx_functions_position == :end
+            triggers(stream) if defined?(::Fx::SchemaDumper::Trigger)
+          end
+
+          def dump_tables(stream)
             inherited_tables = @connection.inherited_tables
-            sorted_tables = @connection.tables.sort - @connection.views
+            sorted_tables = (@connection.tables - @connection.views).sort_by do |table_name|
+              table_name.split(/(?:public)?\./).reverse
+            end
 
             stream.puts "  # These are the common tables"
             (sorted_tables - inherited_tables.keys).each do |table_name|
@@ -38,7 +58,7 @@ module Torque
 
                 # Add the inherits setting
                 sub_stream.rewind
-                inherits.map!(&:to_sym)
+                inherits.map! { |parent| parent.to_s.sub(/\Apublic\./, '') }
                 inherits = inherits.first if inherits.size === 1
                 inherits = ", inherits: #{inherits.inspect} do |t|"
                 table_dump = sub_stream.read.gsub(/ do \|t\|$/, inherits)
@@ -55,13 +75,25 @@ module Torque
                 foreign_keys(tbl, stream) unless ignored?(tbl)
               end
             end
+          end
+
+          # Make sure to remove the schema from the table name
+          def remove_prefix_and_suffix(table)
+            super(table.sub(/\A[a-z0-9_]*\./, ''))
+          end
 
-            # Scenic integration
-            views(stream) if defined?(::Scenic)
+          # Dump user defined schemas
+          def user_defined_schemas(stream)
+            return if (list = (@connection.user_defined_schemas - ['public'])).empty?
 
-            # FX integration
-            functions(stream) if defined?(::Fx::SchemaDumper::Function)
-            triggers(stream) if defined?(::Fx::SchemaDumper::Trigger)
+            stream.puts "  # Custom schemas defined in this database."
+            list.each { |name| stream.puts "  create_schema \"#{name}\", force: :cascade" }
+            stream.puts
+          end
+
+          def fx_functions_position
+            return unless defined?(::Fx::SchemaDumper::Function)
+            Fx.configuration.dump_functions_at_beginning_of_schema ? :beginning : :end
           end
       end
 

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

@@ -7,6 +7,21 @@ module Torque
 
         TableDefinition = ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
 
+        # Create a new schema
+        def create_schema(name, options = {})
+          drop_schema(name, options) if options[:force]
+
+          check = 'IF NOT EXISTS' if options.fetch(:check, true)
+          execute("CREATE SCHEMA #{check} #{quote_schema_name(name.to_s)}")
+        end
+
+        # Drop an existing schema
+        def drop_schema(name, options = {})
+          force = options.fetch(:force, '').upcase
+          check = 'IF EXISTS' if options.fetch(:check, true)
+          execute("DROP SCHEMA #{check} #{quote_schema_name(name.to_s)} #{force}")
+        end
+
         # Drops a type.
         def drop_type(name, options = {})
           force = options.fetch(:force, '').upcase
@@ -64,12 +79,37 @@ module Torque
 
         # Rewrite the method that creates tables to easily accept extra options
         def create_table(table_name, **options, &block)
+          table_name = "#{options[:schema]}.#{table_name}" if options[:schema].present?
+
           options[:id] = false if options[:inherits].present? &&
             options[:primary_key].blank? && options[:id].blank?
 
           super table_name, **options, &block
         end
 
+        # Add the schema option when extracting table options
+        def table_options(table_name)
+          parts = table_name.split('.').reverse
+          return super unless parts.size == 2 && parts[1] != 'public'
+
+          (super || {}).merge(schema: parts[1])
+        end
+
+        # When dumping the schema we need to add all schemas, not only those
+        # active for the current +schema_search_path+
+        def quoted_scope(name = nil, type: nil)
+          return super unless name.nil?
+
+          super.merge(schema: "ANY ('{#{user_defined_schemas.join(',')}}')")
+        end
+
+        # Fix the query to include the schema on tables names when dumping
+        def data_source_sql(name = nil, type: nil)
+          return super unless name.nil?
+
+          super.sub('SELECT c.relname FROM', "SELECT n.nspname || '.' || c.relname FROM")
+        end
+
         private
 
           def quote_enum_values(name, values, options)

data/lib/torque/postgresql/adapter.rb

@@ -31,9 +31,9 @@ module Torque
         )
       end
 
-      # Add `inherits` to the list of extracted table options
+      # Add `inherits` and `schema` to the list of extracted table options
       def extract_table_options!(options)
-        super.merge(options.extract!(:inherits))
+        super.merge(options.extract!(:inherits, :schema))
       end
 
       # Allow filtered bulk insert by adding the where clause. This method is

data/lib/torque/postgresql/associations/preloader/loader_query.rb

@@ -6,7 +6,7 @@ module Torque
       module Preloader
         module LoaderQuery
           def foreign_column
-            @foreign_column ||= scope.columns_hash[association_key_name]
+            @foreign_column ||= scope.columns_hash[association_key_name.to_s]
           end
 
           def load_records_for_keys(keys, &block)

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    class AuxiliaryStatement
+      class Recursive < AuxiliaryStatement
+        # Setup any additional option in the recursive mode
+        def initialize(*, **options)
+          super
+
+          @connect = options[:connect]&.to_a&.first
+          @union_all = options[:union_all]
+          @sub_query = options[:sub_query]
+
+          if options.key?(:with_depth)
+            @depth = options[:with_depth].values_at(:name, :start, :as)
+            @depth[0] ||= 'depth'
+          end
+
+          if options.key?(:with_path)
+            @path = options[:with_path].values_at(:name, :source, :as)
+            @path[0] ||= 'path'
+          end
+        end
+
+        private
+
+          # Build the string or arel query
+          def build_query(base)
+            # Expose columns and get the list of the ones for select
+            columns = expose_columns(base, @query.try(:arel_table))
+            sub_columns = columns.dup
+            type = @union_all.present? ? 'all' : ''
+
+            # Build any extra columns that are dynamic and from the recursion
+            extra_columns(base, columns, sub_columns)
+
+            # Prepare the query depending on its type
+            if @query.is_a?(String) && @sub_query.is_a?(String)
+              args = @args.each_with_object({}) { |h, (k, v)| h[k] = base.connection.quote(v) }
+              ::Arel.sql("(#{@query} UNION #{type.upcase} #{@sub_query})" % args)
+            elsif relation_query?(@query)
+              @query = @query.where(@where) if @where.present?
+              @bound_attributes.concat(@query.send(:bound_attributes))
+
+              if relation_query?(@sub_query)
+                @bound_attributes.concat(@sub_query.send(:bound_attributes))
+
+                sub_query = @sub_query.select(*sub_columns).arel
+                sub_query.from([@sub_query.arel_table, table])
+              else
+                sub_query = ::Arel.sql(@sub_query)
+              end
+
+              @query.select(*columns).arel.union(type, sub_query)
+            else
+              raise ArgumentError, <<-MSG.squish
+                Only String and ActiveRecord::Base objects are accepted as query and sub query
+                objects, #{@query.class.name} given for #{self.class.name}.
+              MSG
+            end
+          end
+
+          # Setup the statement using the class configuration
+          def prepare(base, settings)
+            super
+
+            prepare_sub_query(base, settings)
+          end
+
+          # Make sure that both parts of the union are ready
+          def prepare_sub_query(base, settings)
+            @union_all = settings.union_all if @union_all.nil?
+            @sub_query ||= settings.sub_query
+            @depth ||= settings.depth
+            @path ||= settings.path
+
+            # Collect the connection
+            @connect ||= settings.connect || begin
+              key = base.primary_key
+              [key.to_sym, :"parent_#{key}"] unless key.nil?
+            end
+
+            raise ArgumentError, <<-MSG.squish if @sub_query.nil? && @query.is_a?(String)
+              Unable to generate sub query from a string query. Please provide a `sub_query`
+              property on the "#{table_name}" settings.
+            MSG
+
+            if @sub_query.nil?
+              raise ArgumentError, <<-MSG.squish if @connect.blank?
+                Unable to generate sub query without setting up a proper way to connect it
+                with the main query. Please provide a `connect` property on the "#{table_name}"
+                settings.
+              MSG
+
+              left, right = @connect.map(&:to_s)
+              condition = @query.arel_table[right].eq(table[left])
+
+              if @query.where_values_hash.key?(right)
+                @sub_query = @query.unscope(where: right.to_sym).where(condition)
+              else
+                @sub_query = @query.where(condition)
+                @query = @query.where(right => nil)
+              end
+            elsif @sub_query.respond_to?(:call)
+              # Call a proc to get the real sub query
+              call_args = @sub_query.try(:arity) === 0 ? [] : [OpenStruct.new(@args)]
+              @sub_query = @sub_query.call(*call_args)
+            end
+          end
+
+          # Add depth and path if they were defined in settings
+          def extra_columns(base, columns, sub_columns)
+            return if @query.is_a?(String) || @sub_query.is_a?(String)
+
+            # Add the connect attribute to the query
+            if defined?(@connect)
+              columns.unshift(@query.arel_table[@connect[0]])
+              sub_columns.unshift(@sub_query.arel_table[@connect[0]])
+            end
+
+            # Build a column to represent the depth of the recursion
+            if @depth.present?
+              name, start, as = @depth
+              col = table[name]
+              base.select_extra_values += [col.as(as)] unless as.nil?
+
+              columns << ::Arel.sql(start.to_s).as(name)
+              sub_columns << (col + ::Arel.sql('1')).as(name)
+            end
+
+            # Build a column to represent the path of the record access
+            if @path.present?
+              name, source, as = @path
+              source = @query.arel_table[source || @connect[0]]
+
+              col = table[name]
+              base.select_extra_values += [col.as(as)] unless as.nil?
+              parts = [col, source.cast(:varchar)]
+
+              columns << ::Arel.array([source]).cast(:varchar, true).as(name)
+              sub_columns << ::Arel::Nodes::NamedFunction.new('array_append', parts).as(name)
+            end
+          end
+
+      end
+    end
+  end
+end

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

@@ -4,9 +4,9 @@ module Torque
   module PostgreSQL
     class AuxiliaryStatement
       class Settings < Collector.new(:attributes, :join, :join_type, :query, :requires,
-          :polymorphic, :through)
+          :polymorphic, :through, :union_all, :connect)
 
-        attr_reader :base, :source
+        attr_reader :base, :source, :depth, :path
         alias_method :select, :attributes
         alias_method :cte, :source
 
@@ -14,9 +14,10 @@ module Torque
         delegate :table, :table_name, to: :@source
         delegate :sql, to: ::Arel
 
-        def initialize(base, source)
+        def initialize(base, source, recursive = false)
           @base = base
           @source = source
+          @recursive = recursive
         end
 
         def base_name
@@ -27,6 +28,38 @@ module Torque
           @base.arel_table
         end
 
+        def recursive?
+          @recursive
+        end
+
+        def depth?
+          defined?(@depth)
+        end
+
+        def path?
+          defined?(@path)
+        end
+
+        # Add an attribute to the result showing the depth of each iteration
+        def with_depth(name = 'depth', start: 0, as: nil)
+          @depth = [name.to_s, start, as&.to_s] if recursive?
+        end
+
+        # Add an attribute to the result showing the path of each record
+        def with_path(name = 'path', source: nil, as: nil)
+          @path = [name.to_s, source&.to_s, as&.to_s] if recursive?
+        end
+
+        # Set recursive operation to use union all
+        def union_all!
+          @union_all = true if recursive?
+        end
+
+        # Add both depth and path to the result
+        def with_depth_and_path
+          with_depth && with_path
+        end
+
         # Get the arel version of the table set on the query
         def query_table
           raise StandardError, 'The query is not defined yet' if query.nil?
@@ -41,36 +74,55 @@ module Torque
 
         alias column col
 
-        # There are two ways of setting the query:
+        # There are three 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
+        # - A string or a proc
         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
+          @query = sanitize_query(value, command)
+        end
 
-          valid_type = command.respond_to?(:call) || command.is_a?(String)
+        # Same as query, but for the second part of the union for recursive cte
+        def sub_query(value = nil, command = nil)
+          return unless recursive?
+          return @sub_query if value.nil?
 
-          raise ArgumentError, <<-MSG.squish if command.nil?
-            To use proc or string as query, you need to provide the table name
-            as the first argument
-          MSG
+          @sub_query = sanitize_query(value, command)
+        end
+
+        # Assume `parent_` as the other part if provided a Symbol or String
+        def connect(value = nil)
+          return @connect if value.nil?
 
-          raise ArgumentError, <<-MSG.squish unless valid_type
-            Only relation, string and proc are valid object types for query,
-            #{command.inspect} given.
-          MSG
+          value = [value.to_sym, :"parent_#{value}"] \
+            if value.is_a?(String) || value.is_a?(Symbol)
+          value = value.to_a.first if value.is_a?(Hash)
 
-          @query = command
-          @query_table = ::Arel::Table.new(value)
+          @connect = value
         end
 
+        alias connect= connect
+
+        private
+
+          # Get the query and table from the params
+          def sanitize_query(value, command = nil)
+            return value if relation_query?(value)
+            return value if value.is_a?(::Arel::SelectManager)
+
+            command = value if command.nil? # For compatibility purposes
+            valid_type = command.respond_to?(:call) || command.is_a?(String)
+
+            raise ArgumentError, <<-MSG.squish unless valid_type
+              Only relation, string and proc are valid object types for query,
+              #{command.inspect} given.
+            MSG
+
+            command
+          end
+
       end
     end
   end