sequel 4.12.0 → 4.13.0

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

@@ -368,12 +368,10 @@ module Sequel
         generator.columns.each do |c|
           if t = c.delete(:table)
             same_table = t == name
-            k = c[:key]
+            key = c[:key] || key_proc.call(t)
 
-            key ||= key_proc.call(t)
-
-            if same_table && !k.nil?
-              generator.constraints.unshift(:type=>:unique, :columns=>Array(k))
+            if same_table && !key.nil?
+              generator.constraints.unshift(:type=>:unique, :columns=>Array(key))
             end
 
             generator.foreign_key([c[:name]], t, c.merge(:name=>c[:foreign_key_constraint_name], :type=>:foreign_key, :key=>key))

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

@@ -59,19 +59,33 @@ module Sequel
         false
       end
 
+      IGNORE_OWNERS = %w'APEX_040000 CTXSYS EXFSYS MDSYS OLAPSYS ORDDATA ORDSYS SYS SYSTEM XDB XDBMETADATA XDBPM XFILES WMSYS'
+
       def tables(opts=OPTS)
         m = output_identifier_meth
-        metadata_dataset.from(:tabs).server(opts[:server]).select(:table_name).map{|r| m.call(r[:table_name])}
+        metadata_dataset.from(:all_tables).
+          server(opts[:server]).
+          where(:dropped=>'NO').
+          exclude(:owner=>IGNORE_OWNERS).
+          select(:table_name).
+          map{|r| m.call(r[:table_name])}
       end
 
       def views(opts=OPTS) 
         m = output_identifier_meth
-        metadata_dataset.from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'VIEW').map{|r| m.call(r[:tname])}
+        metadata_dataset.from(:all_views).
+          server(opts[:server]).
+          exclude(:owner=>IGNORE_OWNERS).
+          select(:view_name).
+          map{|r| m.call(r[:view_name])}
       end 
  
       def view_exists?(name) 
         m = input_identifier_meth
-        metadata_dataset.from(:tab).filter(:tname =>m.call(name), :tabtype => 'VIEW').count > 0 
+        metadata_dataset.from(:all_views).
+          exclude(:owner=>IGNORE_OWNERS).
+          where(:view_name=>m.call(name)).
+          count > 0
       end 
 
       # Oracle supports deferrable constraints.

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

@@ -1297,10 +1297,15 @@ module Sequel
       # Insert a record returning the record inserted.  Always returns nil without
       # inserting a query if disable_insert_returning is used.
       def insert_select(*values)
-        unless @opts[:disable_insert_returning]
-          ds = opts[:returning] ? self : returning
-          ds.insert(*values){|r| return r}
-        end
+        return unless supports_insert_select?
+        with_sql_first(insert_select_sql(*values))
+      end
+
+      # The SQL to use for an insert_select, adds a RETURNING clause to the insert
+      # unless the RETURNING clause is already present.
+      def insert_select_sql(*values)
+        ds = opts[:returning] ? self : returning
+        ds.insert_sql(*values)
       end
 
       # Locks all tables in the dataset's FROM clause (but not in JOINs) with

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

@@ -106,7 +106,7 @@ module Sequel
                :columns=>r[:columns].split(',').map{|v| m.call(v.split(' ').first)},
                :table=>m.call(r[:table_name]),
                :key=>r[:column_map].split(',').map{|v| m.call(v.split(' IS ').last)}}
-           end
+          end
         end
         fk_indexes.values
       end
@@ -255,7 +255,6 @@ module Sequel
       DATEPART = 'datepart'.freeze
       REGEXP = 'REGEXP'.freeze
       NOT_REGEXP = 'NOT REGEXP'.freeze
-      TIMESTAMP_USEC_FORMAT = ".%03d".freeze
       APOS = Dataset::APOS
       APOS_RE = Dataset::APOS_RE
       DOUBLE_APOS = Dataset::DOUBLE_APOS
@@ -425,10 +424,6 @@ module Sequel
         end
       end
 
-      def format_timestamp_usec(usec)
-        sprintf(TIMESTAMP_USEC_FORMAT, usec/1000)
-      end
-
       # Sybase uses TOP N for limit.  For Sybase TOP (N) is used
       # to allow the limit to be a bound variable.
       def select_limit_sql(sql)
@@ -465,6 +460,11 @@ module Sequel
           super
         end
       end
+
+      # SQLAnywhere supports millisecond timestamp precision.
+      def timestamp_precision
+        3
+      end
     end
   end
 end

data/lib/sequel/database/connecting.rb

@@ -22,23 +22,10 @@ module Sequel
       return scheme if scheme.is_a?(Class)
 
       scheme = scheme.to_s.gsub('-', '_').to_sym
-      
-      unless klass = ADAPTER_MAP[scheme]
-        # attempt to load the adapter file
-        begin
-          require "sequel/adapters/#{scheme}"
-        rescue LoadError => e
-          raise Sequel.convert_exception_class(e, AdapterNotFound)
-        end
-        
-        # make sure we actually loaded the adapter
-        unless klass = ADAPTER_MAP[scheme]
-          raise AdapterNotFound, "Could not load #{scheme} adapter: adapter class not registered in ADAPTER_MAP"
-        end
-      end
-      klass
+
+      load_adapter(scheme)
     end
-        
+
     # Returns the scheme symbol for the Database class.
     def self.adapter_scheme
       @scheme
@@ -90,6 +77,40 @@ module Sequel
       db
     end
     
+    # Load the adapter from the file system.  Raises Sequel::AdapterNotFound
+    # if the adapter cannot be loaded, or if the adapter isn't registered
+    # correctly after being loaded. Options:
+    # :map :: The Hash in which to look for an already loaded adapter (defaults to ADAPTER_MAP).
+    # :subdir :: The subdirectory of sequel/adapters to look in, only to be used for loading
+    #            subadapters.
+    def self.load_adapter(scheme, opts=OPTS)
+      map = opts[:map] || ADAPTER_MAP
+      if subdir = opts[:subdir]
+        file = "#{subdir}/#{scheme}"
+      else
+        file = scheme
+      end
+      
+      unless obj = Sequel.synchronize{map[scheme]}
+        # attempt to load the adapter file
+        begin
+          require "sequel/adapters/#{file}"
+        rescue LoadError => e
+          # If subadapter file doesn't exist, just return, 
+          # using the main adapter class without database customizations.
+          return if subdir
+          raise Sequel.convert_exception_class(e, AdapterNotFound)
+        end
+        
+        # make sure we actually loaded the adapter
+        unless obj = Sequel.synchronize{map[scheme]}
+          raise AdapterNotFound, "Could not load #{file} adapter: adapter class not registered in ADAPTER_MAP"
+        end
+      end
+
+      obj
+    end
+
     # Sets the adapter scheme for the Database class. Call this method in
     # descendants of Database to allow connection using a URL. For example the
     # following:
@@ -104,7 +125,7 @@ module Sequel
     #   Sequel.connect('mydb://user:password@dbserver/mydb')
     def self.set_adapter_scheme(scheme) # :nodoc:
       @scheme = scheme
-      ADAPTER_MAP[scheme] = self
+      Sequel.synchronize{ADAPTER_MAP[scheme] = self}
     end
     private_class_method :set_adapter_scheme
     

data/lib/sequel/dataset/actions.rb

@@ -1022,8 +1022,12 @@ module Sequel
     def unaliased_identifier(c)
       case c
       when Symbol
-        c_table, column, _ = split_symbol(c)
-        c_table ? SQL::QualifiedIdentifier.new(c_table, column.to_sym) : column.to_sym
+        table, column, aliaz = split_symbol(c)
+        if aliaz
+          table ? SQL::QualifiedIdentifier.new(table, column) : Sequel.identifier(column)
+        else
+          c
+        end
       when SQL::AliasedExpression
         c.expression
       when SQL::OrderedExpression

data/lib/sequel/dataset/graph.rb

@@ -95,7 +95,8 @@ module Sequel
       ds = self
 
       # Use a from_self if this is already a joined table (or from_self specifically disabled for graphs)
-      if (@opts[:graph_from_self] != false && !@opts[:graph] && (@opts[:from].length > 1 || @opts[:join]))
+      if (@opts[:graph_from_self] != false && !@opts[:graph] && joined_dataset?)
+        from_selfed = true
         implicit_qualifier = options[:from_self_alias] || first_source
         ds = ds.from_self(:alias=>implicit_qualifier)
       end
@@ -109,49 +110,46 @@ module Sequel
       # Whether to add the columns to the list of column aliases
       add_columns = !ds.opts.include?(:graph_aliases)
 
-      # Setup the initial graph data structure if it doesn't exist
       if graph = opts[:graph]
         opts[:graph] = graph = graph.dup
         select = opts[:select].dup
         [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k] = graph[k].dup}
       else
+        # Setup the initial graph data structure if it doesn't exist
         qualifier = ds.first_source_alias
         master = alias_symbol(qualifier)
         raise_alias_error.call if master == table_alias
+
         # Master hash storing all .graph related information
         graph = opts[:graph] = {}
+
         # Associates column aliases back to tables and columns
         column_aliases = graph[:column_aliases] = {}
+
         # Associates table alias (the master is never aliased)
         table_aliases = graph[:table_aliases] = {master=>self}
+
         # Keep track of the alias numbers used
         ca_num = graph[:column_alias_num] = Hash.new(0)
+
         # All columns in the master table are never
         # aliased, but are not included if set_graph_aliases
         # has been used.
         if add_columns
           if (select = @opts[:select]) && !select.empty? && !(select.length == 1 && (select.first.is_a?(SQL::ColumnAll)))
-            select = select.each do |sel|
-              column = case sel
-              when Symbol
-                _, c, a = split_symbol(sel)
-                (a || c).to_sym
-              when SQL::Identifier
-                sel.value.to_sym
-              when SQL::QualifiedIdentifier
-                column = sel.column
-                column = column.value if column.is_a?(SQL::Identifier)
-                column.to_sym
-              when SQL::AliasedExpression
-                column = sel.alias
-                column = column.value if column.is_a?(SQL::Identifier)
-                column.to_sym
+            select = select.map do |sel|
+              raise Error, "can't figure out alias to use for graphing for #{sel.inspect}" unless column = _hash_key_symbol(sel)
+              column_aliases[column] = [master, column]
+              if from_selfed
+                # Initial dataset was wrapped in subselect, selected all
+                # columns in the subselect, qualified by the subselect alias.
+                Sequel.qualify(qualifier, Sequel.identifier(column))
               else
-                raise Error, "can't figure out alias to use for graphing for #{sel.inspect}"
+                # Initial dataset not wrapped in subslect, just make
+                # sure columns are qualified in some way.
+                qualified_expression(sel, qualifier)
               end
-              column_aliases[column] = [master, column]
             end
-            select = qualified_expression(select, qualifier)
           else
             select = columns.map do |column|
               column_aliases[column] = [master, column]

data/lib/sequel/dataset/misc.rb

@@ -169,6 +169,11 @@ module Sequel
       "#<#{visible_class_name}: #{sql.inspect}>"
     end
     
+    # Whether this dataset is a joined dataset (multiple FROM tables or any JOINs).
+    def joined_dataset?
+     !!((opts[:from].is_a?(Array) && opts[:from].size > 1) || opts[:join])
+    end
+
     # The alias to use for the row_number column, used when emulating OFFSET
     # support and for eager limit strategies
     def row_number_column
@@ -192,6 +197,17 @@ module Sequel
       end
     end
 
+    # This returns an SQL::Identifier or SQL::AliasedExpression containing an
+    # SQL identifier that represents the unqualified column for the given value.
+    # The given value should be a Symbol, SQL::Identifier, SQL::QualifiedIdentifier,
+    # or SQL::AliasedExpression containing one of those.  In other cases, this
+    # returns nil
+    def unqualified_column_for(v)
+      unless v.is_a?(String)
+        _unqualified_column_for(v)
+      end
+    end
+
     # Creates a unique table alias that hasn't already been used in the dataset.
     # table_alias can be any type of object accepted by alias_symbol.
     # The symbol returned will be the implicit alias in the argument,
@@ -232,6 +248,27 @@ module Sequel
 
     private
 
+    # Internal recursive version of unqualified_column_for, handling Strings inside
+    # of other objects.
+    def _unqualified_column_for(v)
+      case v
+      when Symbol
+        _, c, a = Sequel.split_symbol(v)
+        c = Sequel.identifier(c)
+        a ? c.as(a) : c
+      when String
+        Sequel.identifier(v)
+      when SQL::Identifier
+        v
+      when SQL::QualifiedIdentifier
+        _unqualified_column_for(v.column)
+      when SQL::AliasedExpression
+        if expr = unqualified_column_for(v.expression)
+          SQL::AliasedExpression.new(expr, v.alias)
+        end
+      end
+    end
+
     # Return the class name for this dataset, but skip anonymous classes
     def visible_class_name
       c = self.class

data/lib/sequel/dataset/prepared_statements.rb

@@ -86,8 +86,7 @@ module Sequel
         when :first
           clone(:limit=>1).select_sql
         when :insert_select
-          ds = opts[:returning] ? self : returning
-          ds.insert_sql(*@prepared_modify_values)
+          insert_select_sql(*@prepared_modify_values)
         when :insert
           insert_sql(*@prepared_modify_values)
         when :update

data/lib/sequel/dataset/query.rb

@@ -694,6 +694,7 @@ module Sequel
     #   DB[:items].returning(nil) # RETURNING NULL
     #   DB[:items].returning(:id, :name) # RETURNING id, name
     def returning(*values)
+      raise Error, "RETURNING is not supported on #{db.database_type}" unless supports_returning?(:insert)
       clone(:returning=>values)
     end
 

data/lib/sequel/dataset/sql.rb

@@ -280,7 +280,6 @@ module Sequel
     FORMAT_DATE_STANDARD = "DATE '%Y-%m-%d'".freeze
     FORMAT_OFFSET = "%+03i%02i".freeze
     FORMAT_TIMESTAMP_RE = /%[Nz]/.freeze
-    FORMAT_TIMESTAMP_USEC = ".%06d".freeze
     FORMAT_USEC = '%N'.freeze
     FRAME_ALL = "ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING".freeze
     FRAME_ROWS = "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW".freeze
@@ -331,11 +330,12 @@ module Sequel
     USING = ' USING ('.freeze
     UNION_ALL_SELECT = ' UNION ALL SELECT '.freeze
     VALUES = " VALUES ".freeze
-    V190 = '1.9.0'.freeze
     WHERE = " WHERE ".freeze
     WITH_ORDINALITY = " WITH ORDINALITY".freeze
     WITHIN_GROUP = " WITHIN GROUP (ORDER BY ".freeze
 
+    DATETIME_SECFRACTION_ARG = RUBY_VERSION >= '1.9.0' ? 1000000 : 86400000000
+
     [:literal, :quote_identifier, :quote_schema_table].each do |meth|
       class_eval(<<-END, __FILE__, __LINE__ + 1)
         def #{meth}(*args, &block)
@@ -1022,7 +1022,7 @@ module Sequel
       v2 = db.from_application_timestamp(v)
       fmt = default_timestamp_format.gsub(FORMAT_TIMESTAMP_RE) do |m|
         if m == FORMAT_USEC
-          format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*(RUBY_VERSION < V190 ? 86400000000 : 1000000) : v.usec) if supports_timestamp_usecs?
+          format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*(DATETIME_SECFRACTION_ARG) : v.usec) if supports_timestamp_usecs?
         else
           if supports_timestamp_timezones?
             # Would like to just use %z format, but it doesn't appear to work on Windows
@@ -1043,7 +1043,10 @@ module Sequel
     # Return the SQL timestamp fragment to use for the fractional time part.
     # Should start with the decimal point.  Uses 6 decimal places by default.
     def format_timestamp_usec(usec)
-      sprintf(FORMAT_TIMESTAMP_USEC, usec)
+      unless (ts = timestamp_precision) == 6
+        usec = usec/(10 ** (6 - ts))
+      end
+      sprintf(".%0#{ts}d", usec)
     end
 
     # Append literalization of identifier to SQL string, considering regular strings
@@ -1082,7 +1085,11 @@ module Sequel
 
     def insert_into_sql(sql)
       sql << INTO
-      source_list_append(sql, @opts[:from])
+      if (f = @opts[:from]) && f.length == 1
+        identifier_append(sql, unaliased_identifier(f.first))
+      else
+        source_list_append(sql, f)
+      end
     end
 
     def insert_columns_sql(sql)
@@ -1132,11 +1139,6 @@ module Sequel
       "#{join_type.to_s.gsub(UNDERSCORE, SPACE).upcase} JOIN"
     end
 
-    # Whether this dataset is a joined dataset
-    def joined_dataset?
-     (opts[:from].is_a?(Array) && opts[:from].size > 1) || opts[:join]
-    end
-
     # Append a literalization of the array to SQL string.
     # Treats as an expression if an array of all two pairs, or as a SQL array otherwise.
     def literal_array_append(sql, v)
@@ -1513,6 +1515,11 @@ module Sequel
       ds.clone(:append_sql=>sql).sql
     end
 
+    # The number of decimal digits of precision to use in timestamps.
+    def timestamp_precision
+      supports_timestamp_usecs? ? 6 : 0
+    end
+
     def update_table_sql(sql)
       sql << SPACE
       source_list_append(sql, @opts[:from])

data/lib/sequel/extensions/dataset_source_alias.rb

@@ -0,0 +1,90 @@
+# The dataset_source_alias extension changes Sequel's
+# default behavior of automatically aliasing datasets
+# from using t1, t2, etc. to using an alias based on
+# the source of the dataset.  Example:
+#
+#   DB.from(DB.from(:a))
+#   # default: SELECT * FROM (SELECT * FROM a) AS t1
+#   # with extension: SELECT * FROM (SELECT * FROM a) AS a
+#
+# This also works when joining:
+#
+#   DB[:a].join(DB[:b], [:id])
+#   # SELECT * FROM a INNER JOIN (SELECT * FROM b) AS b USING (id)
+#
+# To avoid conflicting aliases, this attempts to alias tables
+# uniquely if it detects a conflict:
+#
+#   DB.from(:a, DB.from(:a))
+#   # SELECT * FROM a, (SELECT * FROM a) AS a_0
+#
+# Note that not all conflicts are correctly detected and handled.
+# It is encouraged to alias your datasets manually instead of
+# relying on the auto-aliasing if there would be a conflict.
+#
+# In the places where Sequel cannot determine the
+# appropriate alias to use for the dataset, it will fallback to
+# the standard t1, t2, etc. aliasing.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:dataset_source_alias)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:dataset_source_alias)
+
+module Sequel
+  class Dataset
+    module DatasetSourceAlias
+      # Preprocess the list of sources and attempt to alias any
+      # datasets in the sources to the first source of the resepctive
+      # dataset.
+      def from(*source, &block)
+        virtual_row_columns(source, block)
+        table_aliases = []
+        source = source.map do |s|
+          case s
+          when Dataset
+            s = dataset_source_alias_expression(s, table_aliases)
+          when Symbol, String, SQL::AliasedExpression, SQL::Identifier, SQL::QualifiedIdentifier
+            table_aliases << alias_symbol(s)
+          end
+          s
+        end
+        super(*source, &nil)
+      end
+
+      # If a Dataset is given as the table argument, attempt to alias
+      # it to its source.
+      def join_table(type, table, expr=nil, options=OPTS)
+        if table.is_a?(Dataset) && !options[:table_alias]
+          table = dataset_source_alias_expression(table)
+        end
+        super
+      end
+
+      private
+
+      # Attempt to automatically alias the given dataset to its source.
+      # If the dataset cannot be automatically aliased to its source,
+      # return it unchanged.  The table_aliases argument is a list of
+      # already used alias symbols, which will not be used as the alias.
+      def dataset_source_alias_expression(ds, table_aliases=[])
+        base = ds.first_source if ds.opts[:from]
+        case base
+        when Symbol, String, SQL::AliasedExpression, SQL::Identifier, SQL::QualifiedIdentifier
+          aliaz = unused_table_alias(base, table_aliases)
+          table_aliases << aliaz
+          ds.as(aliaz)
+        else
+          ds
+        end
+      end
+    end
+
+    register_extension(:dataset_source_alias, DatasetSourceAlias)
+  end
+end