RubyGems - activerecord-view - Versions diffs - 0.1.0 - Mend

activerecord-view 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

checksums.yaml +7 -0
data/.gitignore +11 -0
data/.rspec +3 -0
data/.travis.yml +11 -0
data/CODE_OF_CONDUCT.md +15 -0
data/Gemfile +4 -0
data/LICENSE.txt +21 -0
data/README.md +139 -0
data/Rakefile +12 -0
data/activerecord-view.gemspec +36 -0
data/bin/console +18 -0
data/bin/setup +10 -0
data/lib/activerecord-view.rb +1 -0
data/lib/activerecord/view.rb +28 -0
data/lib/activerecord/view/error.rb +19 -0
data/lib/activerecord/view/integration.rb +38 -0
data/lib/activerecord/view/integration/command_recorder_methods.rb +61 -0
data/lib/activerecord/view/integration/model_methods.rb +27 -0
data/lib/activerecord/view/integration/schema_methods.rb +178 -0
data/lib/activerecord/view/introspection.rb +100 -0
data/lib/activerecord/view/introspection/abstract.rb +106 -0
data/lib/activerecord/view/introspection/mysql.rb +29 -0
data/lib/activerecord/view/introspection/postgres.rb +47 -0
data/lib/activerecord/view/introspection/sqlite3.rb +38 -0
data/lib/activerecord/view/introspection/view_definition.rb +18 -0
data/lib/activerecord/view/materialized_view_methods.rb +19 -0
data/lib/activerecord/view/read_only.rb +39 -0
data/lib/activerecord/view/schema.rb +10 -0
data/lib/activerecord/view/utility.rb +12 -0
data/lib/activerecord/view/version.rb +5 -0
data/lib/activerecord/view/view_methods.rb +17 -0
metadata +262 -0

data/lib/activerecord/view/integration/model_methods.rb ADDED

@@ -0,0 +1,27 @@
+module ActiveRecord
+  module View
+    module Integration
+      module ModelMethods
+        # @return [void]
+        def is_view!(readonly: true, **kwargs)
+          include ActiveRecord::View::ViewMethods
+          include ActiveRecord::View::ReadOnly if readonly
+        end
+        def is_materialized_view!(**kwargs)
+          is_view!(**kwargs)
+          include ActiveRecord::View::MaterializedViewMethods
+        end
+        def materialized_view?
+          self < ActiveRecord::View::MaterializedViewMethods
+        end
+        def view?
+          self < ActiveRecord::View::ViewMethods
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/view/integration/schema_methods.rb ADDED

@@ -0,0 +1,178 @@
+module ActiveRecord
+  module View
+    module Integration
+      module SchemaMethods
+        extend ActiveSupport::Concern
+        extend ActiveRecord::View::Utility
+        CREATE_VIEW_FMT = cleanup <<-SQL
+        CREATE%<or_replace>s VIEW %<name>s AS %<body>s
+        SQL
+        DROP_VIEW_FMT = cleanup <<-SQL
+        DROP VIEW%<if_exists>s %<name>s%<restriction>s
+        SQL
+        CREATE_MATERIALIZED_VIEW_FMT = cleanup <<-SQL
+        CREATE%<or_replace>s MATERIALIZED VIEW %<name>s AS %<body>s %<with_data>s
+        SQL
+        DROP_MATERIALIZED_VIEW_FMT = cleanup <<-SQL
+        DROP MATERIALIZED VIEW%<if_exists>s %<name>s%<restriction>s
+        SQL
+        MATERIALIZED_VIEW_ADAPTERS = %w[PostgreSQL PostGIS]
+        # Create a SQL view.
+        #
+        # @param (see #build_create_view_query)
+        # @return [void]
+        def create_view(name, body = nil, force: false, **kwargs, &block)
+          kwargs[:sqlite3] = !!(adapter_name =~ /sqlite/i)
+          drop_view(name) if force && table_exists?(name)
+          execute build_create_view_query(name, body, **kwargs, &block)
+        end
+        # Drop a SQL view.
+        #
+        # @param (see #build_drop_view_query)
+        # @return [void]
+        def drop_view(name, **kwargs)
+          kwargs[:sqlite3] = !!(adapter_name =~ /sqlite/i)
+          execute build_drop_view_query(name, **kwargs)
+        end
+        # Create a materialized view.
+        #
+        # Only valid on Postgres.
+        #
+        # @param (see #build_create_materialized_view_query)
+        # @return [void]
+        def create_materialized_view(name, body = nil, force: false, **kwargs, &block)
+          supports_materialized_view!
+          drop_materialized_view(name) if force && table_exists?(name)
+          execute build_create_materialized_view_query(name, body, **kwargs, &block)
+        end
+        # Drop a materialized view.
+        #
+        # Only valid on Postgres.
+        #
+        # @param (see #build_drop_materialized_view_query)
+        # @return [void]
+        def drop_materialized_view(name, **kwargs)
+          supports_materialized_view!
+          execute build_drop_materialized_view_query(name, **kwargs)
+        end
+        protected
+        # @raise [ActiveRecord::View::MaterializedViewNotSupported] if unsupported
+        # @return [void]
+        def supports_materialized_view!
+          raise ActiveRecord::View::MaterializedViewNotSupported, adapter_name unless MATERIALIZED_VIEW_ADAPTERS.include?(adapter_name)
+        end
+        module_function
+        # @param [#to_s] name
+        # @param [String, #to_sql] body
+        # @param [Boolean] replace
+        # @param [Boolean] with_data Whether the materialized view should be automatically populated on create.
+        # @yieldreturn [String, #to_sql] alternatively the body can be provided in a block
+        # @return [String]
+        def build_create_materialized_view_query(name, body, force: nil, replace: false, with_data: false, &block)
+          options = {
+            or_replace: replace ? ' OR REPLACE' : '',
+            with_data:  with_data ? 'WITH DATA' : 'WITH NO DATA',
+            name:       quote_table_name(name)
+          }
+          options[:body] = fetch_view_body(body, &block)
+          sprintf CREATE_MATERIALIZED_VIEW_FMT, options
+        end
+        # @param [#to_s] name
+        # @param [String, #to_sql] body
+        # @param [Boolean] replace
+        # @param [Boolean] sqlite3 whether this should be built for SQLite3 (SQLite3 does not support `OR REPLACE` syntax)
+        # @yieldreturn [String, #to_sql] alternatively the body can be provided in a block
+        # @return [String]
+        def build_create_view_query(name, body, force: nil, replace: false, sqlite3: false, &block)
+          options = {
+            or_replace: replace ? ' OR REPLACE' : '',
+            name:       quote_table_name(name)
+          }
+          options[:or_replace] = unless sqlite3
+                                   replace ? ' OR REPLACE' : ''
+                                 else
+                                   raise ActiveRecord::View::UnsupportedSyntax, 'SQLite3 does not support `OR REPLACE` syntax' if replace
+                                   ''
+                                 end
+          options[:body] = fetch_view_body(body, &block)
+          sprintf CREATE_VIEW_FMT, options
+        end
+        # @return [String]
+        def build_drop_materialized_view_query(name, if_exists: false, force: false, **kwargs)
+          options = {
+            if_exists:  if_exists ? ' IF EXISTS' : '',
+            name:       quote_table_name(name)
+          }
+          options[:restriction] = force ? ' CASCADE' : ' RESTRICT'
+          sprintf DROP_MATERIALIZED_VIEW_FMT, options
+        end
+        # @return [String]
+        def build_drop_view_query(name, if_exists: false, force: false, sqlite3: false, **kwargs)
+          options = {
+            if_exists:  if_exists ? ' IF EXISTS' : '',
+            name:       quote_table_name(name)
+          }
+          options[:restriction] = unless sqlite3
+                                    force ? ' CASCADE' : ' RESTRICT'
+                                  else
+                                    ''
+                                  end
+          sprintf DROP_VIEW_FMT, options
+        end
+        # @api private
+        # @param [String, #to_sql, nil] body
+        # @yieldreturn [String, #to_sql] alternatively the body can be provided in a block
+        # @return [String]
+        def fetch_view_body(body, &block)
+          body ||= yield if block_given?
+          raise 'Must provide body to to create a view' if body.blank?
+          body &&= body.to_sql if body.respond_to? :to_sql
+          body
+        end
+        class << self
+          # @api private
+          # Stub method for tests.
+          # @param [String] name
+          # @return [String]
+          def quote_table_name(name)
+            %["#{name}"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/view/introspection.rb ADDED

@@ -0,0 +1,100 @@
+module ActiveRecord
+  module View
+    module Introspection
+      # @overload definition_for(name, connection:)
+      #   @param [String] name
+      #   @param [ActiveRecord::ConnectionAdapters::AbstractAdapter] connection
+      # @overload definition_for(model, connection: nil)
+      #   @param [#connection, ActiveRecord::View] model
+      #   @param [ActiveRecord::ConnectionAdapters::AbstractAdapter] connection
+      # @return [String]
+      def definition_for(model_or_name, connection: nil, raise_error: false)
+        view_name, connection = detect_view_and_connection(model_or_name, connection)
+        introspector = introspector_for(connection, raise_error: raise_error)
+        introspector.definition_for view_name
+      end
+      # @param [Class] connection
+      # @return [ActiveRecord::View::Introspection::Abstract]
+      def introspector_for(connection, raise_error: false)
+        connection = connection.connection if connection.respond_to?(:connection)
+        klass = case connection.adapter_name
+                when /mysql/i           then 'MySQL'
+                when /postg(res|gis)/i  then 'Postgres'
+                when /sqlite/i          then 'SQLite3'
+                else
+                  raise ActiveRecord::View::UnsupportedDatabase, "`#{connection.adapter_name}` is not a supported adapter"
+                end
+        "ActiveRecord::View::Introspection::#{klass}".constantize.new connection: connection, raise_error: raise_error
+      end
+      # @api private
+      # @param [Class, Arel::Table, String] model_or_name
+      # @param [ActiveRecord::ConnectionAdapters::AbstractAdapter, nil] connection
+      # @return [(String, ActiveRecord::ConnectionAdapters::AbstractAdapter)]
+      def detect_view_and_connection(model_or_name, connection)
+        view_name = case model_or_name
+                    when String, Symbol
+                      model_or_name.to_s
+                    when IS_MODEL
+                      model_or_name.table_name
+                    when Arel::Table
+                      model_or_name.name
+                    end
+        connection = coerce_connection(connection.presence || model_or_name)
+        raise Error, "Could not derive view name from provided: #{model_or_name.inspect}"   unless view_name.present?
+        raise Error, "Could not derive connection from provided: #{model_or_name.inspect}"  unless connection.present?
+        return [view_name, connection]
+      end
+      # @param [Class#connection, Arel::Table, ActiveRecord::ConnectionAdapters::AbstractAdapter]
+      # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+      def coerce_connection(connectible)
+        connection_coercer.coerce connectible
+      end
+      def connection_coercer
+        @_connection_coercer ||= Connectible.new Axiom::Types::Object, default_value: nil, coercer: nil
+      end
+      # @param [#to_sql, String] body
+      # @yieldreturn [#to_sql, String]
+      # @return [#to_sql, String]
+      def validate_body(body = nil, &block)
+        body if valid_body?(body, &block)
+      end
+      def valid_body?(body)
+        body.is_a?(String) || body.respond_to?(:to_sql) || block_given?
+      end
+      IS_MODEL = ->(klass) { klass.is_a?(Class) && ActiveRecord::Base > klass }
+      # @api private
+      class Connectible < Virtus::Attribute
+        def coerce(value)
+          case value
+          when ActiveRecord::ConnectionAdapters::AbstractAdapter then value
+          when Arel::Table      then value.engine.connection
+          when Dux[:connection] then value.connection
+          else
+            nil
+          end
+        end
+      end
+      require_relative './introspection/abstract'
+      require_relative './introspection/mysql'
+      require_relative './introspection/postgres'
+      require_relative './introspection/sqlite3'
+      require_relative './introspection/view_definition'
+    end
+  end
+end

data/lib/activerecord/view/introspection/abstract.rb ADDED

@@ -0,0 +1,106 @@
+module ActiveRecord
+  module View
+    module Introspection
+      # @abstract
+      # @api private
+      class Abstract
+        extend ActiveModel::Callbacks
+        include Virtus.model strict: true
+        define_model_callbacks :fetch_view_definition
+        delegate :adapter_name, :current_database, :select_value, :select_all, to: :connection
+        attribute :connection,  Connectible, default: :default_connection
+        attribute :raise_error, Boolean, default: false
+        # @abstract
+        # @return [<ActiveRecord::View::Introspection::ViewDefinition>]
+        def views
+        end
+        # @param [String] view_name
+        # @param [Hash] options
+        # @option options [Boolean] :pretty whether the SQL definition should be pretty-printed. Only works in postgres.
+        # @return [String]
+        def definition_for(view_name, **options)
+          run_callbacks :fetch_view_definition do
+            result = select_value fetch_view_definition_query(view_name, **options)
+            process_view_definition(result).tap do |processed|
+              raise ActiveRecord::View::Error, 'Empty Definition' if raise_error? && processed.blank?
+            end
+          end
+        end
+        # @return [Arel::SelectManager]
+        def select_manager
+          Arel::SelectManager.new self
+        end
+        # @param [String]
+        # @return [String]
+        def process_view_definition(result)
+          result
+        end
+        # @api private
+        # @abstract
+        # @param [String] view_name
+        # @return [Arel::SelectManager]
+        def fetch_view_definition_query(view_name, **options)
+          # :nocov:
+          raise NotImplementedError, "Must implement for #{self.class}"
+          # :nocov:
+        end
+        def inspect
+          # :nocov:
+          "<#{self.class.name}(:raise_error => #{raise_error?})>"
+          # :nocov:
+        end
+        # Build a SQL-compliant cast statement
+        #
+        # @param [String, Arel::Nodes::Quoted] value
+        # @param [String, Arel::Nodes::SqlLiteral] type
+        # @return [Arel::Nodes::NamedFunction("CAST", [Arel::Nodes::As(Arel::Nodes::Quoted, Arel::Nodes::SqlLiteral)])]
+        def arel_cast(value, type, quote_value: true, literalize_type: true)
+          value = arel_quoted(value)  if quote_value
+          type  = Arel.sql(type)      if literalize_type
+          as_expr = Arel::Nodes::As.new value, type
+          arel_fn 'CAST', as_expr
+        end
+        # Build an Arel function
+        #
+        # @return [Arel::Nodes::NamedFunction]
+        def arel_fn(name, *args)
+          Arel::Nodes::NamedFunction.new(name, args)
+        end
+        # Build a quoted string
+        #
+        # @return [Arel::Nodes::Quoted]
+        def arel_quoted(value)
+          arel_quoted?(value) ? value : Arel::Nodes.build_quoted(value)
+        end
+        def arel_quoted?(value)
+          value.kind_of? Arel::Nodes::Quoted
+        end
+        # @api private
+        # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+        def default_connection
+          # :nocov:
+          ActiveRecord::Base.connection
+          # :nocov:
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/view/introspection/mysql.rb ADDED

@@ -0,0 +1,29 @@
+module ActiveRecord
+  module View
+    module Introspection
+      class MySQL < Abstract
+        def fetch_view_definition_query(view_name, **options)
+          schema_table.project(schema_definition).where(in_current_database.and(view_name_eq(view_name)))
+        end
+        # @!attribute [r] schema_table
+        # @return [Arel::Table]
+        def schema_table
+          @_schema_table ||= Arel::Table.new 'information_schema.views', self
+        end
+        def schema_definition
+          schema_table['view_definition']
+        end
+        def view_name_eq(name)
+          schema_table['table_name'].eq(name)
+        end
+        def in_current_database
+          schema_table['table_schema'].eq(current_database)
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/view/introspection/postgres.rb ADDED

@@ -0,0 +1,47 @@
+module ActiveRecord
+  module View
+    module Introspection
+      class Postgres < Abstract
+        REGCLASS    = Arel.sql 'regclass'
+        PG_TRUE     = Arel.sql 'true'
+        PG_FALSE    = Arel.sql 'false'
+        NOT_A_VIEW  = Arel::Nodes.build_quoted 'Not a view'
+        around_fetch_view_definition :catch_undefined_table
+        def fetch_view_definition_query(view_name, **options)
+          select_manager.project nullify_if_not_view pg_get_viewdef(view_name, **options)
+        end
+        # @api private
+        # @return [Arel::Nodes::NamedFunction]
+        def pg_get_viewdef(view_name, pretty: false, **options)
+          pretty_bool = pretty ? PG_TRUE : PG_FALSE
+          arel_fn 'pg_get_viewdef', arel_cast(view_name, REGCLASS), pretty_bool
+        end
+        # @api private
+        # @return [Arel::Nodes::NamedFunction]
+        def nullify_if_not_view(expression)
+          arel_fn 'NULLIF', expression, NOT_A_VIEW
+        end
+        # @api private
+        def catch_undefined_table
+          yield
+        rescue ActiveRecord::StatementInvalid => e
+          if e.original_exception.kind_of? PG::UndefinedTable
+            raise e if raise_error?
+            nil
+          else
+            # :nocov:
+            raise e
+            # :nocov:
+          end
+        end
+      end
+    end
+  end
+end