sequel 5.108.0 → 5.109.0

data/lib/sequel/adapters/shared/sqlanywhere.rb

@@ -305,38 +305,6 @@ module Sequel
           super(sql, :+, args)
         when :<<, :>>
           complex_expression_emulate_append(sql, op, args)
-        when :LIKE, :"NOT LIKE"
-          sql << '('
-          literal_append(sql, args[0])
-          sql << (op == :LIKE ? ' REGEXP ' : ' NOT REGEXP ')
-          pattern = String.new
-          last_c = ''
-          args[1].each_char do |c|
-            if  c == '_' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '.'
-            elsif c == '%' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '.*'
-            elsif c == '[' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\['
-            elsif c == ']' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\]'
-            elsif c == '*' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\*'
-            elsif c == '?' and not pattern.end_with?('\\') and last_c != '\\'
-              pattern << '\?'
-            else
-              pattern << c
-            end
-            if c == '\\' and last_c == '\\'
-              last_c = ''
-            else
-              last_c = c
-            end
-          end
-          literal_append(sql, pattern)
-          sql << " ESCAPE "
-          literal_append(sql, "\\")
-          sql << ')'
         when :ILIKE, :"NOT ILIKE"
           super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args)
         when :extract

data/lib/sequel/adapters/sqlite.rb

@@ -336,16 +336,20 @@ module Sequel
           log_sql << sql
           log_sql << ")"
         end
-        if block
-          log_connection_yield(log_sql, conn, args){cps.execute(ps_args, &block)}
-        else
-          log_connection_yield(log_sql, conn, args){cps.execute!(ps_args){|r|}}
-          case type
-          when :insert
-            conn.last_insert_row_id
-          when :update
-            conn.changes
+        begin
+          if block
+            log_connection_yield(log_sql, conn, args){cps.execute(ps_args, &block)}
+          else
+            log_connection_yield(log_sql, conn, args){cps.execute!(ps_args){|r|}}
+            case type
+            when :insert
+              conn.last_insert_row_id
+            when :update
+              conn.changes
+            end
           end
+        ensure
+          cps.clear_bindings!
         end
       end
       

data/lib/sequel/adapters/trilogy.rb

@@ -62,7 +62,8 @@ module Sequel
       private
 
       def database_specific_error_class(exception, opts)
-        if exception.error_code == 1205
+        case exception.error_code
+        when 1205, 3572
           DatabaseLockTimeout
         else
           super

data/lib/sequel/core.rb

@@ -156,7 +156,15 @@ module Sequel
     #   Sequel.extension(:blank)
     #   Sequel.extension(:core_extensions, :named_timezones)
     def extension(*extensions)
-      extensions.each{|e| orig_require("sequel/extensions/#{e}")}
+      extensions.each do |e|
+        e = e.to_s
+
+        if %r{..[/\\]} =~ e
+          raise Error, "cannot use extension with ../ for security reasons"
+        end
+
+        orig_require("sequel/extensions/#{e}")
+      end
     end
     
     # The exception classed raised if there is an error parsing JSON.
@@ -203,7 +211,11 @@ module Sequel
     # Parse the string as JSON and return the result.
     # This can be overridden to use an alternative json implementation.
     def parse_json(json)
-      JSON.parse(json, :create_additions=>false)
+      if JSON::VERSION >= '3'
+        JSON.parse(json)
+      else
+        JSON.parse(json, :create_additions=>false)
+      end
     end
 
     # If a mutex is given, synchronize access using it.  If nil is given, just

data/lib/sequel/database/misc.rb

@@ -229,12 +229,7 @@ module Sequel
     end
 
     # Disallow dup/clone for Database instances
-    undef_method :dup, :clone, :initialize_copy
-    # simplecov:disable
-    if RUBY_VERSION >= '1.9.3'
-    # simplecov:enable
-      undef_method :initialize_clone, :initialize_dup
-    end
+    undef_method :dup, :clone, :initialize_copy, :initialize_clone, :initialize_dup
 
     # Cast the given type to a literal type
     #

data/lib/sequel/database/transactions.rb

@@ -374,9 +374,7 @@ module Sequel
 
     # Whether to commit the current transaction. Thread.current.status is
     # checked because Thread#kill skips rescue blocks (so exception would be
-    # nil), but the transaction should still be rolled back. On Ruby 1.9 (but
-    # not 2.0+), the thread status will still be "run", so Thread#kill
-    # will erroneously commit the transaction, and there isn't a workaround.
+    # nil), but the transaction should still be rolled back.
     def commit_or_rollback_transaction(exception, conn, opts)
       if exception
         false

data/lib/sequel/dataset/actions.rb

@@ -242,7 +242,7 @@ module Sequel
         end
       when 1
         arg = args[0]
-        if arg.is_a?(Integer)
+        if arg.is_a?(Integer) && arg >= 0
           res = if block
             if loader = cached_placeholder_literalizer(:_first_integer_cond_loader) do |pl|
                 where(pl.arg).limit(pl.arg)

data/lib/sequel/dataset/sql.rb

@@ -1346,10 +1346,21 @@ module Sequel
     alias delete_returning_sql insert_returning_sql
     alias update_returning_sql insert_returning_sql
 
-    # SQL fragment specifying a JOIN type, converts underscores to
-    # spaces and upcases.
+    JOIN_TYPE_SQL = {}
+    (CONDITIONED_JOIN_TYPES + UNCONDITIONED_JOIN_TYPES + %i[natural_inner natural_left_outer natural_right_outer natural_full_outer]).each do |join_type|
+      JOIN_TYPE_SQL[join_type] = "#{join_type.to_s.tr('_', ' ').upcase} JOIN".freeze
+    end
+    JOIN_TYPE_SQL[nil] = "JOIN"
+    JOIN_TYPE_SQL.freeze
+    private_constant :JOIN_TYPE_SQL
+
+    # SQL fragment for join type
     def join_type_sql(join_type)
-      "#{join_type.to_s.tr('_', ' ').upcase} JOIN"
+      JOIN_TYPE_SQL.fetch(join_type) do
+        # SEQUEL6: Raise error
+        Sequel::Deprecation.deprecate("Unrecognized join type used: #{join_type.inspect}. This will raise an error starting in Sequel 6.")
+        "#{join_type.to_s.tr('_', ' ').upcase} JOIN"
+      end
     end
 
     # Append USING clause for JOIN USING

data/lib/sequel/extensions/core_refinements.rb

@@ -10,10 +10,7 @@
 #
 #   using Sequel::CoreRefinements
 
-# simplecov:disable
-raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
-# simplecov:enable
-
+#
 module Sequel::CoreRefinements
   # simplecov:disable
   include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -40,9 +40,7 @@
 
 module Sequel
   module DuplicateColumnsHandler
-    # simplecov:disable
-    CALLER_ARGS = (RUBY_VERSION >= '2.0' ? [0,1] : [0]).freeze
-    # simplecov:enable
+    CALLER_ARGS = [0,1].freeze
 
     # Customize handling of duplicate columns for this dataset.
     def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless defined?(yield); nil), &block)

data/lib/sequel/extensions/lit_require_frozen.rb

@@ -63,6 +63,20 @@ module Sequel
     class Error < Sequel::Error
     end
 
+    module BooleanExpressionClassMethods
+      private
+
+      # Do not freeze literal strings in value pairs, so they don't skip
+      # the frozen checks.
+      def from_value_pair(l, r)
+        if LiteralString === r
+          new(:'=', l, r)
+        else
+          super
+        end
+      end
+    end
+
     module DatabaseMethods
       def self.extended(db)
         db.extend_datasets(DatasetMethods)
@@ -105,7 +119,7 @@ module Sequel
       def _check_unfrozen_literal_string(str)
         return if !str.is_a?(String) || str.frozen?
 
-        if str.is_a?(LiteralString)
+        if str.is_a?(LiteralString) && str == str.source
           _check_unfrozen_literal_string(str.source)
         else
           raise Error, "cannot treat unfrozen string as literal SQL: #{str.inspect}"
@@ -126,6 +140,8 @@ module Sequel
     end
   end
 
+  SQL::BooleanExpression.extend(LitRequireFrozen::BooleanExpressionClassMethods)
+
   Dataset.register_extension(:lit_require_frozen, LitRequireFrozen::DatasetMethods)
   Database.register_extension(:lit_require_frozen, LitRequireFrozen::DatabaseMethods)
 end

data/lib/sequel/extensions/named_timezones.rb

@@ -69,7 +69,7 @@ module Sequel
     
     if RUBY_VERSION >= '2.6'
       # Whether Time.at with :nsec and :in is broken.  True on JRuby < 9.3.9.0.
-      BROKEN_TIME_AT_WITH_NSEC = defined?(JRUBY_VERSION) && (JRUBY_VERSION < '9.3' || (JRUBY_VERSION < '9.4' && JRUBY_VERSION.split('.')[2].to_i < 9))
+      BROKEN_TIME_AT_WITH_NSEC = defined?(JRUBY_VERSION) && (JRUBY_VERSION.to_r < Rational('9.3') || (JRUBY_VERSION.to_r < Rational('9.4') && JRUBY_VERSION.split('.')[2].to_i < 9))
       private_constant :BROKEN_TIME_AT_WITH_NSEC
 
       # Convert the given input Time (which must be in UTC) to the given input timezone,

data/lib/sequel/extensions/pg_array.rb

@@ -390,6 +390,7 @@ module Sequel
               elsif char == '{'
                 raise Sequel::Error, "invalid array, opening brace with existing recorded data" unless @recorded.empty?
 
+                raise Sequel::Error, "cannot parse array with more than 6 dimensions" if @stack.length >= 6
                 # Start of new array, add it to the stack
                 new = []
                 @stack.last << new

data/lib/sequel/extensions/pg_json_ops.rb

@@ -984,7 +984,8 @@ module Sequel
               comma = true
             end
             ds.literal_append(sql, v)
-            sql << " AS " << k.to_s
+            sql << " AS "
+            ds.send(:identifier_append, sql, k)
           end
         end
       end
@@ -1254,7 +1255,8 @@ module Sequel
               comma = true
             end
             ds.literal_append(sql, v)
-            sql << " AS " << k.to_s
+            sql << " AS "
+            ds.send(:identifier_append, sql, k)
           end
         end
 

data/lib/sequel/extensions/s.rb

@@ -29,8 +29,7 @@
 #
 #   Object.send(:include, Sequel::S)
 #
-# If you are using Ruby 2+, and you would like to use refinements, you
-# can use Sequel::S as a refinement, in which case the private #S method
+# You can use also Sequel::S as a refinement, in which case the private #S method
 # will be available on all objects while the refinement is active.
 #
 #   using Sequel::S
@@ -39,7 +38,6 @@
 #
 # Related module: Sequel::S
 
-
 # 
 module Sequel::S
   private
@@ -50,11 +48,9 @@ module Sequel::S
   end
 
   # simplecov:disable
-  if RUBY_VERSION >= '2.0.0'
-    include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include
+  include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include
   # simplecov:enable
-    refine Object do
-      send include_meth, Sequel::S
-    end
+  refine Object do
+    send include_meth, Sequel::S
   end
 end

data/lib/sequel/extensions/schema_dumper.rb

@@ -200,8 +200,12 @@ END_MIG
 
     # Recreate the column in the passed Schema::CreateTableGenerator from the given name and parsed database schema.
     def recreate_column(name, schema, gen, options)
+      db_type = schema[:db_type]
+      db_type = literal(db_type) if options[:same_db] && database_type == :sqlite
+
       if options[:single_pk] && schema_autoincrementing_primary_key?(schema)
-        type_hash = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
+        type_hash = options[:same_db] ? {:type=>db_type} : column_schema_to_ruby_type(schema)
+
         [:table, :key, :on_delete, :on_update, :deferrable].each{|f| type_hash[f] = schema[f] if schema[f]}
         if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"} || type_hash == {:type=>"INTEGER"}
           type_hash.delete(:type)
@@ -220,7 +224,7 @@ END_MIG
         end
       else
         col_opts = if options[:same_db]
-          h = {:type=>schema[:db_type]}
+          h = {:type=>db_type}
           if database_type == :mysql && h[:type].start_with?("timestamp")
             h[:null] = true
           end

data/lib/sequel/extensions/symbol_aref.rb

@@ -15,41 +15,21 @@
 #
 #   Sequel.extension :symbol_aref
 #
-# If you are using Ruby 2+, and you would like to use refinements, there
-# is a refinement version of this in the symbol_aref_refinement extension.
+# There is a refinement version of this in the symbol_aref_refinement extension.
 #
 # Related module: Sequel::SymbolAref
 
-if RUBY_VERSION >= '2.0'
-  module Sequel::SymbolAref
-    def [](v)
-      case v
-      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
-        Sequel::SQL::QualifiedIdentifier.new(self, v)
-      else
-        super
-      end
+module Sequel::SymbolAref
+  def [](v)
+    case v
+    when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+      Sequel::SQL::QualifiedIdentifier.new(self, v)
+    else
+      super
     end
   end
+end
 
-  class Symbol
-    prepend Sequel::SymbolAref
-  end
-# simplecov:disable
-else
-  class Symbol
-    if method_defined?(:[])
-      alias_method :aref_before_sequel, :[] 
-    end
-
-    def [](v)
-      case v
-      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
-        Sequel::SQL::QualifiedIdentifier.new(self, v)
-      else
-        aref_before_sequel(v)
-      end
-    end
-  end
+class Symbol
+  prepend Sequel::SymbolAref
 end
-# simplecov:enable

data/lib/sequel/extensions/symbol_aref_refinement.rb

@@ -25,10 +25,7 @@
 #
 # Related module: Sequel::SymbolAref
 
-# simplecov:disable
-raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
-# simplecov:enable
-
+#
 module Sequel::SymbolAref
   refine Symbol do
     def [](v)

data/lib/sequel/extensions/symbol_as.rb

@@ -14,8 +14,7 @@
 #
 #   Sequel.extension :symbol_as
 #
-# If you are using Ruby 2+, and you would like to use refinements, there
-# is a refinement version of this in the symbol_as_refinement extension.
+# There is a refinement version of this in the symbol_as_refinement extension.
 
 # 
 class Symbol

data/lib/sequel/extensions/symbol_as_refinement.rb

@@ -23,10 +23,7 @@
 #
 # Related module: Sequel::SymbolAs
 
-# simplecov:disable
-raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
-# simplecov:enable
-
+#
 module Sequel::SymbolAs
   refine Symbol do
     def as(aliaz, columns=nil)
@@ -34,4 +31,3 @@ module Sequel::SymbolAs
     end
   end
 end
-

data/lib/sequel/model/base.rb

@@ -2433,12 +2433,7 @@ END
     plugin self
     def_initialize_nil_instance_variables
 
-    singleton_class.send(:undef_method, :dup, :clone, :initialize_copy)
-    # simplecov:disable
-    if RUBY_VERSION >= '1.9.3'
-    # simplecov:enable
-      singleton_class.send(:undef_method, :initialize_clone, :initialize_dup)
-    end
+    singleton_class.send(:undef_method, :dup, :clone, :initialize_copy, :initialize_clone, :initialize_dup)
 
     # simplecov:disable
     if defined?(Sequel::Postgres::SEQUEL_PG_VERSION_INTEGER) && Sequel::Postgres::SEQUEL_PG_VERSION_INTEGER >= 11800

data/lib/sequel/plugins/caching.rb

@@ -29,6 +29,13 @@ module Sequel
     #
     # You should not use this plugin if you are using sharding and there are different
     # rows for the same primary key on different shards.
+    #
+    # Note that if you are using a composite key, and multiple columns in the composite
+    # key could potentially contain the character ",", you should override the
+    # +composite_cache_key+ class method to return an an unambiguous string identifying
+    # the specific primary key argument given. For consistency, if you would like to
+    # modify the cache key string used for scalar primary keys, you can override the
+    # +scalar_cache_key+ class method.
     # 
     # Usage:
     #
@@ -81,8 +88,26 @@ module Sequel
 
         # Return a key string for the given primary key.
         def cache_key(pk)
-          raise(Error, 'no primary key for this record') unless pk.is_a?(Array) ? pk.all? : pk
-          "#{cache_key_prefix}:#{Array(pk).join(',')}"
+          case pk
+          when Array
+            raise(Error, 'no primary key for this record') unless pk.all?
+            "#{cache_key_prefix}:#{composite_cache_key(pk)}"
+          else
+            raise(Error, 'no primary key for this record') unless pk
+            "#{cache_key_prefix}:#{scalar_cache_key(pk)}"
+          end
+        end
+
+        # Return an appropriate cache key string for a valid scalar primary key.
+        # By default, converts the primary key to a string.
+        def scalar_cache_key(pk)
+          pk.to_s
+        end
+
+        # Return an appropriate cache key string for a valid composite primary key.
+        # By default, joins with the parts of the compsite key with ",".
+        def composite_cache_key(pk)
+          pk.join(',')
         end
         
         Plugins.inherited_instance_variables(self, :@cache_store=>nil, :@cache_ttl=>nil, :@cache_ignore_exceptions=>nil)

data/lib/sequel/plugins/csv_serializer.rb

@@ -73,23 +73,12 @@ module Sequel
         end
       end
 
-      # Avoid keyword argument separation warnings on Ruby 2.7, while still
-      # being compatible with 1.9.
-      if RUBY_VERSION >= "2.0"
-        instance_eval(<<-END, __FILE__, __LINE__+1)
-          def self.csv_call(*args, opts, &block)
-            CSV.send(*args, **opts, &block)
-          end
-        END
-      else
-        # simplecov:disable
-        # :nodoc:
-        def self.csv_call(*args, opts, &block)
-          CSV.send(*args, opts, &block)
-        end
-        # :nodoc:
-        # simplecov:enable
+      # simplecov:disable
+      def self.csv_call(*args, opts, &block)
+        Sequel::Deprecation.deprecate("Sequel::Plugins::CsvSerializer.csv_call will be removed in Sequel 6.")
+        CSV.send(*args, **opts, &block)
       end
+      # simplecov:enable
 
       module ClassMethods
         # The default opts to use when serializing model objects to CSV
@@ -97,7 +86,7 @@ module Sequel
 
         # Attempt to parse an array of instances from the given CSV string
         def array_from_csv(csv, opts = OPTS)
-          CsvSerializer.csv_call(:parse, csv, process_csv_serializer_opts(opts)).map do |row|
+          CSV.parse(csv, **process_csv_serializer_opts(opts)).map do |row|
             row = row.to_hash
             row.delete(nil)
             new(row)
@@ -147,7 +136,7 @@ module Sequel
         # :headers :: The headers to use for the CSV line. Use nil for a header
         #             to specify the column should be ignored.
         def from_csv(csv, opts = OPTS)
-          row = CsvSerializer.csv_call(:parse_line, csv, model.process_csv_serializer_opts(opts)).to_hash
+          row = CSV.parse_line(csv, **model.process_csv_serializer_opts(opts)).to_hash
           row.delete(nil)
           set(row)
         end
@@ -165,7 +154,7 @@ module Sequel
           opts = model.process_csv_serializer_opts(opts)
           headers = opts[:headers]
 
-          CsvSerializer.csv_call(:generate, model.process_csv_serializer_opts(opts)) do |csv|
+          CSV.generate(**model.process_csv_serializer_opts(opts)) do |csv|
             csv << headers.map{|k| public_send(k)}
           end
         end
@@ -184,7 +173,7 @@ module Sequel
           items = opts.delete(:array) || self
           headers = opts[:headers]
 
-          CsvSerializer.csv_call(:generate, opts) do |csv|
+          CSV.generate(**opts) do |csv|
             items.each do |object|
               csv << headers.map{|header| object.public_send(header)}
             end

data/lib/sequel/plugins/instance_filters.rb

@@ -80,6 +80,14 @@ module Sequel
           instance_filters << [args, block]
         end
       
+        # Clear instance filters when saving changes even if the
+        # object wasn't modified.
+        def save_changes(opts=OPTS)
+          ret = super
+          clear_instance_filters if ret.nil?
+          ret
+        end
+
         private
         
         # If there are any instance filters, make sure not to use the

data/lib/sequel/plugins/instance_hooks.rb

@@ -93,6 +93,25 @@ module Sequel
           super
         end
         
+        # Run and clear save/update/validation hooks when saving changes even if the
+        # object wasn't modified.
+        def save_changes(opts=OPTS)
+          ret = super
+          if ret.nil? && @instance_hooks
+            run_before_instance_hooks(:before_validation)
+            run_before_instance_hooks(:after_validation)
+            run_before_instance_hooks(:before_save)
+            run_before_instance_hooks(:before_update)
+            ret = super
+            run_before_instance_hooks(:after_update)
+            run_before_instance_hooks(:after_save)
+            [:before_validation, :after_validation, :before_save, :before_update, :after_update, :after_save].each do |type|
+              @instance_hooks.delete(type)
+            end
+          end
+          ret
+        end
+
         private
         
         # Add the block as an instance level hook.  For before hooks, add it to

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -22,6 +22,13 @@ module Sequel
     #
     #     plugin :mssql_optimistic_locking, lock_column: :column_name
     #
+    # By default, the plugin allows using the lock column setter method to
+    # either increase or decrease the lock column value. To prevent increases,
+    # which could potentially be used to skip an update when it update should
+    # be made, you can use the +:prevent_increase+ plugin option:
+    #
+    #     plugin :mssql_optimistic_locking, prevent_increase: true
+    #
     # This plugin relies on the instance_filters plugin.
     module MssqlOptimisticLocking
       # Load the instance_filters plugin into the model.
@@ -32,6 +39,8 @@ module Sequel
       # Set the lock column
       def self.configure(model, opts=OPTS)
         model.lock_column = opts[:lock_column] || model.lock_column || :timestamp
+        # SEQUEL6: Make prevent_increase true by default
+        model.send(:prevent_lock_column_increase!) if opts[:prevent_increase]
       end
       
       module InstanceMethods

data/lib/sequel/plugins/optimistic_locking.rb

@@ -20,6 +20,13 @@ module Sequel
     #
     #     plugin :optimistic_locking, lock_column: :version
     #
+    # By default, the plugin allows using the lock column setter method to
+    # either increase or decrease the lock column value. To prevent increases,
+    # which could potentially be used to skip an update when it update should
+    # be made, you can use the +:prevent_increase+ plugin option:
+    #
+    #     plugin :optimistic_locking, prevent_increase: true
+    #
     # This plugin relies on the instance_filters plugin.
     module OptimisticLocking
       # Exception class raised when trying to update or destroy a stale object.
@@ -32,6 +39,8 @@ module Sequel
       # Set the lock column
       def self.configure(model, opts=OPTS)
         model.lock_column = opts[:lock_column] || model.lock_column || :lock_version
+        # SEQUEL6: Make prevent_increase true by default
+        model.send(:prevent_lock_column_increase!) if opts[:prevent_increase]
       end
 
       module InstanceMethods
@@ -42,9 +51,10 @@ module Sequel
         def _update_columns(columns)
           lc = model.lock_column
           lcv = get_column_value(lc)
-          columns[lc] = lcv + 1
+          new_lcv = columns[lc] = lcv + 1
           super
-          set_column_value("#{lc}=", lcv + 1)
+          set_column_value("#{lc}=", nil)
+          set_column_value("#{lc}=", new_lcv)
           changed_columns.delete(lc)
           nil
         end