activerecord 5.2.3

data/lib/active_record/connection_adapters/abstract/query_cache.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module QueryCache
+      class << self
+        def included(base) #:nodoc:
+          dirties_query_cache base, :insert, :update, :delete, :rollback_to_savepoint, :rollback_db_transaction
+
+          base.set_callback :checkout, :after, :configure_query_cache!
+          base.set_callback :checkin, :after, :disable_query_cache!
+        end
+
+        def dirties_query_cache(base, *method_names)
+          method_names.each do |method_name|
+            base.class_eval <<-end_code, __FILE__, __LINE__ + 1
+              def #{method_name}(*)
+                clear_query_cache if @query_cache_enabled
+                super
+              end
+            end_code
+          end
+        end
+      end
+
+      module ConnectionPoolConfiguration
+        def initialize(*)
+          super
+          @query_cache_enabled = Concurrent::Map.new { false }
+        end
+
+        def enable_query_cache!
+          @query_cache_enabled[connection_cache_key(Thread.current)] = true
+          connection.enable_query_cache! if active_connection?
+        end
+
+        def disable_query_cache!
+          @query_cache_enabled.delete connection_cache_key(Thread.current)
+          connection.disable_query_cache! if active_connection?
+        end
+
+        def query_cache_enabled
+          @query_cache_enabled[connection_cache_key(Thread.current)]
+        end
+      end
+
+      attr_reader :query_cache, :query_cache_enabled
+
+      def initialize(*)
+        super
+        @query_cache         = Hash.new { |h, sql| h[sql] = {} }
+        @query_cache_enabled = false
+      end
+
+      # Enable the query cache within the block.
+      def cache
+        old, @query_cache_enabled = @query_cache_enabled, true
+        yield
+      ensure
+        @query_cache_enabled = old
+        clear_query_cache unless @query_cache_enabled
+      end
+
+      def enable_query_cache!
+        @query_cache_enabled = true
+      end
+
+      def disable_query_cache!
+        @query_cache_enabled = false
+        clear_query_cache
+      end
+
+      # Disable the query cache within the block.
+      def uncached
+        old, @query_cache_enabled = @query_cache_enabled, false
+        yield
+      ensure
+        @query_cache_enabled = old
+      end
+
+      # Clears the query cache.
+      #
+      # One reason you may wish to call this method explicitly is between queries
+      # that ask the database to randomize results. Otherwise the cache would see
+      # the same SQL query and repeatedly return the same result each time, silently
+      # undermining the randomness you were expecting.
+      def clear_query_cache
+        @lock.synchronize do
+          @query_cache.clear
+        end
+      end
+
+      def select_all(arel, name = nil, binds = [], preparable: nil)
+        if @query_cache_enabled && !locked?(arel)
+          arel = arel_from_relation(arel)
+          sql, binds = to_sql_and_binds(arel, binds)
+
+          if preparable.nil?
+            preparable = prepared_statements ? visitor.preparable : false
+          end
+
+          cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable) }
+        else
+          super
+        end
+      end
+
+      private
+
+        def cache_sql(sql, name, binds)
+          @lock.synchronize do
+            result =
+              if @query_cache[sql].key?(binds)
+                ActiveSupport::Notifications.instrument(
+                  "sql.active_record",
+                  sql: sql,
+                  binds: binds,
+                  type_casted_binds: -> { type_casted_binds(binds) },
+                  name: name,
+                  connection_id: object_id,
+                  cached: true,
+                )
+                @query_cache[sql][binds]
+              else
+                @query_cache[sql][binds] = yield
+              end
+            result.dup
+          end
+        end
+
+        # If arel is locked this is a SELECT ... FOR UPDATE or somesuch. Such
+        # queries should not be cached.
+        def locked?(arel)
+          arel = arel.arel if arel.is_a?(Relation)
+          arel.respond_to?(:locked) && arel.locked
+        end
+
+        def configure_query_cache!
+          enable_query_cache! if pool.query_cache_enabled
+        end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/big_decimal/conversions"
+require "active_support/multibyte/chars"
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module Quoting
+      # Quotes the column value to help prevent
+      # {SQL injection attacks}[https://en.wikipedia.org/wiki/SQL_injection].
+      def quote(value)
+        value = id_value_for_database(value) if value.is_a?(Base)
+
+        if value.respond_to?(:value_for_database)
+          value = value.value_for_database
+        end
+
+        _quote(value)
+      end
+
+      # Cast a +value+ to a type that the database understands. For example,
+      # SQLite does not understand dates, so this method will convert a Date
+      # to a String.
+      def type_cast(value, column = nil)
+        value = id_value_for_database(value) if value.is_a?(Base)
+
+        if column
+          value = type_cast_from_column(column, value)
+        end
+
+        _type_cast(value)
+      rescue TypeError
+        to_type = column ? " to #{column.type}" : ""
+        raise TypeError, "can't cast #{value.class}#{to_type}"
+      end
+
+      # If you are having to call this function, you are likely doing something
+      # wrong. The column does not have sufficient type information if the user
+      # provided a custom type on the class level either explicitly (via
+      # Attributes::ClassMethods#attribute) or implicitly (via
+      # AttributeMethods::Serialization::ClassMethods#serialize, +time_zone_aware_attributes+).
+      # In almost all cases, the sql type should only be used to change quoting behavior, when the primitive to
+      # represent the type doesn't sufficiently reflect the differences
+      # (varchar vs binary) for example. The type used to get this primitive
+      # should have been provided before reaching the connection adapter.
+      def type_cast_from_column(column, value) # :nodoc:
+        if column
+          type = lookup_cast_type_from_column(column)
+          type.serialize(value)
+        else
+          value
+        end
+      end
+
+      # See docs for #type_cast_from_column
+      def lookup_cast_type_from_column(column) # :nodoc:
+        lookup_cast_type(column.sql_type)
+      end
+
+      # Quotes a string, escaping any ' (single quote) and \ (backslash)
+      # characters.
+      def quote_string(s)
+        s.gsub('\\'.freeze, '\&\&'.freeze).gsub("'".freeze, "''".freeze) # ' (for ruby-mode)
+      end
+
+      # Quotes the column name. Defaults to no quoting.
+      def quote_column_name(column_name)
+        column_name.to_s
+      end
+
+      # Quotes the table name. Defaults to column name quoting.
+      def quote_table_name(table_name)
+        quote_column_name(table_name)
+      end
+
+      # Override to return the quoted table name for assignment. Defaults to
+      # table quoting.
+      #
+      # This works for mysql2 where table.column can be used to
+      # resolve ambiguity.
+      #
+      # We override this in the sqlite3 and postgresql adapters to use only
+      # the column name (as per syntax requirements).
+      def quote_table_name_for_assignment(table, attr)
+        quote_table_name("#{table}.#{attr}")
+      end
+
+      def quote_default_expression(value, column) # :nodoc:
+        if value.is_a?(Proc)
+          value.call
+        else
+          value = lookup_cast_type(column.sql_type).serialize(value)
+          quote(value)
+        end
+      end
+
+      def quoted_true
+        "TRUE".freeze
+      end
+
+      def unquoted_true
+        true
+      end
+
+      def quoted_false
+        "FALSE".freeze
+      end
+
+      def unquoted_false
+        false
+      end
+
+      # Quote date/time values for use in SQL input. Includes microseconds
+      # if the value is a Time responding to usec.
+      def quoted_date(value)
+        if value.acts_like?(:time)
+          zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+
+          if value.respond_to?(zone_conversion_method)
+            value = value.send(zone_conversion_method)
+          end
+        end
+
+        result = value.to_s(:db)
+        if value.respond_to?(:usec) && value.usec > 0
+          "#{result}.#{sprintf("%06d", value.usec)}"
+        else
+          result
+        end
+      end
+
+      def quoted_time(value) # :nodoc:
+        value = value.change(year: 2000, month: 1, day: 1)
+        quoted_date(value).sub(/\A\d\d\d\d-\d\d-\d\d /, "")
+      end
+
+      def quoted_binary(value) # :nodoc:
+        "'#{quote_string(value.to_s)}'"
+      end
+
+      def type_casted_binds(binds) # :nodoc:
+        if binds.first.is_a?(Array)
+          binds.map { |column, value| type_cast(value, column) }
+        else
+          binds.map { |attr| type_cast(attr.value_for_database) }
+        end
+      end
+
+      private
+        def lookup_cast_type(sql_type)
+          type_map.lookup(sql_type)
+        end
+
+        def id_value_for_database(value)
+          if primary_key = value.class.primary_key
+            value.instance_variable_get(:@attributes)[primary_key].value_for_database
+          end
+        end
+
+        def types_which_need_no_typecasting
+          [nil, Numeric, String]
+        end
+
+        def _quote(value)
+          case value
+          when String, ActiveSupport::Multibyte::Chars
+            "'#{quote_string(value.to_s)}'"
+          when true       then quoted_true
+          when false      then quoted_false
+          when nil        then "NULL"
+          # BigDecimals need to be put in a non-normalized form and quoted.
+          when BigDecimal then value.to_s("F")
+          when Numeric, ActiveSupport::Duration then value.to_s
+          when Type::Binary::Data then quoted_binary(value)
+          when Type::Time::Value then "'#{quoted_time(value)}'"
+          when Date, Time then "'#{quoted_date(value)}'"
+          when Symbol     then "'#{quote_string(value.to_s)}'"
+          when Class      then "'#{value}'"
+          else raise TypeError, "can't quote #{value.class.name}"
+          end
+        end
+
+        def _type_cast(value)
+          case value
+          when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+            value.to_s
+          when true       then unquoted_true
+          when false      then unquoted_false
+          # BigDecimals need to be put in a non-normalized form and quoted.
+          when BigDecimal then value.to_s("F")
+          when Type::Time::Value then quoted_time(value)
+          when Date, Time then quoted_date(value)
+          when *types_which_need_no_typecasting
+            value
+          else raise TypeError
+          end
+        end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract/savepoints.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Savepoints
+      def current_savepoint_name
+        current_transaction.savepoint_name
+      end
+
+      def create_savepoint(name = current_savepoint_name)
+        execute("SAVEPOINT #{name}")
+      end
+
+      def exec_rollback_to_savepoint(name = current_savepoint_name)
+        execute("ROLLBACK TO SAVEPOINT #{name}")
+      end
+
+      def release_savepoint(name = current_savepoint_name)
+        execute("RELEASE SAVEPOINT #{name}")
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/abstract/schema_creation.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/strip"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      class SchemaCreation # :nodoc:
+        def initialize(conn)
+          @conn = conn
+          @cache = {}
+        end
+
+        def accept(o)
+          m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
+          send m, o
+        end
+
+        delegate :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
+          :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys_in_create?, :foreign_key_options, to: :@conn
+        private :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
+          :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys_in_create?, :foreign_key_options
+
+        private
+
+          def visit_AlterTable(o)
+            sql = "ALTER TABLE #{quote_table_name(o.name)} ".dup
+            sql << o.adds.map { |col| accept col }.join(" ")
+            sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(" ")
+            sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(" ")
+          end
+
+          def visit_ColumnDefinition(o)
+            o.sql_type = type_to_sql(o.type, o.options)
+            column_sql = "#{quote_column_name(o.name)} #{o.sql_type}".dup
+            add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
+            column_sql
+          end
+
+          def visit_AddColumnDefinition(o)
+            "ADD #{accept(o.column)}".dup
+          end
+
+          def visit_TableDefinition(o)
+            create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} ".dup
+
+            statements = o.columns.map { |c| accept c }
+            statements << accept(o.primary_keys) if o.primary_keys
+
+            if supports_indexes_in_create?
+              statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
+            end
+
+            if supports_foreign_keys_in_create?
+              statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+            end
+
+            create_sql << "(#{statements.join(', ')})" if statements.present?
+            add_table_options!(create_sql, table_options(o))
+            create_sql << " AS #{to_sql(o.as)}" if o.as
+            create_sql
+          end
+
+          def visit_PrimaryKeyDefinition(o)
+            "PRIMARY KEY (#{o.name.map { |name| quote_column_name(name) }.join(', ')})"
+          end
+
+          def visit_ForeignKeyDefinition(o)
+            sql = <<-SQL.strip_heredoc
+              CONSTRAINT #{quote_column_name(o.name)}
+              FOREIGN KEY (#{quote_column_name(o.column)})
+                REFERENCES #{quote_table_name(o.to_table)} (#{quote_column_name(o.primary_key)})
+            SQL
+            sql << " #{action_sql('DELETE', o.on_delete)}" if o.on_delete
+            sql << " #{action_sql('UPDATE', o.on_update)}" if o.on_update
+            sql
+          end
+
+          def visit_AddForeignKey(o)
+            "ADD #{accept(o)}"
+          end
+
+          def visit_DropForeignKey(name)
+            "DROP CONSTRAINT #{quote_column_name(name)}"
+          end
+
+          def table_options(o)
+            table_options = {}
+            table_options[:comment] = o.comment
+            table_options[:options] = o.options
+            table_options
+          end
+
+          def add_table_options!(create_sql, options)
+            if options_sql = options[:options]
+              create_sql << " #{options_sql}"
+            end
+            create_sql
+          end
+
+          def column_options(o)
+            o.options.merge(column: o)
+          end
+
+          def add_column_options!(sql, options)
+            sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
+            # must explicitly check for :null to allow change_column to work on migrations
+            if options[:null] == false
+              sql << " NOT NULL"
+            end
+            if options[:auto_increment] == true
+              sql << " AUTO_INCREMENT"
+            end
+            if options[:primary_key] == true
+              sql << " PRIMARY KEY"
+            end
+            sql
+          end
+
+          def to_sql(sql)
+            sql = sql.to_sql if sql.respond_to?(:to_sql)
+            sql
+          end
+
+          def foreign_key_in_create(from_table, to_table, options)
+            options = foreign_key_options(from_table, to_table, options)
+            accept ForeignKeyDefinition.new(from_table, to_table, options)
+          end
+
+          def action_sql(action, dependency)
+            case dependency
+            when :nullify then "ON #{action} SET NULL"
+            when :cascade  then "ON #{action} CASCADE"
+            when :restrict then "ON #{action} RESTRICT"
+            else
+              raise ArgumentError, <<-MSG.strip_heredoc
+                '#{dependency}' is not supported for :on_update or :on_delete.
+                Supported values are: :nullify, :cascade, :restrict
+              MSG
+            end
+          end
+      end
+    end
+    SchemaCreation = AbstractAdapter::SchemaCreation # :nodoc:
+  end
+end