sequel 4.39.0 → 4.40.0

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

@@ -4,10 +4,6 @@ Sequel.require 'adapters/utils/split_alter_table'
 Sequel.require 'adapters/utils/replace'
 
 module Sequel
-  Dataset::NON_SQL_OPTIONS << :insert_ignore
-  Dataset::NON_SQL_OPTIONS << :update_ignore
-  Dataset::NON_SQL_OPTIONS << :on_duplicate_key_update
-
   module MySQL
     Sequel::Database.set_shared_adapter_scheme(:mysql, self)
 
@@ -76,11 +72,11 @@ module Sequel
         m = output_identifier_meth
         im = input_identifier_meth
         ds = metadata_dataset.
-          from(:INFORMATION_SCHEMA__KEY_COLUMN_USAGE).
+          from(Sequel[:INFORMATION_SCHEMA][:KEY_COLUMN_USAGE]).
           where(:TABLE_NAME=>im.call(table), :TABLE_SCHEMA=>Sequel.function(:DATABASE)).
           exclude(:CONSTRAINT_NAME=>'PRIMARY').
           exclude(:REFERENCED_TABLE_NAME=>nil).
-          select(:CONSTRAINT_NAME___name, :COLUMN_NAME___column, :REFERENCED_TABLE_NAME___table, :REFERENCED_COLUMN_NAME___key)
+          select(Sequel[:CONSTRAINT_NAME].as(:name), Sequel[:COLUMN_NAME].as(:column), Sequel[:REFERENCED_TABLE_NAME].as(:table), Sequel[:REFERENCED_COLUMN_NAME].as(:key))
         
         h = {}
         ds.each do |row|
@@ -623,6 +619,8 @@ module Sequel
       # Comes directly from MySQL's documentation, used for queries with limits without offsets
       ONLY_OFFSET = ",18446744073709551615".freeze
 
+      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:insert_ignore, :update_ignore, :on_duplicate_key_update]).freeze
+
       Dataset.def_sql_method(self, :delete, %w'delete from where order limit')
       Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update')
       Dataset.def_sql_method(self, :select, %w'select distinct calc_found_rows columns from join where group having compounds order limit lock')
@@ -998,6 +996,11 @@ module Sequel
         :values
       end
 
+      # Dataset options that do not affect the generated SQL.
+      def non_sql_options
+        NON_SQL_OPTIONS
+      end
+
       def select_only_offset_sql(sql)
         sql << LIMIT
         literal_append(sql, @opts[:offset])

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

@@ -47,11 +47,22 @@ module Sequel
         im = input_identifier_meth
         schema, table = schema_and_table(table)
         ds = metadata_dataset.
-          from(:all_cons_columns___pc, :all_constraints___p, :all_cons_columns___fc, :all_constraints___f).
-          where(:f__table_name=>im.call(table), :f__constraint_type=>'R', :p__owner=>:f__r_owner, :p__constraint_name=>:f__r_constraint_name, :pc__owner=>:p__owner, :pc__constraint_name=>:p__constraint_name, :pc__table_name=>:p__table_name, :fc__owner=>:f__owner, :fc__constraint_name=>:f__constraint_name, :fc__table_name=>:f__table_name, :fc__position=>:pc__position).
-          select(:p__table_name___table, :pc__column_name___key, :fc__column_name___column, :f__constraint_name___name).
-          order(:table, :fc__position)
-        ds = ds.where(:f__schema_name=>im.call(schema)) if schema
+          from{[all_cons_columns.as(:pc), all_constraints.as(:p), all_cons_columns.as(:fc), all_constraints.as(:f)]}.
+          where{{
+            f[:table_name]=>im.call(table),
+            f[:constraint_type]=>'R',
+            p[:owner]=>f[:r_owner],
+            p[:constraint_name]=>f[:r_constraint_name],
+            pc[:owner]=>p[:owner],
+            pc[:constraint_name]=>p[:constraint_name],
+            pc[:table_name]=>p[:table_name],
+            fc[:owner]=>f[:owner],
+            fc[:constraint_name]=>f[:constraint_name],
+            fc[:table_name]=>f[:table_name],
+            fc[:position]=>pc[:position]}}.
+          select{[p[:table_name].as(:table), pc[:column_name].as(:key), fc[:column_name].as(:column), f[:constraint_name].as(:name)]}.
+          order{[:table, fc[:position]]}
+        ds = ds.where{{f[:schema_name]=>im.call(schema)}} if schema
 
         fks = {}
         ds.each do |r|

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

@@ -309,11 +309,15 @@ module Sequel
         m = output_identifier_meth
         schema, _ = opts.fetch(:schema, schema_and_table(table))
         range = 0...32
+        oid = regclass_oid(table)
 
         base_ds = metadata_dataset.
-          from(:pg_constraint___co).
-          join(:pg_class___cl, :oid=>:conrelid).
-          where(:cl__relkind=>'r', :co__contype=>'f', :cl__oid=>regclass_oid(table))
+          from{pg_constraint.as(:co)}.
+          join(Sequel[:pg_class].as(:cl), :oid=>:conrelid).
+          where{{
+            cl[:relkind]=>'r',
+            co[:contype]=>'f',
+            cl[:oid]=>oid}}
 
         # We split the parsing into two separate queries, which are merged manually later.
         # This is because PostgreSQL stores both the referencing and referenced columns in
@@ -322,22 +326,33 @@ module Sequel
         # the index of that element in the array.
 
         ds = base_ds.
-          join(:pg_attribute___att, :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, :co__conkey)).
-          order(:co__conname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:co__conkey, [x]), x]}, 32, :att__attnum)).
-          select(:co__conname___name, :att__attname___column, :co__confupdtype___on_update, :co__confdeltype___on_delete,
-                 SQL::BooleanExpression.new(:AND, :co__condeferrable, :co__condeferred).as(:deferrable))
+          join(Sequel[:pg_attribute].as(:att), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+          order{[
+            co[:conname],
+            SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:conkey], [x]), x]}, 32, att[:attnum])]}.
+          select{[
+            co[:conname].as(:name),
+            att[:attname].as(:column),
+            co[:confupdtype].as(:on_update),
+            co[:confdeltype].as(:on_delete),
+            SQL::BooleanExpression.new(:AND, co[:condeferrable], co[:condeferred]).as(:deferrable)]}
 
         ref_ds = base_ds.
-          join(:pg_class___cl2, :oid=>:co__confrelid).
-          join(:pg_attribute___att2, :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, :co__confkey)).
-          order(:co__conname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:co__confkey, [x]), x]}, 32, :att2__attnum)).
-          select(:co__conname___name, :cl2__relname___table, :att2__attname___refcolumn)
+          join(Sequel[:pg_class].as(:cl2), :oid=>Sequel[:co][:confrelid]).
+          join(Sequel[:pg_attribute].as(:att2), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:confkey])).
+          order{[
+            co[:conname],
+            SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:confkey], [x]), x]}, 32, att2[:attnum])]}.
+          select{[
+            co[:conname].as(:name),
+            cl2[:relname].as(:table),
+            att2[:attname].as(:refcolumn)]}
 
         # If a schema is given, we only search in that schema, and the returned :table
         # entry is schema qualified as well.
         if schema
-          ref_ds = ref_ds.join(:pg_namespace___nsp2, :oid=>:cl2__relnamespace).
-            select_more(:nsp2__nspname___schema)
+          ref_ds = ref_ds.join(Sequel[:pg_namespace].as(:nsp2), :oid=>Sequel[:cl2][:relnamespace]).
+            select_more{nsp2[:nspname].as(:schema)}
         end
 
         h = {}
@@ -362,18 +377,25 @@ module Sequel
       def indexes(table, opts=OPTS)
         m = output_identifier_meth
         range = 0...32
-        attnums = server_version >= 80100 ? SQL::Function.new(:ANY, :ind__indkey) : range.map{|x| SQL::Subscript.new(:ind__indkey, [x])}
+        attnums = server_version >= 80100 ? SQL::Function.new(:ANY, Sequel[:ind][:indkey]) : range.map{|x| SQL::Subscript.new(Sequel[:ind][:indkey], [x])}
+        oid = regclass_oid(table, opts)
         ds = metadata_dataset.
-          from(:pg_class___tab).
-          join(:pg_index___ind, :indrelid=>:oid).
-          join(:pg_class___indc, :oid=>:indexrelid).
-          join(:pg_attribute___att, :attrelid=>:tab__oid, :attnum=>attnums).
-          left_join(:pg_constraint___con, :conname=>:indc__relname).
-          filter(:indc__relkind=>'i', :ind__indisprimary=>false, :indexprs=>nil, :indpred=>nil, :indisvalid=>true, :tab__oid=>regclass_oid(table, opts)).
-          order(:indc__relname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:ind__indkey, [x]), x]}, 32, :att__attnum)).
-          select(:indc__relname___name, :ind__indisunique___unique, :att__attname___column, :con__condeferrable___deferrable)
-
-        ds.filter!(:indisready=>true, :indcheckxmin=>false) if server_version >= 80300
+          from{pg_class.as(:tab)}.
+          join(Sequel[:pg_index].as(:ind), :indrelid=>:oid).
+          join(Sequel[:pg_class].as(:indc), :oid=>:indexrelid).
+          join(Sequel[:pg_attribute].as(:att), :attrelid=>Sequel[:tab][:oid], :attnum=>attnums).
+          left_join(Sequel[:pg_constraint].as(:con), :conname=>Sequel[:indc][:relname]).
+          where{{
+            indc[:relkind]=>'i',
+            ind[:indisprimary]=>false,
+            :indexprs=>nil,
+            :indpred=>nil,
+            :indisvalid=>true,
+            tab[:oid]=>oid}}.
+          order{[indc[:relname], SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(ind[:indkey], [x]), x]}, 32, att[:attnum])]}.
+          select{[indc[:relname].as(:name), ind[:indisunique].as(:unique), att[:attname].as(:column), con[:condeferrable].as(:deferrable)]}
+
+        ds = ds.where(:indisready=>true, :indcheckxmin=>false) if server_version >= 80300
 
         indexes = {}
         ds.each do |r|
@@ -385,7 +407,7 @@ module Sequel
 
       # Dataset containing all current database locks
       def locks
-        dataset.from(:pg_class).join(:pg_locks, :relation=>:relfilenode).select(:pg_class__relname, Sequel::SQL::ColumnAll.new(:pg_locks))
+        dataset.from(:pg_class).join(:pg_locks, :relation=>:relfilenode).select{[pg_class[:relname], Sequel::SQL::ColumnAll.new(:pg_locks)]}
       end
 
       # Notifies the given channel.  See the PostgreSQL NOTIFY documentation. Options:
@@ -972,7 +994,7 @@ module Sequel
         else
           Sequel.function(:any, Sequel.function(:current_schemas, false))
         end
-        ds.where(:pg_namespace__nspname=>expr)
+        ds.where{{pg_namespace[:nspname]=>expr}}
       end
 
       # Return a hash with oid keys and callable values, used for converting types.
@@ -1032,7 +1054,7 @@ module Sequel
         if block_given?
           yield(ds)
         elsif opts[:qualify]
-          ds.select_append(:pg_namespace__nspname).map{|r| Sequel.qualify(m.call(r[:nspname]), m.call(r[:relname]))}
+          ds.select_append{pg_namespace[:nspname]}.map{|r| Sequel.qualify(m.call(r[:nspname]).to_s, m.call(r[:relname]).to_s)}
         else
           ds.map{|r| m.call(r[:relname])}
         end
@@ -1098,24 +1120,26 @@ module Sequel
       # The dataset used for parsing table schemas, using the pg_* system catalogs.
       def schema_parse_table(table_name, opts)
         m = output_identifier_meth(opts[:dataset])
-        ds = metadata_dataset.select(:pg_attribute__attname___name,
-            SQL::Cast.new(:pg_attribute__atttypid, :integer).as(:oid),
-            SQL::Cast.new(:basetype__oid, :integer).as(:base_oid),
-            SQL::Function.new(:format_type, :basetype__oid, :pg_type__typtypmod).as(:db_base_type),
-            SQL::Function.new(:format_type, :pg_type__oid, :pg_attribute__atttypmod).as(:db_type),
-            SQL::Function.new(:pg_get_expr, :pg_attrdef__adbin, :pg_class__oid).as(:default),
-            SQL::BooleanExpression.new(:NOT, :pg_attribute__attnotnull).as(:allow_null),
-            SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(:pg_attribute__attnum => SQL::Function.new(:ANY, :pg_index__indkey)), false).as(:primary_key)).
+        oid = regclass_oid(table_name, opts)
+        ds = metadata_dataset.select{[
+            pg_attribute[:attname].as(:name),
+            SQL::Cast.new(pg_attribute[:atttypid], :integer).as(:oid),
+            SQL::Cast.new(basetype[:oid], :integer).as(:base_oid),
+            SQL::Function.new(:format_type, basetype[:oid], pg_type[:typtypmod]).as(:db_base_type),
+            SQL::Function.new(:format_type, pg_type[:oid], pg_attribute[:atttypmod]).as(:db_type),
+            SQL::Function.new(:pg_get_expr, pg_attrdef[:adbin], pg_class[:oid]).as(:default),
+            SQL::BooleanExpression.new(:NOT, pg_attribute[:attnotnull]).as(:allow_null),
+            SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(pg_attribute[:attnum] => SQL::Function.new(:ANY, pg_index[:indkey])), false).as(:primary_key)]}.
           from(:pg_class).
           join(:pg_attribute, :attrelid=>:oid).
           join(:pg_type, :oid=>:atttypid).
-          left_outer_join(:pg_type___basetype, :oid=>:typbasetype).
-          left_outer_join(:pg_attrdef, :adrelid=>:pg_class__oid, :adnum=>:pg_attribute__attnum).
-          left_outer_join(:pg_index, :indrelid=>:pg_class__oid, :indisprimary=>true).
-          filter(:pg_attribute__attisdropped=>false).
-          filter{|o| o.pg_attribute__attnum > 0}.
-          filter(:pg_class__oid=>regclass_oid(table_name, opts)).
-          order(:pg_attribute__attnum)
+          left_outer_join(Sequel[:pg_type].as(:basetype), :oid=>:typbasetype).
+          left_outer_join(:pg_attrdef, :adrelid=>Sequel[:pg_class][:oid], :adnum=>Sequel[:pg_attribute][:attnum]).
+          left_outer_join(:pg_index, :indrelid=>Sequel[:pg_class][:oid], :indisprimary=>true).
+          where{{pg_attribute[:attisdropped]=>false}}.
+          where{pg_attribute[:attnum] > 0}.
+          where{{pg_class[:oid]=>oid}}.
+          order{pg_attribute[:attnum]}
         ds.map do |row|
           row[:default] = nil if blank_object?(row[:default])
           if row[:base_oid]
@@ -1240,6 +1264,8 @@ module Sequel
       LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze)
       SKIP_LOCKED = " SKIP LOCKED".freeze
 
+      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:cursor, :insert_conflict]).freeze
+
       Dataset.def_sql_method(self, :delete, [['if server_version >= 90100', %w'with delete from using where returning'], ['else', %w'delete from using where returning']])
       Dataset.def_sql_method(self, :insert, [['if server_version >= 90500', %w'with insert into columns values conflict returning'], ['elsif server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
       Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'values order limit'], ['elsif server_version >= 80400', %w'with select distinct columns from join where group having window compounds order limit lock'], ['else', %w'select distinct columns from join where group having compounds order limit lock']])
@@ -1403,6 +1429,7 @@ module Sequel
 
       # Handle uniqueness violations when inserting, by updating the conflicting row, using
       # ON CONFLICT. With no options, uses ON CONFLICT DO NOTHING.  Options:
+      # :conflict_where :: The index filter, when using a partial index to determine uniqueness.
       # :constraint :: An explicit constraint name, has precendence over :target.
       # :target :: The column name or expression to handle uniqueness violations on.
       # :update :: A hash of columns and values to set.  Uses ON CONFLICT DO UPDATE.
@@ -1421,6 +1448,10 @@ module Sequel
       #   DB[:table].insert_conflict(:target=>:a).insert(:a=>1, :b=>2)
       #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
       #   # ON CONFLICT (a) DO NOTHING
+      #
+      #   DB[:table].insert_conflict(:target=>:a, :conflict_where=>{:c=>true}).insert(:a=>1, :b=>2)
+      #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
+      #   # ON CONFLICT (a) WHERE (c IS TRUE) DO NOTHING
       #   
       #   DB[:table].insert_conflict(:target=>:a, :update=>{:b=>:excluded__b}).insert(:a=>1, :b=>2)
       #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
@@ -1642,19 +1673,22 @@ module Sequel
           elsif target = opts[:target]
             sql << ' '
             identifier_append(sql, Array(target))
+            if conflict_where = opts[:conflict_where]
+              sql << " WHERE "
+              literal_append(sql, conflict_where)
+            end
           end
 
           if values = opts[:update]
             sql << " DO UPDATE SET "
             update_sql_values_hash(sql, values)
-            if where = opts[:update_where]
+            if update_where = opts[:update_where]
               sql << " WHERE "
-              literal_append(sql, where)
+              literal_append(sql, update_where)
             end
           else
             sql << " DO NOTHING"
           end
-
         end
       end
 
@@ -1720,6 +1754,11 @@ module Sequel
         :values
       end
 
+      # Dataset options that do not affect the generated SQL.
+      def non_sql_options
+        NON_SQL_OPTIONS
+      end
+
       # PostgreSQL requires parentheses around compound datasets if they use
       # CTEs, and using them in other places doesn't hurt.
       def compound_dataset_sql_append(sql, ds)

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

@@ -57,8 +57,8 @@ module Sequel
         im = input_identifier_meth(opts[:dataset])
         metadata_dataset.
          from{sa_describe_query("select * from #{im.call(table)}").as(:a)}.
-         join(:syscolumn___b, :table_id=>:base_table_id, :column_id=>:base_column_id).
-         order(:a__column_number).
+         join(Sequel[:syscolumn].as(:b), :table_id=>:base_table_id, :column_id=>:base_column_id).
+         order{a[:column_number]}.
          map do |row|
           auto_increment = row.delete(:is_autoincrement)
           row[:auto_increment] = auto_increment == 1 || auto_increment == true
@@ -80,11 +80,15 @@ module Sequel
         im = input_identifier_meth
         indexes = {}
         metadata_dataset.
-         from(:dbo__sysobjects___z).
-         select(:z__name___table_name, :i__name___index_name, :si__indextype___type, :si__colnames___columns).
-         join(:dbo__sysindexes___i, :id___i=> :id___z).
-         join(:sys__sysindexes___si, :iname=> :name___i).
-         where(:z__type => 'U', :table_name=>im.call(table)).
+         from(Sequel[:dbo][:sysobjects].as(:z)).
+         select{[
+           z[:name].as(:table_name),
+           i[:name].as(:index_name),
+           si[:indextype].as(:type),
+           si[:colnames].as(:columns)]}.
+         join(Sequel[:dbo][:sysindexes].as(:i), :id=>:id).
+         join(Sequel[:sys][:sysindexes].as(:si), :iname=> :name).
+         where{{z[:type] => 'U', :table_name=>im.call(table)}}.
          each do |r|
           indexes[m.call(r[:index_name])] =
             {:unique=>(r[:type].downcase=='unique'),
@@ -98,11 +102,16 @@ module Sequel
         im = input_identifier_meth
         fk_indexes = {}
         metadata_dataset.
-         from(:sys__sysforeignkey___fk).
-         select(:fk__role___name, :fks__columns___column_map, :si__indextype___type, :si__colnames___columns, :fks__primary_tname___table_name).
-         join(:sys__sysforeignkeys___fks, :role => :role).
-         join_table(:inner, :sys__sysindexes___si, [:iname=> :fk__role], {:implicit_qualifier => :fk}).
-         where(:fks__foreign_tname=>im.call(table)).
+         from{sys[:sysforeignkey].as(:fk)}.
+         select{[
+           fk[:role].as(:name),
+           fks[:columns].as(:column_map),
+           si[:indextype].as(:type),
+           si[:colnames].as(:columns),
+           fks[:primary_tname].as(:table_name)]}.
+         join(Sequel[:sys][:sysforeignkeys].as(:fks), :role => :role).
+         join(Sequel[:sys][:sysindexes].as(:si), [:iname=> Sequel[:fk][:role]], {:implicit_qualifier => :fk}).
+         where{{fks[:foreign_tname]=>im.call(table)}}.
          each do |r|
           unless r[:type].downcase == 'primary key'
             fk_indexes[r[:name]] =
@@ -142,6 +151,11 @@ module Sequel
         AUTO_INCREMENT
       end
       
+      # Sybase does not allow adding primary key constraints to NULLable columns.
+      def can_add_primary_key_constraint_on_nullable_columns?
+        false
+      end
+
       # SQL fragment for marking a table as temporary
       def temporary_table_sql
         TEMPORARY
@@ -235,9 +249,9 @@ module Sequel
       def tables_and_views(type, opts=OPTS)
         m = output_identifier_meth
         metadata_dataset.
-          from(:sysobjects___a).
-          where(:a__type=>type).
-          select_map(:a__name).
+          from{sysobjects.as(:a)}.
+          where{{a[:type]=>type}}.
+          select_map{a[:name]}.
           map{|n| m.call(n)}
       end
       

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

@@ -314,17 +314,17 @@ module Sequel
         end
       end
 
+      # SQLite allows adding primary key constraints on NULLABLE columns, but then
+      # does not enforce NOT NULL for such columns, so force setting the columns NOT NULL.
+      def can_add_primary_key_constraint_on_nullable_columns?
+        false
+      end
+
       # Surround default with parens to appease SQLite
       def column_definition_default_sql(sql, column)
         sql << " DEFAULT (#{literal(column[:default])})" if column.include?(:default)
       end
     
-      # Add null/not null SQL fragment to column creation SQL.
-      def column_definition_null_sql(sql, column)
-        column = column.merge(:null=>false) if column[:primary_key]
-        super(sql, column)
-      end
-    
       # Array of PRAGMA SQL statements based on the Database options that should be applied to
       # new connections.
       def connection_pragmas

data/lib/sequel/core.rb

@@ -24,6 +24,7 @@
 module Sequel
   @convert_two_digit_years = true
   @datetime_class = Time
+  @split_symbols = true
 
   # Whether Sequel is being run in single threaded mode
   @single_threaded = false
@@ -234,28 +235,78 @@ module Sequel
   COLUMN_REF_RE3 = /\A((?:(?!__).)+)__(.+)\z/.freeze
   SPLIT_SYMBOL_CACHE = {}
 
-  # Splits the symbol into three parts.  Each part will
-  # either be a string or nil.
+  # Splits the symbol into three parts, if symbol splitting is enabled.
+  # Each part will either be a string or nil. If symbol splitting
+  # is disabled, returns an array with the first and third parts
+  # being nil, and the second part beind a string version of the symbol.
   #
   # For columns, these parts are the table, column, and alias.
   # For tables, these parts are the schema, table, and alias.
   def self.split_symbol(sym)
     unless v = Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym]}
-      v = case s = sym.to_s
-      when COLUMN_REF_RE1
-        [$1.freeze, $2.freeze, $3.freeze].freeze
-      when COLUMN_REF_RE2
-        [nil, $1.freeze, $2.freeze].freeze
-      when COLUMN_REF_RE3
-        [$1.freeze, $2.freeze, nil].freeze
+      if split_symbols?
+        v = case s = sym.to_s
+        when COLUMN_REF_RE1
+          [$1.freeze, $2.freeze, $3.freeze].freeze
+        when COLUMN_REF_RE2
+          [nil, $1.freeze, $2.freeze].freeze
+        when COLUMN_REF_RE3
+          [$1.freeze, $2.freeze, nil].freeze
+        else
+          [nil, s.freeze, nil].freeze
+        end
       else
-        [nil, s.freeze, nil].freeze
+        v = [nil,sym.to_s.freeze,nil].freeze
       end
       Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym] = v}
     end
     v
   end
 
+  # Sequel by default will split symbols, treating:
+  #
+  #   :table__column         # table.column
+  #   :column___alias        # column AS alias
+  #   :table__column___alias # table.column AS alias
+  #
+  # This can cause problems if any identifiers in the database use a double
+  # or triple underscore.  When Sequel was first created, using symbols with
+  # double or triple underscores was the only way to represent qualified or
+  # aliased identifiers.  Sequel now offers many ways to create qualified and
+  # aliased identifiers, so there is less of a need for this now.  This allows
+  # you to turn off symbol splitting, potentially avoiding problems if you
+  # have identifiers that use double underscores:
+  #
+  #   Sequel.split_symbols = false
+  #
+  # Note that Sequel::Database instances do their own caching of literalized
+  # symbols, and changing this setting does not affect those caches.  It is
+  # recommended that if you want to change this setting, you do so directly
+  # after requiring Sequel, before creating any Sequel::Database instances.
+  #
+  # Also note that disabling symbol splitting will also disable the handling
+  # of double underscores in virtual row methods, causing such methods to
+  # yield regular identifers instead of qualified identifiers. To make sure
+  # the code works when splitting symbols is both disabled and enabled, you
+  # can use Sequel::SQL::Identifier#[].
+  #
+  #   # Sequel.split_symbols = true
+  #   Sequel.expr{table__column}  # table.column
+  #   Sequel.expr{table[:column]} # table.column
+  #
+  #   # Sequel.split_symbols = false
+  #   Sequel.expr{table__column}  # table__column
+  #   Sequel.expr{table[:column]} # table.column
+  def self.split_symbols=(v)
+    Sequel.synchronize{SPLIT_SYMBOL_CACHE.clear}
+    @split_symbols = v
+  end
+
+  # Whether Sequel currently splits symbols into qualified/aliased identifiers.
+  def self.split_symbols?
+    @split_symbols
+  end
+
   # Converts the given +string+ into a +Date+ object.
   #
   #   Sequel.string_to_date('2010-09-10') # Date.civil(2010, 09, 10)