activerecord 7.0.0.rc3 → 7.0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 458dd96fbc8713da75b5ee24f47f90b3330c3baf9f5ce2db5bda1eb2c5ca3c01
-  data.tar.gz: fc473846b0d1ee465223c5980616937a119ef0ce349154ca4c0eb3633db0790a
+  metadata.gz: b892baa52df60baaecc7813d5c9988f540289629ffcefdae8d83a40b9d9b3724
+  data.tar.gz: ec575b7c8f32e41bd93218735a0ca966bbcac5b9ff22bc503b63bf24b70081d3
 SHA512:
-  metadata.gz: 1f7d111235cf366f0de47a9f895d8a01351344b52d5a92dda94e627e424d7b9ed72daec2b371f58fa5d7d2e99de8bb8add753aa16baca7977a1a3174443b5171
-  data.tar.gz: 573befa4bc581ae039212f43f7c622f64a19900de064579f6314b2351457e64b74cfc5d63b37c06058da394244d585d8271f6b1f22b8646e4138e145d8b4b4d1
+  metadata.gz: 8e9d267301499c076f46c5bc4b131cb27e2b4039bb2926a275c0a43a7ca313e31c6e7b667ee27f9c9ec7954cc3bd3655788c0b20ab395dd43a64fdb5e7547bdf
+  data.tar.gz: 30a63818a8216ccf2a66e6e86563304009fa8195deb72c5052f10b00839df6eb4eb6cf4456dad9512b5a2497a08cc844a9acf9388b6df0bb44b6fb36aae24b71

data/CHANGELOG.md

@@ -1,3 +1,194 @@
+## Rails 7.0.2.1 (February 11, 2022) ##
+
+*   No changes.
+
+
+## Rails 7.0.2 (February 08, 2022) ##
+
+*   Fix `PG.connect` keyword arguments deprecation warning on ruby 2.7.
+
+    *Nikita Vasilevsky*
+
+*   Fix the ability to exclude encryption params from being autofiltered.
+
+    *Mark Gangl*
+
+*   Dump the precision for datetime columns following the new defaults.
+
+    *Rafael Mendonça França*
+
+*   Make sure encrypted attributes are not being filtered twice.
+
+    *Nikita Vasilevsky*
+
+*   Dump the database schema containing the current Rails version.
+
+    Since https://github.com/rails/rails/pull/42297, Rails now generate datetime columns
+    with a default precision of 6. This means that users upgrading to Rails 7.0 from 6.1,
+    when loading the database schema, would get the new precision value, which would not match
+    the production schema.
+
+    To avoid this the schema dumper will generate the new format which will include the Rails
+    version and will look like this:
+
+    ```
+    ActiveRecord::Schema[7.0].define
+    ```
+
+    When upgrading from Rails 6.1 to Rails 7.0, you can run the `rails app:update` task that will
+    set the current schema version to 6.1.
+
+    *Rafael Mendonça França*
+
+*   Fix parsing expression for PostgreSQL generated column.
+
+    *fatkodima*
+
+*   Fix `Mysql2::Error: Commands out of sync; you can't run this command now`
+    when bulk-inserting fixtures that exceed `max_allowed_packet` configuration.
+
+    *Nikita Vasilevsky*
+
+*   Fix error when saving an association with a relation named `record`.
+
+    *Dorian Marié*
+
+*   Fix `MySQL::SchemaDumper` behavior about datetime precision value.
+
+    *y0t4*
+
+*   Improve associated with no reflection error.
+
+    *Nikolai*
+
+*   Fix PG.connect keyword arguments deprecation warning on ruby 2.7.
+
+    Fixes #44307.
+
+    *Nikita Vasilevsky*
+
+*   Fix passing options to `check_constraint` from `change_table`.
+
+    *Frederick Cheung*
+
+
+## Rails 7.0.1 (January 06, 2022) ##
+
+
+*   Change `QueryMethods#in_order_of` to drop records not listed in values.
+
+    `in_order_of` now filters down to the values provided, to match the behavior of the `Enumerable` version.
+
+    *Kevin Newton*
+
+*   Allow named expression indexes to be revertible.
+
+    Previously, the following code would raise an error in a reversible migration executed while rolling back, due to the index name not being used in the index removal.
+
+    ```ruby
+    add_index(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
+    ```
+
+    Fixes #43331.
+
+    *Oliver Günther*
+
+*   Better error messages when association name is invalid in the argument of `ActiveRecord::QueryMethods::WhereChain#missing`.
+
+    *ykpythemind*
+
+*   Fix ordered migrations for single db in multi db environment.
+
+    *Himanshu*
+
+*   Extract `on update CURRENT_TIMESTAMP` for mysql2 adapter.
+
+    *Kazuhiro Masuda*
+
+*   Fix incorrect argument in PostgreSQL structure dump tasks.
+
+    Updating the `--no-comment` argument added in Rails 7 to the correct `--no-comments` argument.
+
+    *Alex Dent*
+
+*   Fix schema dumping column default SQL values for sqlite3.
+
+    *fatkodima*
+
+*   Correctly parse complex check constraint expressions for PostgreSQL.
+
+    *fatkodima*
+
+*   Fix `timestamptz` attributes on PostgreSQL handle blank inputs.
+
+    *Alex Ghiculescu*
+
+*   Fix migration compatibility to create SQLite references/belongs_to column as integer when migration version is 6.0.
+
+    Reference/belongs_to in migrations with version 6.0 were creating columns as
+    bigint instead of integer for the SQLite Adapter.
+
+    *Marcelo Lauxen*
+
+*   Fix joining through a polymorphic association.
+
+    *Alexandre Ruban*
+
+*   Fix `QueryMethods#in_order_of` to handle empty order list.
+
+    ```ruby
+    Post.in_order_of(:id, []).to_a
+    ```
+
+    Also more explicitly set the column as secondary order, so that any other
+    value is still ordered.
+
+    *Jean Boussier*
+
+*   Fix `rails dbconsole` for 3-tier config.
+
+    *Eileen M. Uchitelle*
+
+*   Fix quoting of column aliases generated by calculation methods.
+
+    Since the alias is derived from the table name, we can't assume the result
+    is a valid identifier.
+
+    ```ruby
+    class Test < ActiveRecord::Base
+      self.table_name = '1abc'
+    end
+    Test.group(:id).count
+    # syntax error at or near "1" (ActiveRecord::StatementInvalid)
+    # LINE 1: SELECT COUNT(*) AS count_all, "1abc"."id" AS 1abc_id FROM "1...
+    ```
+
+    *Jean Boussier*
+
+
+## Rails 7.0.0 (December 15, 2021) ##
+
+*   Better handle SQL queries with invalid encoding.
+
+    ```ruby
+    Post.create(name: "broken \xC8 UTF-8")
+    ```
+
+    Would cause all adapters to fail in a non controlled way in the code
+    responsible to detect write queries.
+
+    The query is now properly passed to the database connection, which might or might
+    not be able to handle it, but will either succeed or failed in a more correct way.
+
+    *Jean Boussier*
+
+*   Move database and shard selection config options to a generator.
+
+    Rather than generating the config options in `production.rb` when applications are created, applications can now run a generator to create an initializer and uncomment / update options as needed. All multi-db configuration can be implemented in this initializer.
+
+    *Eileen M. Uchitelle*
+
+
 ## Rails 7.0.0.rc3 (December 14, 2021) ##
 
 *   No changes.
@@ -5,6 +196,11 @@
 
 ## Rails 7.0.0.rc2 (December 14, 2021) ##
 
+*   No changes.
+
+
+## Rails 7.0.0.rc1 (December 06, 2021) ##
+
 *   Remove deprecated `ActiveRecord::DatabaseConfigurations::DatabaseConfig#spec_name`.
 
     *Rafael Mendonça França*
@@ -312,7 +508,6 @@
 
     Applications may now set their the filename or path of the schema / structure dump file in their database configuration.
 
-
     ```yaml
     production:
       primary:
@@ -399,6 +594,8 @@
     `#with_lock` now accepts transaction options like `requires_new:`,
     `isolation:`, and `joinable:`
 
+    *John Mileham*
+
 *   Adds support for deferrable foreign key constraints in PostgreSQL.
 
     By default, foreign key constraints in PostgreSQL are checked after each statement. This works for most use cases,
@@ -475,7 +672,7 @@
 
     *Alex Ghiculescu*
 
-* Avoid COMMENT statements in PostgreSQL structure dumps
+*   Avoid COMMENT statements in PostgreSQL structure dumps
 
     COMMENT statements are now omitted from the output of `db:structure:dump` when using PostgreSQL >= 11.
     This allows loading the dump without a pgsql superuser account.
@@ -528,7 +725,7 @@
 
     *Sam Bostock*
 
-* Add ssl support for postgresql database tasks
+*   Add ssl support for postgresql database tasks
 
     Add `PGSSLMODE`, `PGSSLCERT`, `PGSSLKEY` and `PGSSLROOTCERT` to pg_env from database config
     when running postgresql database tasks.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2021 David Heinemeier Hansson
+Copyright (c) 2004-2022 David Heinemeier Hansson
 
 Arel originally copyright (c) 2007-2016 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
 

data/lib/active_record/associations/join_dependency.rb

@@ -3,8 +3,12 @@
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
-      autoload :JoinBase,        "active_record/associations/join_dependency/join_base"
-      autoload :JoinAssociation, "active_record/associations/join_dependency/join_association"
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :JoinBase
+        autoload :JoinAssociation
+      end
 
       class Aliases # :nodoc:
         def initialize(tables)

data/lib/active_record/associations.rb

@@ -290,6 +290,7 @@ module ActiveRecord
     def self.eager_load!
       super
       Preloader.eager_load!
+      JoinDependency.eager_load!
     end
 
     # Returns the association instance for the given name, instantiating it if it doesn't already exist
@@ -594,19 +595,27 @@ module ActiveRecord
       # you can also define callbacks that get triggered when you add an object to or remove an
       # object from an association collection.
       #
-      #   class Project
-      #     has_and_belongs_to_many :developers, after_add: :evaluate_velocity
+      #   class Firm < ActiveRecord::Base
+      #     has_many :clients,
+      #              dependent: :destroy,
+      #              after_add: :congratulate_client,
+      #              after_remove: :log_after_remove
       #
-      #     def evaluate_velocity(developer)
-      #       ...
+      #     def congratulate_client(record)
+      #       # ...
+      #     end
+      #
+      #     def log_after_remove(record)
+      #       # ...
       #     end
-      #   end
       #
       # It's possible to stack callbacks by passing them as an array. Example:
       #
-      #   class Project
-      #     has_and_belongs_to_many :developers,
-      #                             after_add: [:evaluate_velocity, Proc.new { |p, d| p.shipping_date = Time.now}]
+      #   class Firm < ActiveRecord::Base
+      #     has_many :clients,
+      #              dependent: :destroy,
+      #              after_add: [:congratulate_client, -> (firm, record) { firm.log << "after_adding#{record.id}" }],
+      #              after_remove: :log_after_remove
       #   end
       #
       # Possible callbacks are: +before_add+, +after_add+, +before_remove+ and +after_remove+.
@@ -617,6 +626,18 @@ module ActiveRecord
       # Similarly, if any of the +before_remove+ callbacks throw an exception, the object
       # will not be removed from the collection.
       #
+      # Note: To trigger remove callbacks, you must use +destroy+ / +destroy_all+ methods. For example:
+      #
+      #   * <tt>firm.clients.destroy(client)</tt>
+      #   * <tt>firm.clients.destroy(*clients)</tt>
+      #   * <tt>firm.clients.destroy_all</tt>
+      #
+      # +delete+ / +delete_all+ methods like the following do *not* trigger remove callbacks:
+      #
+      #   * <tt>firm.clients.delete(client)</tt>
+      #   * <tt>firm.clients.delete(*clients)</tt>
+      #   * <tt>firm.clients.delete_all</tt>
+      #
       # == Association extensions
       #
       # The proxy objects that control the access to associations can be extended through anonymous

data/lib/active_record/attribute_methods.rb

@@ -413,7 +413,7 @@ module ActiveRecord
           inspected_value = if value.is_a?(String) && value.length > 50
             "#{value[0, 50]}...".inspect
           elsif value.is_a?(Date) || value.is_a?(Time)
-            %("#{value.to_formatted_s(:inspect)}")
+            %("#{value.to_fs(:inspect)}")
           else
             value.inspect
           end

data/lib/active_record/autosave_association.rb

@@ -446,7 +446,7 @@ module ActiveRecord
           elsif autosave != false
             key = reflection.options[:primary_key] ? public_send(reflection.options[:primary_key]) : id
 
-            if (autosave && record.changed_for_autosave?) || record_changed?(reflection, record, key)
+            if (autosave && record.changed_for_autosave?) || _record_changed?(reflection, record, key)
               unless reflection.through_reflection
                 record[reflection.foreign_key] = key
                 association.set_inverse_instance(record)
@@ -461,7 +461,7 @@ module ActiveRecord
       end
 
       # If the record is new or it has changed, returns true.
-      def record_changed?(reflection, record, key)
+      def _record_changed?(reflection, record, key)
         record.new_record? ||
           association_foreign_key_changed?(reflection, record, key) ||
           record.will_save_change_to_attribute?(reflection.foreign_key)

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

@@ -128,7 +128,7 @@ module ActiveRecord
           end
         end
 
-        result = value.to_formatted_s(:db)
+        result = value.to_fs(:db)
         if value.respond_to?(:usec) && value.usec > 0
           result << "." << sprintf("%06d", value.usec)
         else

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

@@ -810,8 +810,8 @@ module ActiveRecord
       #  t.check_constraint("price > 0", name: "price_check")
       #
       # See {connection.add_check_constraint}[rdoc-ref:SchemaStatements#add_check_constraint]
-      def check_constraint(*args)
-        @base.add_check_constraint(name, *args)
+      def check_constraint(*args, **options)
+        @base.add_check_constraint(name, *args, **options)
       end
 
       # Removes the given check constraint from the table.
@@ -819,8 +819,8 @@ module ActiveRecord
       #  t.remove_check_constraint(name: "price_check")
       #
       # See {connection.remove_check_constraint}[rdoc-ref:SchemaStatements#remove_check_constraint]
-      def remove_check_constraint(*args)
-        @base.remove_check_constraint(name, *args)
+      def remove_check_constraint(*args, **options)
+        @base.remove_check_constraint(name, *args, **options)
       end
     end
   end

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

@@ -3,6 +3,8 @@
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     class SchemaDumper < SchemaDumper # :nodoc:
+      DEFAULT_DATETIME_PRECISION = 6 # :nodoc:
+
       def self.create(connection, options)
         new(connection, options)
       end
@@ -63,7 +65,18 @@ module ActiveRecord
         end
 
         def schema_precision(column)
-          column.precision.inspect if column.precision
+          if column.type == :datetime
+            case column.precision
+            when nil
+              "nil"
+            when DEFAULT_DATETIME_PRECISION
+              nil
+            else
+              column.precision.inspect
+            end
+          elsif column.precision
+            column.precision.inspect
+          end
         end
 
         def schema_scale(column)

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

@@ -1438,7 +1438,7 @@ module ActiveRecord
 
           checks = []
 
-          if !options.key?(:name) && column_name.is_a?(String) && /\W/.match?(column_name)
+          if !options.key?(:name) && expression_column_name?(column_name)
             options[:name] = index_name(table_name, column_name)
             column_names = []
           else
@@ -1447,7 +1447,7 @@ module ActiveRecord
 
           checks << lambda { |i| i.name == options[:name].to_s } if options.key?(:name)
 
-          if column_names.present?
+          if column_names.present? && !(options.key?(:name) && expression_column_name?(column_names))
             checks << lambda { |i| index_name(table_name, i.columns) == index_name(table_name, column_names) }
           end
 
@@ -1515,7 +1515,7 @@ module ActiveRecord
         end
 
         def index_column_names(column_names)
-          if column_names.is_a?(String) && /\W/.match?(column_names)
+          if expression_column_name?(column_names)
             column_names
           else
             Array(column_names)
@@ -1523,13 +1523,18 @@ module ActiveRecord
         end
 
         def index_name_options(column_names)
-          if column_names.is_a?(String) && /\W/.match?(column_names)
+          if expression_column_name?(column_names)
             column_names = column_names.scan(/\w+/).join("_")
           end
 
           { column: column_names }
         end
 
+        # Try to identify whether the given column name is an expression
+        def expression_column_name?(column_name)
+          column_name.is_a?(String) && /\W/.match?(column_name)
+        end
+
         def strip_table_name_prefix_and_suffix(table_name)
           prefix = Base.table_name_prefix
           suffix = Base.table_name_suffix

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -197,7 +197,7 @@ module ActiveRecord
 
       # Executes the SQL statement in the context of this connection.
       def execute(sql, name = nil, async: false)
-        raw_execute(sql, name, async)
+        raw_execute(sql, name, async: async)
       end
 
       # Mysql2Adapter doesn't have to free a result after using it, but we use this method

data/lib/active_record/connection_adapters/mysql/database_statements.rb

@@ -26,6 +26,8 @@ module ActiveRecord
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         def explain(arel, binds = [])
@@ -98,8 +100,8 @@ module ActiveRecord
             statements = statements.map { |sql| transform_query(sql) }
             combine_multi_statements(statements).each do |statement|
               raw_execute(statement, name)
+              @connection.abandon_results!
             end
-            @connection.abandon_results!
           end
 
           def default_insert_value(column)

data/lib/active_record/connection_adapters/mysql/schema_dumper.rb

@@ -53,7 +53,13 @@ module ActiveRecord
           end
 
           def schema_precision(column)
-            super unless /\A(?:date)?time(?:stamp)?\b/.match?(column.sql_type) && column.precision == 0
+            if /\Atime(?:stamp)?\b/.match?(column.sql_type) && column.precision == 0
+              nil
+            elsif column.type == :datetime
+              column.precision == 0 ? "nil" : super
+            else
+              super
+            end
           end
 
           def schema_collation(column)

data/lib/active_record/connection_adapters/mysql/schema_statements.rb

@@ -163,6 +163,7 @@ module ActiveRecord
             default, default_function = field[:Default], nil
 
             if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(default)
+              default = "#{default} ON UPDATE #{default}" if /on update CURRENT_TIMESTAMP/i.match?(field[:Extra])
               default, default_function = nil, default
             elsif type_metadata.extra == "DEFAULT_GENERATED"
               default = +"(#{default})" unless default.start_with?("(")

data/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -28,6 +28,8 @@ module ActiveRecord
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         # Executes an SQL statement, returning a PG::Result object on success

data/lib/active_record/connection_adapters/postgresql/oid/timestamp_with_time_zone.rb

@@ -10,6 +10,8 @@ module ActiveRecord
           end
 
           def cast_value(value)
+            return if value.blank?
+
             time = super
             return time if time.is_a?(ActiveSupport::TimeWithZone)
 

data/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -525,7 +525,7 @@ module ActiveRecord
           scope = quoted_scope(table_name)
 
           check_info = exec_query(<<-SQL, "SCHEMA")
-            SELECT conname, pg_get_constraintdef(c.oid) AS constraintdef, c.convalidated AS valid
+            SELECT conname, pg_get_constraintdef(c.oid, true) AS constraintdef, c.convalidated AS valid
             FROM pg_constraint c
             JOIN pg_class t ON c.conrelid = t.oid
             WHERE c.contype = 'c'
@@ -537,7 +537,7 @@ module ActiveRecord
               name: row["conname"],
               validate: row["valid"]
             }
-            expression = row["constraintdef"][/CHECK \({2}(.+)\){2}/, 1]
+            expression = row["constraintdef"][/CHECK \((.+)\)/m, 1]
 
             CheckConstraintDefinition.new(table_name, expression, options)
           end
@@ -569,7 +569,7 @@ module ActiveRecord
               else raise ArgumentError, "No integer type has byte size #{limit}. Use a numeric with scale 0 instead."
               end
             when "enum"
-              raise ArgumentError "enum_type is required for enums" if enum_type.nil?
+              raise ArgumentError, "enum_type is required for enums" if enum_type.nil?
 
               enum_type
             else
@@ -663,7 +663,12 @@ module ActiveRecord
             column_name, type, default, notnull, oid, fmod, collation, comment, attgenerated = field
             type_metadata = fetch_type_metadata(column_name, type, oid.to_i, fmod.to_i)
             default_value = extract_value_from_default(default)
-            default_function = extract_default_function(default_value, default)
+
+            if attgenerated.present?
+              default_function = default
+            else
+              default_function = extract_default_function(default_value, default)
+            end
 
             if match = default_function&.match(/\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z/)
               serial = sequence_name_from_parts(table_name, column_name, match[:suffix]) == match[:sequence_name]

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -75,7 +75,7 @@ module ActiveRecord
 
       class << self
         def new_client(conn_params)
-          PG.connect(conn_params)
+          PG.connect(**conn_params)
         rescue ::PG::Error => error
           if conn_params && conn_params[:dbname] && error.message.include?(conn_params[:dbname])
             raise ActiveRecord::NoDatabaseError.db_error(conn_params[:dbname])
@@ -281,7 +281,7 @@ module ActiveRecord
       def initialize(connection, logger, connection_parameters, config)
         super(connection, logger, config)
 
-        @connection_parameters = connection_parameters
+        @connection_parameters = connection_parameters || {}
 
         # @local_tz is initialized as nil to avoid warnings when connect tries to use it
         @local_tz = nil

data/lib/active_record/connection_adapters/sqlite3/database_statements.rb

@@ -11,6 +11,8 @@ module ActiveRecord
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         def explain(arel, binds = [])

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

@@ -45,6 +45,19 @@ module ActiveRecord
           0
         end
 
+        def quote_default_expression(value, column) # :nodoc:
+          if value.is_a?(Proc)
+            value = value.call
+            if value.match?(/\A\w+\(.*\)\z/)
+              "(#{value})"
+            else
+              value
+            end
+          else
+            super
+          end
+        end
+
         def type_cast(value) # :nodoc:
           case value
           when BigDecimal

data/lib/active_record/connection_adapters/sqlite3/schema_statements.rb

@@ -127,20 +127,20 @@ module ActiveRecord
           end
 
           def new_column_from_field(table_name, field)
-            default = \
-              case field["dflt_value"]
-              when /^null$/i
-                nil
-              when /^'(.*)'$/m
-                $1.gsub("''", "'")
-              when /^"(.*)"$/m
-                $1.gsub('""', '"')
-              else
-                field["dflt_value"]
-              end
+            default = field["dflt_value"]
 
             type_metadata = fetch_type_metadata(field["type"])
-            Column.new(field["name"], default, type_metadata, field["notnull"].to_i == 0, collation: field["collation"])
+            default_value = extract_value_from_default(default)
+            default_function = extract_default_function(default_value, default)
+
+            Column.new(
+              field["name"],
+              default_value,
+              type_metadata,
+              field["notnull"].to_i == 0,
+              default_function,
+              collation: field["collation"]
+            )
           end
 
           def data_source_sql(name = nil, type: nil)