sequel 4.39.0 → 4.40.0

data/doc/security.rdoc

@@ -242,7 +242,8 @@ derived from user input unless absolutely necessary.
 
 Sequel also allows you to create identifiers using
 Sequel.identifier[rdoc-ref:Sequel::SQL::Builders#identifier] for plain identifiers,
-Sequel.qualify[rdoc-ref:Sequel::SQL::Builders#qualify] for qualified identifiers, and
+Sequel.qualify[rdoc-ref:Sequel::SQL::Builders#qualify] and
+Sequel::SQL::Indentifier#[][rdoc-ref:Sequel::SQL::QualifyingMethods#[]] for qualified identifiers, and
 Sequel.as[rdoc-ref:Sequel::SQL::Builders#as] for aliased expressions.  So if you
 pass any of those values derived from user input, you are dealing with the same scenario.
 

data/doc/sql.rdoc

@@ -125,6 +125,8 @@ A plain symbol is usually treated as an unqualified identifier.  However, if you
 
   :table__column # "table"."column"
 
+This works by default, but it is possible to turn off by setting <tt>Sequel.split_symbols = false</tt>.
+
 Note that you can't use a period to separate them:
 
   :table.column # calls the column method on the symbol
@@ -133,14 +135,21 @@ Also note that specifying the period inside the symbol doesn't work if you are q
 
   :"table.column" # "table.column"
 
-The other way to qualify an identifier is to use the <tt>Sequel.qualify</tt> with the table and column symbols:
+A couple other ways two create a qualified identifier are to use <tt>Sequel.[]</tt> to create an identifier,
+and call <tt>[]</tt> or +qualify+ on that, or to use the <tt>Sequel.qualify</tt> with the table and column symbols:
 
+  Sequel[:table][:column]         # "table"."column"
+  Sequel[:column].qualify(:table) # "table"."column"
   Sequel.qualify(:table, :column) # "table"."column"
 
 Another way to generate identifiers is to use Sequel's {virtual row support}[rdoc-ref:doc/virtual_rows.rdoc]:
 
   DB[:albums].select{name} # SELECT "name" FROM "albums"
-  DB[:albums].select{albums__name} # SELECT "albums"."name" FROM "albums"
+  DB[:albums].select{albums[:name]} # SELECT "albums"."name" FROM "albums"
+
+You can also use the symbol_aref extension for creating qualified identifiers:
+
+  :table[:column] # "table"."column"
 
 === Numbers
 
@@ -173,10 +182,17 @@ You can combine this with implicit qualification:
 
   :table__column___alias # "table"."column" AS "alias"
 
+As with creating qualified identifiers via a double underscore, This works by default, but it is possible to turn off by setting <tt>Sequel.split_symbols = false</tt>.
+
 You can also use the <tt>Sequel.as</tt> method to create an alias, and the +as+ method on most Sequel-specific expression objects:
 
-  Sequel.as(:column, :alias) # "column" AS "alias"
-  Sequel.qualify(:table, :column).as(:alias) # "table"."column" AS "alias"
+  Sequel.as(:column, :alias)                 # "column" AS "alias"
+  Sequel[:column].as(:alias)                 # "column" AS "alias"
+  Sequel[:table][:column].as(:alias)         # "table"."column" AS "alias"
+
+You can also use the symbol_as extension for creating aliased identifiers:
+
+  :column.as(:alias) # "column" AS "alias"
 
 If you want to use a derived column list, you can provide an array of column aliases:
 
@@ -231,10 +247,10 @@ If the database supports window functions, Sequel can handle them by calling the
 
 If the database supports schema qualified functions, Sequel can handle them by calling the function method on a QuailfiedIdentifier:
 
-  DB[:albums].select{schema__function.function}
+  DB[:albums].select{schema[:function].function}
   # SELECT schema.function() FROM albums
   
-  DB[:albums].select{schema__function.function(col, 2, "a")}
+  DB[:albums].select{schema[:function].function(col, 2, "a")}
   # SELECT schema.function(col, 2, 'a') FROM albums
 
 === Portable/Emulated Functions
@@ -347,8 +363,8 @@ produces <tt>(column != 1)</tt> instead of <tt>NOT (column = 1)</tt>.
 
 Sequel defines the inequality operators directly on most Sequel-specific expression objects:
 
-  Sequel.qualify(:table, :column) > 1 # ("table"."column" > 1)
-  Sequel.qualify(:table, :column) < 1 # ("table"."column" < 1)
+  Sequel[:table][:column] > 1 # ("table"."column" > 1)
+  Sequel[:table][:column] < 1 # ("table"."column" < 1)
   Sequel.function(:func) >= 1 # (func() >= 1)
   Sequel.function(:func, :column) <= 1 # (func("column") <= 1)
 
@@ -365,23 +381,23 @@ A common use of virtual rows is to handle inequality operators:
 The standard mathematical operates are defined on most Sequel-specific expression objects:
 
   Sequel[:column] + 1 # "column" + 1
-  Sequel[:table__column] - 1 # "table"."column" - 1
-  Sequel.qualify(:table, :column) * 1 # "table"."column" * 1
+  Sequel[:table][:column] - 1 # "table"."column" - 1
+  Sequel[:table][:column] * 1 # "table"."column" * 1
   Sequel[:column] / 1 # "column" / 1
   Sequel[:column] ** 1 # power("column", 1)
 
 You can also call the operator methods directly on the Sequel module:
 
   Sequel.+(:column, 1) # "column" + 1
-  Sequel.-(:table__column, 1) # "table"."column" - 1
-  Sequel.*(Sequel.qualify(:table, :column), 1) # "table"."column" * 1
+  Sequel.-(Sequel[:table][:column], 1) # "table"."column" - 1
+  Sequel.*(Sequel[:table][:column], 1) # "table"."column" * 1
   Sequel./(:column, 1) # "column" / 1
   Sequel.**(:column, 1) # power("column", 1)
 
 Note that since Sequel implements support for ruby's coercion protocol, the following also works:
 
   1 + Sequel[:column]
-  1 - Sequel.qualify(:table__column)
+  1 - Sequel[:table][:column]
 
 === Boolean Operators (AND OR)
 
@@ -432,7 +448,7 @@ Casting in Sequel is done with the +cast+ method, which is available on most of
 
   Sequel[:name].cast(:text) # CAST("name" AS text)
   Sequel['1'].cast(:integer) # CAST('1' AS integer)
-  Sequel.qualify(:table, :column).cast(:date) # CAST("table"."column" AS date)
+  Sequel[:table][:column].cast(:date) # CAST("table"."column" AS date)
 
 You can also use the <tt>Sequel.cast</tt> method:
 
@@ -516,17 +532,17 @@ Note that using +ilike+ with a regular expression will always make the regexp ca
 Sequel supports specifying ascending or descending order using the +asc+ and +desc+ method on most Sequel-specific expression objects:
 
   Sequel[:column].asc # "column" ASC
-  Sequel[:column].qualify(:table).desc # "table"."column" DESC
+  Sequel[:table][:column].desc # "table"."column" DESC
 
 You can also use the <tt>Sequel.asc</tt> and <tt>Sequel.desc</tt> methods:
 
   Sequel.asc(:column) # "column" ASC
-  Sequel.desc(Sequel[:column].qualify(:table)) # "table"."column" DESC
+  Sequel.desc(Sequel[:table][:column]) # "table"."column" DESC
 
 On some databases, you can specify null ordering:
 
   Sequel.asc(:column, :nulls=>:first) # "column" ASC NULLS FIRST
-  Sequel.desc(Sequel[:column].qualify(:table), :nulls=>:last) # "table"."column" DESC NULLS LAST
+  Sequel.desc(Sequel[:table][:column], :nulls=>:last) # "table"."column" DESC NULLS LAST
 
 === All Columns (.*)
 
@@ -556,7 +572,7 @@ If you provide a 3rd argument to <tt>Sequel.case</tt>, it goes between CASE and
 Sequel supports SQL subscripts using the +sql_subscript+ method on most Sequel-specific expression objects:
 
   Sequel[:column].sql_subscript(3) # column[3]
-  Sequel[:column].qualify(:table).sql_subscript(3) # table.column[3]
+  Sequel[:table][:column].sql_subscript(3) # table.column[3]
 
 You can also use the <tt>Sequel.subscript</tt> method:
 

data/doc/testing.rdoc

@@ -159,5 +159,6 @@ SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
 SEQUEL_NO_AUTO_LITERAL_STRINGS :: Use the no_auto_string_literals extension when running the specs
 SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs
 SEQUEL_NO_CHECK_SQLS :: Don't check for specific SQL syntax when running the specs
+SEQUEL_NO_SPLIT_SYMBOLS :: Turn off symbol splitting when running the specs
 SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
 SKIPPED_TEST_WARN :: Warn when skipping any tests because libraries aren't available

data/doc/virtual_rows.rdoc

@@ -121,8 +121,17 @@ in the method name:
   # WHERE table.column > 1
 
 Using the double underscore for SQL::QualifiedIdentifiers was done to make
-usage very similar to using symbols, which also translate the double underscore
-into a qualified column.
+usage very similar to using symbols, which by default also translate the
+double underscore into a qualified column.
+
+Note that when <tt>Sequel.split_symbols = false</tt> is used, then virtual
+rows do not split symbols either.  If you need to create qualified identifers
+when disabling symbol splitting, it is easy to do by calling #[] on the
+SQL::Identifiers returned by regular methods calls:
+
+  ds.where{|o| o.table[:column] > 1}
+  ds.where{table[:column] > 1}
+  # WHERE table.column > 1
 
 == SQL::Functions - SQL function calls
 

data/lib/sequel/adapters/jdbc/derby.rb

@@ -82,9 +82,15 @@ module Sequel
           end
         end
 
+        # Derby does not allow adding primary key constraints to NULLable columns.
+        def can_add_primary_key_constraint_on_nullable_columns?
+          false
+        end
+
         # Derby doesn't allow specifying NULL for columns, only NOT NULL.
         def column_definition_null_sql(sql, column)
-          sql << " NOT NULL" if column.fetch(:null, column[:allow_null]) == false
+          null = column.fetch(:null, column[:allow_null])
+          sql << " NOT NULL" if null == false || (null.nil? && column[:primary_key])
         end
     
         # Add NOT LOGGED for temporary tables to improve performance.

data/lib/sequel/adapters/jdbc/h2.rb

@@ -58,6 +58,11 @@ module Sequel
         
         private
         
+        # H2 does not allow adding primary key constraints to NULLable columns.
+        def can_add_primary_key_constraint_on_nullable_columns?
+          false
+        end
+
         # If the :prepare option is given and we aren't in a savepoint,
         # prepare the transaction for a two-phase commit.
         def commit_transaction(conn, opts=OPTS)
@@ -73,12 +78,21 @@ module Sequel
           case op[:op]
           when :add_column
             if (pk = op.delete(:primary_key)) || (ref = op.delete(:table))
+              if pk
+                op[:null] = false
+              end
+
               sqls = [super(table, op)]
-              sqls << "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})" if pk && op[:type] != :identity
+
+              if pk && op[:type] != :identity
+                sqls << "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})"
+              end
+
               if ref
                 op[:table] = ref
                 sqls << "ALTER TABLE #{quote_schema_table(table)} ADD FOREIGN KEY (#{quote_identifier(op[:name])}) #{column_references_sql(op)}"
               end
+
               sqls
             else
               super(table, op)

data/lib/sequel/adapters/oracle.rb

@@ -264,11 +264,15 @@ module Sequel
         im = input_identifier_meth(ds)
 
         # Primary Keys
-        ds = metadata_dataset.from(:all_constraints___cons, :all_cons_columns___cols).
-          where(:cols__table_name=>im.call(table), :cons__constraint_type=>'P',
-                :cons__constraint_name=>:cols__constraint_name, :cons__owner=>:cols__owner)
-        ds = ds.where(:cons__owner=>im.call(schema)) if schema
-        pks = ds.select_map(:cols__column_name)
+        ds = metadata_dataset.
+          from{[all_constraints.as(:cons), all_cons_columns.as(:cols)]}.
+          where{{
+           cols[:table_name]=>im.call(table),
+           cons[:constraint_type]=>'P',
+           cons[:constraint_name]=>cols[:constraint_name],
+           cons[:owner]=>cols[:owner]}}
+        ds = ds.where{{cons[:owner]=>im.call(schema)}} if schema
+        pks = ds.select_map{cols[:column_name]}
 
         # Default values
         defaults = begin

data/lib/sequel/adapters/postgres.rb

@@ -94,7 +94,6 @@ rescue LoadError => e
 end
 
 module Sequel
-  Dataset::NON_SQL_OPTIONS << :cursor
   module Postgres
     CONVERTED_EXCEPTIONS << PGError
 

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

@@ -23,11 +23,11 @@ module Sequel
         m2 = input_identifier_meth
         indexes = {}
         metadata_dataset.
-          from(:db_index___i).
-          join(:db_index_key___k, :index_name=>:index_name, :class_name=>:class_name).
-          where(:i__class_name=>m2.call(table), :is_primary_key=>'NO').
-          order(:k__key_order).
-          select(:i__index_name, :k__key_attr_name___column, :is_unique).
+          from{db_index[:i]}.
+          join(Sequel[:db_index_key].as(:k), :index_name=>:index_name, :class_name=>:class_name).
+          where{{i[:class_name]=>m2.call(table), :is_primary_key=>'NO'}}.
+          order{k[:key_order]}.
+          select{[i[:index_name], k[:key_attr_name].as(:column), :is_unique]}.
           each do |row|
             index = indexes[m.call(row[:index_name])] ||= {:columns=>[], :unique=>row[:is_unique]=='YES'}
             index[:columns] << m.call(row[:column])
@@ -44,18 +44,18 @@ module Sequel
         m2 = input_identifier_meth(opts[:dataset])
 
         pks = metadata_dataset.
-          from(:db_index___i).
-          join(:db_index_key___k, :index_name=>:index_name, :class_name=>:class_name).
-          where(:i__class_name=>m2.call(table_name), :is_primary_key=>'YES').
-          order(:k__key_order).
-          select_map(:k__key_attr_name).
+          from{db_index[:i]}.
+          join(Sequel[:db_index_key].as(:k), :index_name=>:index_name, :class_name=>:class_name).
+          where{{i[:class_name]=>m2.call(table_name), :is_primary_key=>'YES'}}.
+          order{k[:key_order]}.
+          select_map{k[:key_attr_name]}.
           map{|c| m.call(c)}
 
         metadata_dataset.
           from(:db_attribute).
           where(:class_name=>m2.call(table_name)).
           order(:def_order).
-          select(:attr_name, :data_type___db_type, :default_value___default, :is_nullable___allow_null, :prec).
+          select{[:attr_name, data_type.as(:db_type), default_value.as(:default), is_nullable.as(:allow_null), :prec]}.
           map do |row|
             name = m.call(row.delete(:attr_name))
             row[:allow_null] = row[:allow_null] == 'YES'

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

@@ -76,7 +76,7 @@ module Sequel
         m = output_identifier_meth
         indexes = {}
         metadata_dataset.
-         from(:syscat__indexes).
+         from(Sequel[:syscat][:indexes]).
          select(:indname, :uniquerule, :colnames).
          where(:tabname=>input_identifier_meth.call(table), :system_required=>0).
          each do |r|
@@ -160,13 +160,9 @@ module Sequel
         AUTOINCREMENT
       end
 
-      # Add null/not null SQL fragment to column creation SQL.
-      def column_definition_null_sql(sql, column)
-        null = column.fetch(:null, column[:allow_null]) 
-        null = false  if column[:primary_key]
-
-        sql << NOT_NULL if null == false
-        sql << NULL if null == true
+      # DB2 does not allow adding primary key constraints to NULLable columns.
+      def can_add_primary_key_constraint_on_nullable_columns?
+        false
       end
 
       # Supply columns with NOT NULL if they are part of a composite

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

@@ -3,7 +3,6 @@
 Sequel.require %w'emulate_offset_with_row_number split_alter_table', 'adapters/utils'
 
 module Sequel
-  Dataset::NON_SQL_OPTIONS << :disable_insert_output
   module MSSQL
     Sequel::Database.set_shared_adapter_scheme(:mssql, self)
 
@@ -141,20 +140,22 @@ module Sequel
         schema, table = schema_and_table(table)
         current_schema = m.call(get(Sequel.function('schema_name')))
         fk_action_map = FOREIGN_KEY_ACTION_MAP
+        fk = Sequel[:fk]
+        fkc = Sequel[:fkc]
         ds = metadata_dataset.from(Sequel.lit('[sys].[foreign_keys]').as(:fk)).
           join(Sequel.lit('[sys].[foreign_key_columns]').as(:fkc), :constraint_object_id => :object_id).
-          join(Sequel.lit('[sys].[all_columns]').as(:pc), :object_id => :fkc__parent_object_id,     :column_id => :fkc__parent_column_id).
-          join(Sequel.lit('[sys].[all_columns]').as(:rc), :object_id => :fkc__referenced_object_id, :column_id => :fkc__referenced_column_id).
-          where{{object_schema_name(:fk__parent_object_id) => im.call(schema || current_schema)}}.
-          where{{object_name(:fk__parent_object_id) => im.call(table)}}.
-          select{[:fk__name, 
-                  :fk__delete_referential_action, 
-                  :fk__update_referential_action, 
-                  :pc__name___column, 
-                  :rc__name___referenced_column, 
-                  object_schema_name(:fk__referenced_object_id).as(:schema), 
-                  object_name(:fk__referenced_object_id).as(:table)]}.
-          order(:fk__name, :fkc__constraint_column_id)
+          join(Sequel.lit('[sys].[all_columns]').as(:pc), :object_id => fkc[:parent_object_id],     :column_id => fkc[:parent_column_id]).
+          join(Sequel.lit('[sys].[all_columns]').as(:rc), :object_id => fkc[:referenced_object_id], :column_id => fkc[:referenced_column_id]).
+          where{{object_schema_name(fk[:parent_object_id]) => im.call(schema || current_schema)}}.
+          where{{object_name(fk[:parent_object_id]) => im.call(table)}}.
+          select{[fk[:name], 
+                  fk[:delete_referential_action], 
+                  fk[:update_referential_action], 
+                  pc[:name].as(:column), 
+                  rc[:name].as(:referenced_column), 
+                  object_schema_name(fk[:referenced_object_id]).as(:schema), 
+                  object_name(fk[:referenced_object_id]).as(:table)]}.
+          order(fk[:name], fkc[:constraint_column_id])
         h = {}
         ds.each do |row|
           if r = h[row[:name]]
@@ -179,17 +180,18 @@ module Sequel
         m = output_identifier_meth
         im = input_identifier_meth
         indexes = {}
+        i = Sequel[:i]
         ds = metadata_dataset.from(Sequel.lit('[sys].[tables]').as(:t)).
          join(Sequel.lit('[sys].[indexes]').as(:i), :object_id=>:object_id).
          join(Sequel.lit('[sys].[index_columns]').as(:ic), :object_id=>:object_id, :index_id=>:index_id).
          join(Sequel.lit('[sys].[columns]').as(:c), :object_id=>:object_id, :column_id=>:column_id).
-         select(:i__name, :i__is_unique, :c__name___column).
-         where{{t__name=>im.call(table)}}.
-         where(:i__is_primary_key=>0, :i__is_disabled=>0).
-         order(:i__name, :ic__index_column_id)
+         select(i[:name], i[:is_unique], Sequel[:c][:name].as(:column)).
+         where{{t[:name]=>im.call(table)}}.
+         where(i[:is_primary_key]=>0, i[:is_disabled]=>0).
+         order(i[:name], Sequel[:ic][:index_column_id])
 
         if supports_partial_indexes?
-          ds = ds.where(:i__has_filter=>0)
+          ds = ds.where(i[:has_filter]=>0)
         end
 
         ds.each do |r|
@@ -313,6 +315,11 @@ module Sequel
         SQL_BEGIN
       end
 
+      # MSSQL does not allow adding primary key constraints to NULLable columns.
+      def can_add_primary_key_constraint_on_nullable_columns?
+        false
+      end
+
       # Handle MSSQL specific default format.
       def column_schema_normalize_default(default, type)
         if m = MSSQL_DEFAULT_RE.match(default)
@@ -365,7 +372,7 @@ module Sequel
       def default_constraint_name(table, column_name)
         if server_version >= 9000000
           table_name = schema_and_table(table).compact.join('.')
-          self[:sys__default_constraints].
+          self[Sequel[:sys][:default_constraints]].
             where{{:parent_object_id => Sequel::SQL::Function.new(:object_id, table_name), col_name(:parent_object_id, :parent_column_id) => column_name.to_s}}.
             get(:name)
         end
@@ -390,7 +397,7 @@ module Sequel
       # Backbone of the tables and views support.
       def information_schema_tables(type, opts)
         m = output_identifier_meth
-        metadata_dataset.from(:information_schema__tables___t).
+        metadata_dataset.from(Sequel[:information_schema][:tables].as(:t)).
           select(:table_name).
           filter(:table_type=>type, :table_schema=>(opts[:schema]||'dbo').to_s).
           map{|x| m.call(x[:table_name])}
@@ -453,17 +460,17 @@ module Sequel
           get(:indid)
         pk_cols = metadata_dataset.from(sys_qual.call(Sequel.lit('sysindexkeys')).as(:sik)).
           join(sys_qual.call(Sequel.lit('syscolumns')).as(:sc), :id=>:id, :colid=>:colid).
-          where(:sik__id=>table_id, :sik__indid=>pk_index_id).
-          select_order_map(:sc__name)
+          where{{sik[:id]=>table_id, sik[:indid]=>pk_index_id}}.
+          select_order_map{sc[:name]}
 
-        ds = metadata_dataset.from(inf_sch_qual.call(:information_schema__tables).as(:t)).
-         join(inf_sch_qual.call(:information_schema__columns).as(:c), :table_catalog=>:table_catalog,
+        ds = metadata_dataset.from(inf_sch_qual.call(Sequel[:information_schema][:tables]).as(:t)).
+         join(inf_sch_qual.call(Sequel[:information_schema][:columns]).as(:c), :table_catalog=>:table_catalog,
               :table_schema => :table_schema, :table_name => :table_name).
-         select(:column_name___column, :data_type___db_type, :character_maximum_length___max_chars, :column_default___default, :is_nullable___allow_null, :numeric_precision___column_size, :numeric_scale___scale).
-         filter(:c__table_name=>tn)
+         select{[column_name.as(:column), data_type.as(:db_type), character_maximum_length.as(:max_chars), column_default.as(:default), is_nullable.as(:allow_null), numeric_precision.as(:column_size), numeric_scale.as(:scale)]}.
+         where{{c[:table_name]=>tn}}
 
         if schema = opts[:schema]
-          ds.filter!(:c__table_schema=>schema)
+          ds = ds.where{{c[:table_schema]=>schema}}
         end
 
         ds.map do |row|
@@ -567,12 +574,13 @@ module Sequel
       ROWS_ONLY = " ROWS ONLY".freeze
       FETCH_NEXT = " FETCH NEXT ".freeze
 
+      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:disable_insert_output]).freeze
+
       Dataset.def_mutation_method(:disable_insert_output, :output, :module=>self)
       Dataset.def_sql_method(self, :delete, %w'with delete from output from2 where')
       Dataset.def_sql_method(self, :insert, %w'with insert into columns output values')
       Dataset.def_sql_method(self, :update, [['if is_2005_or_later?', %w'with update limit table set output from where'], ['else', %w'update table set output from where']])
 
-
       # Allow overriding of the mssql_unicode_strings option at the dataset level.
       attr_writer :mssql_unicode_strings
 
@@ -953,6 +961,11 @@ module Sequel
         is_2008_or_later? ? :values : :union
       end
 
+      # Dataset options that do not affect the generated SQL.
+      def non_sql_options
+        NON_SQL_OPTIONS
+      end
+
       def select_into_sql(sql)
         if i = @opts[:into]
           sql << INTO