scenic 1.0.0 → 1.1.0

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

@@ -0,0 +1,57 @@
+module Scenic
+  module Adapters
+    class Postgres
+      # Decorates an ActiveRecord connection with methods that help determine
+      # the connections capabilities.
+      #
+      # Every attempt is made to use the versions of these methods defined by
+      # Rails where they are available and public before falling back to our own
+      # implementations for older Rails versions.
+      #
+      # @api private
+      class Connection < SimpleDelegator
+        # True if the connection supports materialized views.
+        #
+        # Delegates to the method of the same name if it is already defined on
+        # the connection. This is the case for Rails 4.2 or higher.
+        #
+        # @return [Boolean]
+        def supports_materialized_views?
+          if undecorated_connection.respond_to?(:supports_materialized_views?)
+            super
+          else
+            postgresql_version >= 90300
+          end
+        end
+
+        # True if the connection supports concurrent refreshes of materialized
+        # views.
+        #
+        # @return [Boolean]
+        def supports_concurrent_refreshes?
+          postgresql_version >= 90400
+        end
+
+        # An integer representing the version of Postgres we're connected to.
+        #
+        # postgresql_version is public in Rails 5, but protected in earlier
+        # versions.
+        #
+        # @return [Integer]
+        def postgresql_version
+          if undecorated_connection.respond_to?(:postgresql_version)
+            super
+          else
+            undecorated_connection.send(:postgresql_version)
+          end
+        end
+
+        private
+
+        def undecorated_connection
+          __getobj__
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Scenic
+  module Adapters
+    class Postgres
+      # Raised when a materialized view operation is attempted on a database
+      # version that does not support materialized views.
+      #
+      # Materialized views are supported on Postgres 9.3 or newer.
+      class MaterializedViewsNotSupportedError < StandardError
+        def initialize
+          super("Materialized views require Postgres 9.3 or newer")
+        end
+      end
+
+      # Raised when attempting a concurrent materialized view refresh on a
+      # database version that does not support that.
+      #
+      # Concurrent materialized view refreshes are supported on Postgres 9.4 or
+      # newer.
+      class ConcurrentRefreshesNotSupportedError < StandardError
+        def initialize
+          super("Concurrent materialized view refreshes require Postgres 9.4 or newer")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Scenic
+  module Adapters
+    class Postgres
+      # Updatine a materialized view causes the view to be dropped and
+      # recreated. This causes any associated indexes to be dropped as well.
+      # This object can be used to capture the existing indexes before the drop
+      # and then reapply appropriate indexes following the create.
+      #
+      # @api private
+      class IndexReapplication
+        # Creates the index reapplication object.
+        #
+        # @param connection [Connection] The connection to execute SQL against.
+        # @param speaker [#say] (ActiveRecord::Migration) The object used for
+        #   logging the results of reapplying indexes.
+        def initialize(connection:, speaker: ActiveRecord::Migration)
+          @connection = connection
+          @speaker = speaker
+        end
+
+        # Caches indexes on the provided object before executing the block and
+        # then reapplying the indexes. Each recreated or skipped index is
+        # announced to STDOUT by default. This can be overridden in the
+        # constructor.
+        #
+        # @param name The name of the object we are reapplying indexes on.
+        # @yield Operations to perform before reapplying indexes.
+        #
+        # @return [void]
+        def on(name)
+          indexes = Indexes.new(connection: connection).on(name)
+
+          yield
+
+          indexes.each(&method(:try_index_create))
+        end
+
+        private
+
+        attr_reader :connection, :speaker
+
+        def try_index_create(index)
+          success = with_savepoint(index.index_name) do
+            connection.execute(index.definition)
+          end
+
+          if success
+            say "index '#{index.index_name}' on '#{index.object_name}' has been recreated"
+          else
+            say "index '#{index.index_name}' on '#{index.object_name}' is no longer valid and has been dropped."
+          end
+        end
+
+        def with_savepoint(name)
+          connection.execute("SAVEPOINT #{name}")
+          yield
+          connection.execute("RELEASE SAVEPOINT #{name}")
+          true
+        rescue
+          connection.execute("ROLLBACK TO SAVEPOINT #{name}")
+          false
+        end
+
+        def say(message)
+          subitem = true
+          speaker.say(message, subitem)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Scenic
+  module Adapters
+    class Postgres
+      # Fetches indexes on objects from the Postgres connection.
+      #
+      # @api private
+      class Indexes
+        def initialize(connection:)
+          @connection = connection
+        end
+
+        # Indexes on the provided object.
+        #
+        # @param name [String] The name of the object we want indexes from.
+        # @return [Array<Scenic::Index>]
+        def on(name)
+          indexes_on(name).map(&method(:index_from_database))
+        end
+
+        private
+
+        attr_reader :connection
+        delegate :quote_table_name, to: :connection
+
+        def indexes_on(name)
+          connection.execute(<<-SQL)
+            SELECT
+              t.relname as object_name,
+              i.relname as index_name,
+              pg_get_indexdef(d.indexrelid) AS definition
+            FROM pg_class t
+            INNER JOIN pg_index d ON t.oid = d.indrelid
+            INNER JOIN pg_class i ON d.indexrelid = i.oid
+            LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
+            WHERE i.relkind = 'i'
+              AND d.indisprimary = 'f'
+              AND t.relname = '#{quote_table_name(name)}'
+              AND n.nspname = ANY (current_schemas(false))
+            ORDER BY i.relname
+          SQL
+        end
+
+        def index_from_database(result)
+          Scenic::Index.new(
+            object_name: result["object_name"],
+            index_name: result["index_name"],
+            definition: result["definition"],
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+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
+            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)
+          Scenic::View.new(
+            name: result["viewname"],
+            definition: result["definition"].strip,
+            materialized: result["kind"] == "m",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/scenic/configuration.rb

@@ -2,7 +2,7 @@ module Scenic
   class Configuration
     # The Scenic database adapter instance to use when executing SQL.
     #
-    # Defualts to an instance of [Scenic::Adapters::Postgres]
+    # Defualts to an instance of {Adapters::Postgres}
     # @return Scenic adapter
     attr_accessor :database
 
@@ -28,7 +28,7 @@ module Scenic
   # @yieldparam [Scenic::Configuration] config current Scenic config
   # ```
   # Scenic.configure do |config|
-  #   config.database = Scenic::Adapters::Postgres
+  #   config.database = Scenic::Adapters::Postgres.new
   # end
   # ```
   def self.configure

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

@@ -15,7 +15,7 @@ module Scenic
     end
 
     def views_in_database
-      @views_in_database ||= Scenic.database.views.sort
+      @views_in_database ||= Scenic.database.views
     end
 
     private

data/lib/scenic/statements.rb

@@ -68,10 +68,8 @@ module Scenic
     # @param version [Fixnum] The version number of the view.
     # @param revert_to_version [Fixnum] The version number to rollback to on
     #   `rake db rollback`
-    # @param materialized [Boolean] Must be false. Updating a meterialized view
-    #   causes indexes on it to be dropped. For this reason you should
-    #   explicitly use {#drop_view} followed by {#create_view} and recreate
-    #   applicable indexes. Setting this to `true` will raise an error.
+    # @param materialized [Boolean] True if updating a materialized view.
+    #   Defaults to false.
     # @return The database response from executing the create statement.
     #
     # @example
@@ -82,17 +80,13 @@ module Scenic
         raise ArgumentError, "version is required"
       end
 
+      sql_definition = definition(name, version)
+
       if materialized
-        raise ArgumentError, "Updating materialized views is not supported "\
-          "because it would cause any indexes to be dropped. Please use "\
-          "'drop_view' followed by 'create_view', being sure to also recreate "\
-          "any previously-existing indexes."
+        Scenic.database.update_materialized_view(name, sql_definition)
+      else
+        Scenic.database.update_view(name, sql_definition)
       end
-
-      drop_view name,
-        revert_to_version: revert_to_version,
-        materialized: materialized
-      create_view(name, version: version, materialized: materialized)
     end
 
     private

data/lib/scenic/version.rb

@@ -1,3 +1,3 @@
 module Scenic
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/scenic/view.rb

@@ -22,9 +22,6 @@ module Scenic
     # @return [Boolean]
     attr_reader :materialized
 
-    # @api private
-    delegate :<=>, to: :name
-
     # Returns a new instance of View.
     #
     # @param name [String] The name of the view.

data/scenic.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^spec/})
   spec.require_paths = ['lib']
 
+  spec.add_development_dependency 'appraisal'
   spec.add_development_dependency 'bundler', '>= 1.5'
   spec.add_development_dependency 'database_cleaner'
   spec.add_development_dependency 'rake'
@@ -27,9 +28,11 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pg'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'ammeter', '>= 1.1.3'
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'redcarpet'
 
   spec.add_dependency 'activerecord', '>= 4.0.0'
   spec.add_dependency 'railties', '>= 4.0.0'
 
-  spec.required_ruby_version = '~> 2.0'
+  spec.required_ruby_version = '~> 2.1'
 end

data/spec/dummy/config/application.rb

@@ -8,5 +8,8 @@ require "scenic"
 
 module Dummy
   class Application < Rails::Application
+    config.cache_classes = true
+    config.eager_load = false
+    config.active_support.deprecation = :stderr
   end
 end

data/spec/scenic/adapters/postgres/connection_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+module Scenic
+  module Adapters
+    describe Postgres::Connection do
+      describe "supports_materialized_views?" do
+        context "supports_materialized_views? was defined on connection" do
+          it "uses the previously defined version" do
+            base_response = double("response from base connection")
+            base_connection = double(
+              "Connection",
+              supports_materialized_views?: base_response,
+            )
+
+            connection = Postgres::Connection.new(base_connection)
+
+            expect(connection.supports_materialized_views?).to be base_response
+          end
+        end
+
+        context "supports_materialized_views? is not already defined" do
+          it "is true if postgres version is at least than 9.3.0" do
+            base_connection = double("Connection", postgresql_version: 90300)
+
+            connection = Postgres::Connection.new(base_connection)
+
+            expect(connection.supports_materialized_views?).to be true
+          end
+
+          it "is false if postgres version is less than 9.3.0" do
+            base_connection = double("Connection", postgresql_version: 90299)
+
+            connection = Postgres::Connection.new(base_connection)
+
+            expect(connection.supports_materialized_views?).to be false
+          end
+        end
+      end
+
+      describe "#postgresql_version" do
+        it "uses the public method on the provided connection if defined" do
+          base_connection = Class.new do
+            def postgresql_version
+              123
+            end
+          end
+
+          connection = Postgres::Connection.new(base_connection.new)
+
+          expect(connection.postgresql_version).to eq 123
+        end
+
+        it "uses the protected method if the underlying method is not public" do
+          base_connection = Class.new do
+            protected
+
+            def postgresql_version
+              123
+            end
+          end
+
+          connection = Postgres::Connection.new(base_connection.new)
+
+          expect(connection.postgresql_version).to eq 123
+        end
+      end
+
+      describe "#supports_concurrent_refresh" do
+        it "is true if postgres version is at least 9.4.0" do
+          base_connection = double("Connection", postgresql_version: 90400)
+
+          connection = Postgres::Connection.new(base_connection)
+
+          expect(connection.supports_concurrent_refreshes?).to be true
+        end
+      end
+    end
+  end
+end