scenic-jets 1.5.4

data/lib/scenic/adapters/postgres/refresh_dependencies.rb

@@ -0,0 +1,116 @@
+module Scenic
+  module Adapters
+    class Postgres
+      class RefreshDependencies
+        def self.call(name, adapter, connection, concurrently: false)
+          new(name, adapter, connection, concurrently: concurrently).call
+        end
+
+        def initialize(name, adapter, connection, concurrently:)
+          @name = name
+          @adapter = adapter
+          @connection = connection
+          @concurrently = concurrently
+        end
+
+        def call
+          dependencies.each do |dependency|
+            adapter.refresh_materialized_view(
+              dependency,
+              concurrently: concurrently,
+            )
+          end
+        end
+
+        private
+
+        attr_reader :name, :adapter, :connection, :concurrently
+
+        class DependencyParser
+          def initialize(raw_dependencies, view_to_refresh)
+            @raw_dependencies = raw_dependencies
+            @view_to_refresh = view_to_refresh
+          end
+
+          # We're given an array from the SQL query that looks kind of like this
+          # [["view_name", "{'dependency_1', 'dependency_2'}"]]
+          #
+          # We need to parse that into a more easy to understand data type so we
+          # can use the Tsort module from the Standard Library to topologically
+          # sort those out so we can refresh in the correct order, so we parse
+          # that raw data into a hash.
+          #
+          # Then, once Tsort has worked it magic, we're given a sorted 1-D array
+          # ["dependency_1", "dependency_2", "view_name"]
+          #
+          # So we then need to slice off just the bit leading up to the view
+          # that we're refreshing, so we find where in the topologically sorted
+          # array our given view is, and return all the dependencies up to that
+          # point.
+          def to_sorted_array
+            dependency_hash = parse_to_hash(raw_dependencies)
+            sorted_arr = tsort(dependency_hash)
+
+            idx = sorted_arr.find_index do |dep|
+              if view_to_refresh.to_s.include?(".")
+                dep == view_to_refresh.to_s
+              else
+                dep.ends_with?(".#{view_to_refresh}")
+              end
+            end
+
+            if idx.present?
+              sorted_arr[0...idx]
+            else
+              []
+            end
+          end
+
+          private
+
+          attr_reader :raw_dependencies, :view_to_refresh
+
+          def parse_to_hash(dependency_rows)
+            dependency_rows.each_with_object({}) do |row, hash|
+              formatted_dependencies = row.last.tr("{}", "").split(",")
+              formatted_dependencies.each do |dependency|
+                hash[dependency] = [] unless hash[dependency]
+              end
+              hash[row.first] = formatted_dependencies
+            end
+          end
+
+          def tsort(hash)
+            each_node = lambda { |&b| hash.each_key(&b) }
+            each_child = lambda { |n, &b| hash[n].each(&b) }
+            TSort.tsort(each_node, each_child)
+          end
+        end
+
+        DEPENDENCY_SQL = <<-SQL.freeze
+          SELECT rewrite_namespace.nspname || '.' || class_for_rewrite.relname AS materialized_view,
+          array_agg(depend_namespace.nspname || '.' || class_for_depend.relname) AS depends_on
+          FROM pg_rewrite AS rewrite
+          JOIN pg_class AS class_for_rewrite ON rewrite.ev_class = class_for_rewrite.oid
+          JOIN pg_depend AS depend ON rewrite.oid = depend.objid
+          JOIN pg_class AS class_for_depend ON depend.refobjid = class_for_depend.oid
+          JOIN pg_namespace AS rewrite_namespace ON rewrite_namespace.oid = class_for_rewrite.relnamespace
+          JOIN pg_namespace AS depend_namespace ON depend_namespace.oid = class_for_depend.relnamespace
+          WHERE class_for_depend.relkind = 'm'
+          AND class_for_rewrite.relkind = 'm'
+          AND class_for_depend.relname != class_for_rewrite.relname
+          GROUP BY class_for_rewrite.relname, rewrite_namespace.nspname
+          ORDER BY class_for_rewrite.relname;
+        SQL
+
+        private_constant "DependencyParser"
+        private_constant "DEPENDENCY_SQL"
+
+        def dependencies
+          raw_dependency_info = connection.select_rows(DEPENDENCY_SQL)
+          DependencyParser.new(raw_dependency_info, name).to_sorted_array
+        end
+      end
+    end
+  end
+end

data/lib/scenic/adapters/postgres/views.rb

@@ -0,0 +1,74 @@
+module Scenic
+  module Adapters
+    class Postgres
+      # Fetches defined views from the postgres connection.
+      # @api private
+      class Views
+        def initialize(connection)
+          @connection = connection
+        end
+
+        # All of the views that this connection has defined.
+        #
+        # This will include materialized views if those are supported by the
+        # connection.
+        #
+        # @return [Array<Scenic::View>]
+        def all
+          views_from_postgres.map(&method(:to_scenic_view))
+        end
+
+        private
+
+        attr_reader :connection
+
+        def views_from_postgres
+          connection.execute(<<-SQL)
+            SELECT
+              c.relname as viewname,
+              pg_get_viewdef(c.oid) AS definition,
+              c.relkind AS kind,
+              n.nspname AS namespace
+            FROM pg_class c
+              LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE
+              c.relkind IN ('m', 'v')
+              AND c.relname NOT IN (SELECT extname FROM pg_extension)
+              AND n.nspname = ANY (current_schemas(false))
+            ORDER BY c.oid
+          SQL
+        end
+
+        def to_scenic_view(result)
+          namespace, viewname = result.values_at "namespace", "viewname"
+
+          if namespace != "public"
+            namespaced_viewname = "#{pg_identifier(namespace)}.#{pg_identifier(viewname)}"
+          else
+            namespaced_viewname = pg_identifier(viewname)
+          end
+
+          Scenic::View.new(
+            name: namespaced_viewname,
+            definition: result["definition"].strip,
+            materialized: result["kind"] == "m",
+          )
+        end
+
+        def pg_identifier(name)
+          return name if name =~ /^[a-zA-Z_][a-zA-Z0-9_]*$/
+
+          pgconn.quote_ident(name)
+        end
+
+        def pgconn
+          if defined?(PG::Connection)
+            PG::Connection
+          else
+            PGconn
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scenic/command_recorder.rb

@@ -0,0 +1,52 @@
+require "scenic/command_recorder/statement_arguments"
+
+module Scenic
+  # @api private
+  module CommandRecorder
+    def create_view(*args)
+      record(:create_view, args)
+    end
+
+    def drop_view(*args)
+      record(:drop_view, args)
+    end
+
+    def update_view(*args)
+      record(:update_view, args)
+    end
+
+    def replace_view(*args)
+      record(:replace_view, args)
+    end
+
+    def invert_create_view(args)
+      drop_view_args = StatementArguments.new(args).remove_version.to_a
+      [:drop_view, drop_view_args]
+    end
+
+    def invert_drop_view(args)
+      perform_scenic_inversion(:create_view, args)
+    end
+
+    def invert_update_view(args)
+      perform_scenic_inversion(:update_view, args)
+    end
+
+    def invert_replace_view(args)
+      perform_scenic_inversion(:replace_view, args)
+    end
+
+    private
+
+    def perform_scenic_inversion(method, args)
+      scenic_args = StatementArguments.new(args)
+
+      if scenic_args.revert_to_version.nil?
+        message = "#{method} is reversible only if given a revert_to_version"
+        raise ActiveRecord::IrreversibleMigration, message
+      end
+
+      [method, scenic_args.invert_version.to_a]
+    end
+  end
+end

data/lib/scenic/command_recorder/statement_arguments.rb

@@ -0,0 +1,51 @@
+module Scenic
+  module CommandRecorder
+    # @api private
+    class StatementArguments
+      def initialize(args)
+        @args = args.freeze
+      end
+
+      def view
+        @args[0]
+      end
+
+      def version
+        options[:version]
+      end
+
+      def revert_to_version
+        options[:revert_to_version]
+      end
+
+      def invert_version
+        StatementArguments.new([view, options_for_revert])
+      end
+
+      def remove_version
+        StatementArguments.new([view, options_without_version])
+      end
+
+      def to_a
+        @args.to_a.dup.delete_if(&:empty?)
+      end
+
+      private
+
+      def options
+        @options ||= @args[1] || {}
+      end
+
+      def options_for_revert
+        options.clone.tap do |revert_options|
+          revert_options[:version] = revert_to_version
+          revert_options.delete(:revert_to_version)
+        end
+      end
+
+      def options_without_version
+        options.except(:version)
+      end
+    end
+  end
+end

data/lib/scenic/configuration.rb

@@ -0,0 +1,37 @@
+module Scenic
+  class Configuration
+    # The Scenic database adapter instance to use when executing SQL.
+    #
+    # Defaults to an instance of {Adapters::Postgres}
+    # @return Scenic adapter
+    attr_accessor :database
+
+    def initialize
+      @database = Scenic::Adapters::Postgres.new
+    end
+  end
+
+  # @return [Scenic::Configuration] Scenic's current configuration
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Set Scenic's configuration
+  #
+  # @param config [Scenic::Configuration]
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  # Modify Scenic's current configuration
+  #
+  # @yieldparam [Scenic::Configuration] config current Scenic config
+  # ```
+  # Scenic.configure do |config|
+  #   config.database = Scenic::Adapters::Postgres.new
+  # end
+  # ```
+  def self.configure
+    yield configuration
+  end
+end

data/lib/scenic/definition.rb

@@ -0,0 +1,35 @@
+module Scenic
+  # @api private
+  class Definition
+    def initialize(name, version)
+      @name = name
+      @version = version.to_i
+    end
+
+    def to_sql
+      File.read(full_path).tap do |content|
+        if content.empty?
+          raise "Define view query in #{path} before migrating."
+        end
+      end
+    end
+
+    def full_path
+      Jets.root.join(path)
+    end
+
+    def path
+      File.join("db", "views", filename)
+    end
+
+    def version
+      @version.to_s.rjust(2, "0")
+    end
+
+    private
+
+    def filename
+      "#{@name.to_s.tr('.', '_')}_v#{version}.sql"
+    end
+  end
+end

data/lib/scenic/index.rb

@@ -0,0 +1,36 @@
+module Scenic
+  # The in-memory representation of a database index.
+  #
+  # **This object is used internally by adapters and the schema dumper and is
+  # not intended to be used by application code. It is documented here for
+  # use by adapter gems.**
+  #
+  # @api extension
+  class Index
+    # The name of the object that has the index
+    # @return [String]
+    attr_reader :object_name
+
+    # The name of the index
+    # @return [String]
+    attr_reader :index_name
+
+    # The SQL statement that defines the index
+    # @return [String]
+    #
+    # @example
+    #   "CREATE INDEX index_users_on_email ON users USING btree (email)"
+    attr_reader :definition
+
+    # Returns a new instance of Index
+    #
+    # @param object_name [String] The name of the object that has the index
+    # @param index_name [String] The name of the index
+    # @param definition [String] The SQL statements that defined the index
+    def initialize(object_name:, index_name:, definition:)
+      @object_name = object_name
+      @index_name = index_name
+      @definition = definition
+    end
+  end
+end

data/lib/scenic/schema_dumper.rb

@@ -0,0 +1,44 @@
+require "rails"
+
+module Scenic
+  # @api private
+  module SchemaDumper
+    def tables(stream)
+      super
+      views(stream)
+    end
+
+    def views(stream)
+      if dumpable_views_in_database.any?
+        stream.puts
+      end
+
+      dumpable_views_in_database.each do |view|
+        stream.puts(view.to_schema)
+        indexes(view.name, stream)
+      end
+    end
+
+    private
+
+    def dumpable_views_in_database
+      @dumpable_views_in_database ||= Scenic.database.views.reject do |view|
+        ignored?(view.name)
+      end
+    end
+
+    unless ActiveRecord::SchemaDumper.private_instance_methods(false).include?(:ignored?)
+      # This method will be present in Rails 4.2.0 and can be removed then.
+      def ignored?(table_name)
+        ["schema_migrations", ignore_tables].flatten.any? do |ignored|
+          case ignored
+          when String then remove_prefix_and_suffix(table_name) == ignored
+          when Regexp then remove_prefix_and_suffix(table_name) =~ ignored
+          else
+            raise StandardError, "ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values."
+          end
+        end
+      end
+    end
+  end
+end