sequel 3.42.0 → 3.43.0

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

@@ -314,15 +314,19 @@ module Sequel
         m2 = input_identifier_meth(opts[:dataset])
         tn = m2.call(table_name.to_s)
         table_id = get{object_id(tn)}
-        pk_index_id = metadata_dataset.from(:sysindexes).
+        info_sch_sch = opts[:information_schema_schema]
+        inf_sch_qual = lambda{|s| info_sch_sch ? Sequel.qualify(info_sch_sch, s) : Sequel.expr(s)}
+        sys_qual = lambda{|s| info_sch_sch ? Sequel.qualify(info_sch_sch, Sequel.qualify(Sequel.lit(''), s)) : Sequel.expr(s)}
+
+        pk_index_id = metadata_dataset.from(sys_qual.call(:sysindexes)).
           where(:id=>table_id, :indid=>1..254){{(status & 2048)=>2048}}.
           get(:indid)
-        pk_cols = metadata_dataset.from(:sysindexkeys___sik).
-          join(:syscolumns___sc, :id=>:id, :colid=>:colid).
+        pk_cols = metadata_dataset.from(sys_qual.call(:sysindexkeys).as(:sik)).
+          join(sys_qual.call(:syscolumns).as(:sc), :id=>:id, :colid=>:colid).
           where(:sik__id=>table_id, :sik__indid=>pk_index_id).
           select_order_map(:sc__name)
-        ds = metadata_dataset.from(:information_schema__tables___t).
-         join(:information_schema__columns___c, :table_catalog=>:table_catalog,
+        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,
               :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)

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

@@ -429,6 +429,8 @@ module Sequel
         pk = SQL::Identifier.new(primary_key(table))
         db = self
         seq_ds = db.from(LiteralString.new(seq))
+        s, t = schema_and_table(table)
+        table = Sequel.qualify(s, t) if s
         get{setval(seq, db[table].select{coalesce(max(pk)+seq_ds.select{:increment_by}, seq_ds.select(:min_value))}, false)}
       end
 

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

@@ -19,7 +19,7 @@ module Sequel
 
         # Consider tinyint(1) columns as boolean.
         def schema_column_type(db_type)
-          db_type == 'tinyint(1)' ? :boolean : super
+          db_type =~ /\Atinyint\(1\)/ ? :boolean : super
         end
       
         # Apply the connectiong setting SQLs for every new connection.

data/lib/sequel/core.rb

@@ -390,7 +390,7 @@ module Sequel
     vr = SQL::VirtualRow.new
     case block.arity
     when -1, 0
-      vr.instance_eval(&block)
+      vr.instance_exec(&block)
     else
       block.call(vr)
     end  
@@ -422,7 +422,7 @@ module Sequel
 
   private_class_method :adapter_method, :def_adapter_method
   
-  require(%w"metaprogramming sql connection_pool exceptions dataset database timezones ast_transformer version")
+  require(%w"sql connection_pool exceptions dataset database timezones ast_transformer version")
   if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS')
     extension(:core_extensions)
   end

data/lib/sequel/database.rb

@@ -13,8 +13,6 @@ module Sequel
   # The Database class is meant to be subclassed by database adapters in order
   # to provide the functionality needed for executing queries.
   class Database
-    extend Metaprogramming
-    include Metaprogramming
   end
 
   require(%w"connecting dataset dataset_defaults logging misc query schema_generator schema_methods", 'database')

data/lib/sequel/database/query.rb

@@ -180,19 +180,34 @@ module Sequel
       raise(Error, 'schema parsing is not implemented on this database') unless respond_to?(:schema_parse_table, true)
 
       opts = opts.dup
-      if table.is_a?(Dataset)
+      tab = if table.is_a?(Dataset)
         o = table.opts
         from = o[:from]
         raise(Error, "can only parse the schema for a dataset with a single from table") unless from && from.length == 1 && !o.include?(:join) && !o.include?(:sql)
-        tab = table.first_source_table
-        sch, table_name = schema_and_table(tab)
+        table.first_source_table
+      else
+        table
+      end
+
+      qualifiers = split_qualifiers(tab)
+      table_name = qualifiers.pop
+      sch = qualifiers.pop
+      information_schema_schema = case qualifiers.length
+      when 1
+        Sequel.identifier(*qualifiers)
+      when 2
+        Sequel.qualify(*qualifiers)
+      end
+
+      if table.is_a?(Dataset)
         quoted_name = table.literal(tab)
         opts[:dataset] = table
       else
-        sch, table_name = schema_and_table(table)
-        quoted_name = quote_schema_table(table)
+        quoted_name = schema_utility_dataset.literal(table)
       end
+
       opts[:schema] = sch if sch && !opts.include?(:schema)
+      opts[:information_schema_schema] = information_schema_schema if information_schema_schema && !opts.include?(:information_schema_schema)
 
       Sequel.synchronize{@schemas.delete(quoted_name)} if opts[:reload]
       if v = Sequel.synchronize{@schemas[quoted_name]}

data/lib/sequel/database/schema_generator.rb

@@ -199,6 +199,11 @@ module Sequel
       def method_missing(type, name = nil, opts = {})
         name ? column(name, type, opts) : super
       end
+
+      # This object responds to all methods.
+      def respond_to_missing?(meth, include_private)
+        true
+      end
       
       # Adds an autoincrementing primary key column or a primary key constraint to the DDL.
       # To create a constraint, the first argument should be an array of column symbols

data/lib/sequel/database/schema_methods.rb

@@ -715,6 +715,11 @@ module Sequel
       @schema_utility_dataset ||= dataset
     end
 
+    # Split the schema information from the table
+    def split_qualifiers(table_name)
+      schema_utility_dataset.split_qualifiers(table_name)
+    end
+
     # Whether the database supports combining multiple alter table
     # operations into a single query, false by default.
     def supports_combining_alter_table_ops?

data/lib/sequel/dataset.rb

@@ -23,8 +23,6 @@ module Sequel
   #
   # For more information, see the {"Dataset Basics" guide}[link:files/doc/dataset_basics_rdoc.html].
   class Dataset
-    extend Metaprogramming
-    include Metaprogramming
     include Enumerable
     include SQL::AliasMethods
     include SQL::BooleanMethods

data/lib/sequel/dataset/actions.rb

@@ -225,12 +225,35 @@ module Sequel
     #
     #   ds.get{sum(id)} # SELECT sum(id) FROM table LIMIT 1
     #   # => 6
+    #
+    # You can pass an array of arguments to return multiple arguments,
+    # but you must make sure each element in the array has an alias that
+    # Sequel can determine:
+    #
+    #   DB[:table].get([:id, :name]) # SELECT id, name FROM table LIMIT 1
+    #   # => [3, 'foo']
+    #
+    #   DB[:table].get{[sum(id).as(sum), name]} # SELECT sum(id) AS sum, name FROM table LIMIT 1
+    #   # => [6, 'foo']
     def get(column=(no_arg=true; nil), &block)
+      ds = naked
       if block
         raise(Error, ARG_BLOCK_ERROR_MSG) unless no_arg
-        select(&block).single_value
+        ds = ds.select(&block)
+        column = ds.opts[:select]
+        column = nil if column.is_a?(Array) && column.length < 2
+      else
+        ds = if column.is_a?(Array)
+          ds.select(*column)
+        else
+          ds.select(column)
+        end
+      end
+
+      if column.is_a?(Array)
+        ds.single_record.values_at(*column.map{|c| hash_key_symbol(c)})
       else
-        select(column).single_value
+        ds.single_value
       end
     end
     

data/lib/sequel/dataset/misc.rb

@@ -107,7 +107,7 @@ module Sequel
     # Define a hash value such that datasets with the same DB, opts, and SQL
     # will have the same hash value
     def hash
-      [db, opts.sort_by{|k, v| k.to_s}, sql].hash
+      [db, opts, sql].hash
     end
     
     # The String instance method to call on identifiers before sending them to

data/lib/sequel/dataset/sql.rb

@@ -636,24 +636,46 @@ module Sequel
       sql << QUOTE << name.to_s.gsub(QUOTE_RE, DOUBLE_QUOTE) << QUOTE
     end
 
-    # Split the schema information from the table
-    def schema_and_table(table_name)
-      sch = db.default_schema if db
+    # Split the schema information from the table, returning two strings,
+    # one for the schema and one for the table.  The returned schema may
+    # be nil, but the table will always have a string value.
+    #
+    # Note that this function does not handle tables with more than one
+    # level of qualification (e.g. database.schema.table on Microsoft
+    # SQL Server).
+    def schema_and_table(table_name, sch=(db.default_schema if db))
+      sch = sch.to_s if sch
       case table_name
       when Symbol
         s, t, a = split_symbol(table_name)
         [s||sch, t]
       when SQL::QualifiedIdentifier
-        [table_name.table, table_name.column]
+        [table_name.table.to_s, table_name.column.to_s]
       when SQL::Identifier
-        [sch, table_name.value]
+        [sch, table_name.value.to_s]
       when String
-        [sch, table_name]
+        [sch, table_name.to_s]
       else
         raise Error, 'table_name should be a Symbol, SQL::QualifiedIdentifier, SQL::Identifier, or String'
       end
     end
 
+    # Splits table_name into an array of strings.
+    #
+    #   ds.split_qualifiers(:s) # ['s']
+    #   ds.split_qualifiers(:t__s) # ['t', 's']
+    #   ds.split_qualifiers(Sequel.qualify(:d, :t__s)) # ['d', 't', 's']
+    #   ds.split_qualifiers(Sequel.qualify(:h__d, :t__s)) # ['h', 'd', 't', 's']
+    def split_qualifiers(table_name, *args)
+      case table_name
+      when SQL::QualifiedIdentifier
+        split_qualifiers(table_name.table, nil) + split_qualifiers(table_name.column, nil)
+      else
+        sch, table = schema_and_table(table_name, *args)
+        sch ? [sch, table] : [table]
+      end
+    end
+
     # SQL fragment for specifying subscripts (SQL array accesses)
     def subscript_sql_append(sql, s)
       literal_append(sql, s.f)

data/lib/sequel/extensions/core_refinements.rb

@@ -0,0 +1,221 @@
+# These are refinements to core classes that allow the Sequel
+# DSL to be used without modifying the core classes directly.
+# After loading the extension via:
+#
+#   Sequel.extension :core_refinements
+#
+# you can enable the refinements for particular files:
+#
+#   using Sequel::CoreRefinements
+
+raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+
+module Sequel::CoreRefinements
+  refine Array do
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, not matching all of the
+    # conditions.
+    #
+    #   ~[[:a, true]] # SQL: a IS NOT TRUE
+    #   ~[[:a, 1], [:b, [2, 3]]] # SQL: a != 1 OR b NOT IN (2, 3)
+    def ~
+      Sequel.~(self)
+    end
+
+    # Return a <tt>Sequel::SQL::CaseExpression</tt> with this array as the conditions and the given
+    # default value and expression.
+    #
+    #   [[{:a=>[2,3]}, 1]].case(0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+    #   [[:a, 1], [:b, 2]].case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
+    def case(*args)
+      ::Sequel::SQL::CaseExpression.new(self, *args)
+    end
+
+    # Return a <tt>Sequel::SQL::ValueList</tt> created from this array.  Used if this array contains
+    # all two element arrays and you want it treated as an SQL value list (IN predicate) 
+    # instead of as a conditions specifier (similar to a hash).  This is not necessary if you are using
+    # this array as a value in a filter, but may be necessary if you are using it as a
+    # value with placeholder SQL:
+    #
+    #   DB[:a].filter([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
+    #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
+    #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: (a, b) IN ((1, 2), (3, 4))
+    def sql_value_list
+      ::Sequel::SQL::ValueList.new(self)
+    end
+    
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching all of the
+    # conditions.  Rarely do you need to call this explicitly, as Sequel generally
+    # assumes that arrays of two element arrays specify this type of condition.  One case where
+    # it can be necessary to use this is if you are using the object as a value in a filter hash
+    # and want to use the = operator instead of the IN operator (which is used by default for
+    # arrays of two element arrays).
+    #
+    #   [[:a, true]].sql_expr # SQL: a IS TRUE
+    #   [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: a = 1 AND b IN (2, 3)
+    def sql_expr
+      Sequel.expr(self)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching none
+    # of the conditions.
+    #
+    #   [[:a, true]].sql_negate # SQL: a IS NOT TRUE
+    #   [[:a, 1], [:b, [2, 3]]].sql_negate # SQL: a != 1 AND b NOT IN (2, 3)
+    def sql_negate
+      Sequel.negate(self)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching any of the
+    # conditions.
+    #
+    #   [[:a, true]].sql_or # SQL: a IS TRUE
+    #   [[:a, 1], [:b, [2, 3]]].sql_or # SQL: a = 1 OR b IN (2, 3)
+    def sql_or
+      Sequel.or(self)
+    end
+
+    # Return a <tt>Sequel::SQL::StringExpression</tt> representing an SQL string made up of the
+    # concatenation of this array's elements.  If an argument is passed
+    # it is used in between each element of the array in the SQL
+    # concatenation.
+    #
+    #   [:a].sql_string_join # SQL: a
+    #   [:a, :b].sql_string_join # SQL: a || b
+    #   [:a, 'b'].sql_string_join # SQL: a || 'b'
+    #   ['a', :b].sql_string_join(' ') # SQL: 'a' || ' ' || b
+    def sql_string_join(joiner=nil)
+      Sequel.join(self, joiner)
+    end
+  end
+
+  refine Hash do
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching
+    # all of the conditions in this hash and the condition specified by
+    # the given argument.
+    #
+    #   {:a=>1} & :b # SQL: a = 1 AND b
+    #   {:a=>true} & ~:b # SQL: a IS TRUE AND NOT b
+    def &(ce)
+      ::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching
+    # all of the conditions in this hash or the condition specified by
+    # the given argument.
+    #
+    #   {:a=>1} | :b # SQL: a = 1 OR b
+    #   {:a=>true} | ~:b # SQL: a IS TRUE OR NOT b
+    def |(ce)
+      ::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, not matching all of the
+    # conditions.
+    #
+    #   ~{:a=>true} # SQL: a IS NOT TRUE
+    #   ~{:a=>1, :b=>[2, 3]} # SQL: a != 1 OR b NOT IN (2, 3)
+    def ~
+      ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
+    end
+
+    # Return a <tt>Sequel::SQL::CaseExpression</tt> with this hash as the conditions and the given
+    # default value.  Note that the order of the conditions will be arbitrary on ruby 1.8, so all
+    # conditions should be orthogonal.
+    #
+    #   {{:a=>[2,3]}=>1}.case(0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+    #   {:a=>1, :b=>2}.case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
+    #                                 #  or: CASE c WHEN b THEN 2 WHEN a THEN 1 ELSE d END
+    def case(*args)
+      ::Sequel::SQL::CaseExpression.new(to_a, *args)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching all of the
+    # conditions.  Rarely do you need to call this explicitly, as Sequel generally
+    # assumes that hashes specify this type of condition.
+    #
+    #   {:a=>true}.sql_expr # SQL: a IS TRUE
+    #   {:a=>1, :b=>[2, 3]}.sql_expr # SQL: a = 1 AND b IN (2, 3)
+    def sql_expr
+      ::Sequel::SQL::BooleanExpression.from_value_pairs(self)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching none
+    # of the conditions.
+    #
+    #   {:a=>true}.sql_negate # SQL: a IS NOT TRUE
+    #   {:a=>1, :b=>[2, 3]}.sql_negate # SQL: a != 1 AND b NOT IN (2, 3)
+    def sql_negate
+      ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching any of the
+    # conditions.
+    #
+    #   {:a=>true}.sql_or # SQL: a IS TRUE
+    #   {:a=>1, :b=>[2, 3]}.sql_or # SQL: a = 1 OR b IN (2, 3)
+    def sql_or
+      ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
+    end
+  end
+
+  refine String do
+    include Sequel::SQL::AliasMethods
+    include Sequel::SQL::CastMethods
+
+    # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
+    # literalization, e.g.:
+    #
+    #   DB[:items].filter(:abc => 'def').sql #=>
+    #     "SELECT * FROM items WHERE (abc = 'def')"
+    #
+    #   DB[:items].filter(:abc => 'def'.lit).sql #=>
+    #     "SELECT * FROM items WHERE (abc = def)"
+    #
+    # You can also provide arguments, to create a <tt>Sequel::SQL::PlaceholderLiteralString</tt>:
+    #
+    #    DB[:items].select{|o| o.count('DISTINCT ?'.lit(:a))}.sql #=>
+    #      "SELECT count(DISTINCT a) FROM items"
+    def lit(*args)
+      args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
+    end
+    
+    # Returns a <tt>Sequel::SQL::Blob</tt> that holds the same data as this string. Blobs provide proper
+    # escaping of binary data.
+    def to_sequel_blob
+      ::Sequel::SQL::Blob.new(self)
+    end
+  end
+
+  refine Symbol do
+    include Sequel::SQL::AliasMethods
+    include Sequel::SQL::CastMethods
+    include Sequel::SQL::OrderMethods
+    include Sequel::SQL::BooleanMethods
+    include Sequel::SQL::NumericMethods
+    include Sequel::SQL::QualifyingMethods
+    include Sequel::SQL::StringMethods
+    include Sequel::SQL::SubscriptMethods
+    include Sequel::SQL::ComplexExpressionMethods
+
+    # Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.  Usually used to
+    # prevent splitting the symbol.
+    #
+    #   :a__b # SQL: "a"."b"
+    #   :a__b.identifier # SQL: "a__b"
+    def identifier
+      Sequel::SQL::Identifier.new(self)
+    end
+
+    # Returns a <tt>Sequel::SQL::Function</tt> with this as the function name,
+    # and the given arguments. This is aliased as <tt>Symbol#[]</tt> if the RUBY_VERSION
+    # is less than 1.9.0. Ruby 1.9 defines <tt>Symbol#[]</tt>, and Sequel
+    # doesn't override methods defined by ruby itself.
+    #
+    #   :now.sql_function # SQL: now()
+    #   :sum.sql_function(:a) # SQL: sum(a)
+    #   :concat.sql_function(:a, :b) # SQL: concat(a, b)
+    def sql_function(*args)
+      Sequel::SQL::Function.new(self, *args)
+    end
+  end
+end