torque-postgresql 2.2.4 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95fa82a4869d180b12518b184191e6877b9e6cf3108fb5e68e55d6a836809389
-  data.tar.gz: 45c6e24a30b3782ec26ff5caafe01430c24f137c460eb19b6f2a49e0b6609142
+  metadata.gz: 51c2e056f8b1a5bfa52339dbc7212a03fdd7f99f7fa05b11d066859ef1763f45
+  data.tar.gz: 6b0cdc4ac793d578cc925363f331f167c80a73a1d708f68c98b2d8430b21331f
 SHA512:
-  metadata.gz: cd7e925ab13b8ae3eb6f0d92fbb994f12c6c121998792263b0752eb9647c0d2e4f72dec8d3973c6e0365fe0c5194a2af5fba9189189743c5bca7b06a4e6dfa41
-  data.tar.gz: 470bb4e8b0816318ca5ee1b99e1896a8a4f3297af46e653de4ddac5347cf40a781b530a4e2531cf41eae38f7205332e52ced09e5b857a618f965851a6d9d7162
+  metadata.gz: fd702676e2677393a1002c411380cb297f7f56b7f2bdad7317a446849accf3090b9dcd27d6b2e50b7e7c81d6299db97f3fbd190a6c21d6afca9782c575e900ba
+  data.tar.gz: 74cbc3c504fad7ebd55249ed4339c7a2571320828faebe7a2f573b759e721febd07e05c5227759748dbde4c0e629521d167d149e65339cd3a0be855f60076b29

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
@@ -115,18 +146,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_dumper.rb

@@ -14,6 +14,7 @@ module Torque
 
         def extensions(stream) # :nodoc:
           super
+          user_defined_schemas(stream)
           user_defined_types(stream)
         end
 
@@ -41,7 +42,9 @@ module Torque
 
           def tables(stream) # :nodoc:
             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|
@@ -58,7 +61,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)
@@ -84,6 +87,20 @@ module Torque
             triggers(stream) if defined?(::Fx::SchemaDumper::Trigger)
           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
+
+          # Dump user defined schemas
+          def user_defined_schemas(stream)
+            return if (list = (@connection.user_defined_schemas - ['public'])).empty?
+
+            stream.puts "  # Custom schemas defined in this database."
+            list.each { |name| stream.puts "  create_schema \"#{name}\", force: :cascade" }
+            stream.puts
+          end
+
           # Dump user defined types like enum
           def user_defined_types(stream)
             types = @connection.user_defined_types('e')

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
@@ -79,12 +94,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/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,39 @@ 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 +75,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