sequel 2.7.1 → 2.8.0

data/lib/sequel_core/adapters/odbc.rb

@@ -14,6 +14,9 @@ module Sequel
         when 'mssql'
           require 'sequel_core/adapters/shared/mssql'
           extend Sequel::MSSQL::DatabaseMethods
+        when 'progress'
+          require 'sequel_core/adapters/shared/progress'
+          extend Sequel::Progress::DatabaseMethods
         end
       end
 
@@ -37,10 +40,6 @@ module Sequel
         conn
       end      
 
-      def disconnect
-        @pool.disconnect {|c| c.disconnect}
-      end
-    
       def dataset(opts = nil)
         ODBC::Dataset.new(self, opts)
       end
@@ -63,6 +62,35 @@ module Sequel
         synchronize(opts[:server]){|conn| conn.do(sql)}
       end
       alias_method :do, :execute_dui
+
+      # Support single level transactions on ODBC
+      def transaction(server=nil)
+        synchronize(server) do |conn|
+          return yield(conn) if @transactions.include?(Thread.current)
+          log_info(begin_transaction_sql)
+          conn.do(begin_transaction_sql)
+          begin
+            @transactions << Thread.current
+            yield(conn)
+          rescue ::Exception => e
+            log_info(rollback_transaction_sql)
+            conn.do(rollback_transaction_sql)
+            transaction_error(e)
+          ensure
+            unless e
+              log_info(commit_transaction_sql)
+              conn.do(commit_transaction_sql)
+            end
+            @transactions.delete(Thread.current)
+          end
+        end
+      end
+
+      private
+
+      def disconnect_connection(c)
+        c.disconnect
+      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel_core/adapters/openbase.rb

@@ -15,11 +15,6 @@ module Sequel
         )
       end
       
-      def disconnect
-        # would this work?
-        @pool.disconnect {|c| c.disconnect}
-      end
-    
       def dataset(opts = nil)
         OpenBase::Dataset.new(self, opts)
       end
@@ -33,6 +28,12 @@ module Sequel
         end
       end
       alias_method :do, :execute
+
+      private
+
+      def disconnect_connection(c)
+        c.disconnect
+      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel_core/adapters/oracle.rb

@@ -6,6 +6,12 @@ module Sequel
     class Database < Sequel::Database
       include DatabaseMethods
       set_adapter_scheme :oracle
+
+      # ORA-00028: your session has been killed
+      # ORA-01012: not logged on
+      # ORA-03113: end-of-file on communication channel
+      # ORA-03114: not connected to ORACLE
+      CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114 ]      
       
       def connect(server)
         opts = server_opts(server)
@@ -21,10 +27,6 @@ module Sequel
         conn
       end
       
-      def disconnect
-        @pool.disconnect {|c| c.logoff}
-      end
-    
       def dataset(opts = nil)
         Oracle::Dataset.new(self, opts)
       end
@@ -32,9 +34,17 @@ module Sequel
       def execute(sql, opts={})
         log_info(sql)
         synchronize(opts[:server]) do |conn|
-          r = conn.exec(sql)
-          yield(r) if block_given?
-          r
+          begin
+            r = conn.exec(sql)
+            yield(r) if block_given?
+            r
+          rescue OCIException => e
+            if CONNECTION_ERROR_CODES.include?(e.code)  
+              raise(Sequel::DatabaseDisconnectError)              
+            else
+              raise
+            end
+          end
         end
       end
       alias_method :do, :execute
@@ -57,6 +67,12 @@ module Sequel
           end
         end
       end
+
+      private
+
+      def disconnect_connection(c)
+        c.logoff
+      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel_core/adapters/postgres.rb

@@ -62,6 +62,9 @@ rescue LoadError => e
         def block(timeout=nil)
         end
       end
+      unless defined?(CONNECTION_OK)
+        CONNECTION_OK = -1
+      end
     end
     class PGresult 
       alias_method :nfields, :num_fields unless method_defined?(:nfields) 
@@ -97,7 +100,6 @@ module Sequel
       1083 => lambda{ |s| s.to_time }, # time without time zone
       1114 => lambda{ |s| s.to_sequel_time }, # timestamp without time zone
       1184 => lambda{ |s| s.to_sequel_time }, # timestamp with time zone
-      1186 => lambda{ |s| s.to_i }, # interval
       1266 => lambda{ |s| s.to_time }, # time with time zone
       1700 => lambda{ |s| s.to_d }, # numeric
     }
@@ -119,7 +121,12 @@ module Sequel
       # the date style to ISO in order make Date object creation in ruby faster,
       # if Postgres.use_iso_date_format is true.
       def apply_connection_settings
-        async_exec("SET DateStyle = 'ISO'") if Postgres.use_iso_date_format
+        super
+        if Postgres.use_iso_date_format
+          sql = "SET DateStyle = 'ISO'"
+          @db.log_info(sql)
+          execute(sql)
+        end
       end
 
       # Execute the given SQL with this connection.  If a block is given,
@@ -128,12 +135,16 @@ module Sequel
         q = nil
         begin
           q = args ? async_exec(sql, args) : async_exec(sql)
-        rescue PGError => e
-          raise if status == Adapter::CONNECTION_OK
-          reset
-          q = args ? async_exec(sql, args) : async_exec(sql)
+        rescue PGError
+          begin
+            s = status
+          rescue PGError
+            raise(Sequel::DatabaseDisconnectError)
+          end
+          status_ok = (s == Adapter::CONNECTION_OK)
+          status_ok ? raise : raise(Sequel::DatabaseDisconnectError)
         ensure
-          block
+          block if status_ok
         end
         begin
           block_given? ? yield(q) : q.cmd_tuples
@@ -200,8 +211,8 @@ module Sequel
             conn.async_exec("set client_encoding to '#{encoding}'")
           end
         end
-        conn.apply_connection_settings
         conn.db = self
+        conn.apply_connection_settings
         conn
       end
       
@@ -210,11 +221,6 @@ module Sequel
         Postgres::Dataset.new(self, opts)
       end
       
-      # Disconnect all active connections.
-      def disconnect
-        @pool.disconnect {|c| c.finish}
-      end
-      
       # Execute the given SQL with the given args on an available connection.
       def execute(sql, opts={}, &block)
         return execute_prepared_statement(sql, opts, &block) if Symbol === sql
@@ -250,6 +256,14 @@ module Sequel
         super.merge(:pool_convert_exceptions=>false)
       end
       
+      # Disconnect given connection
+      def disconnect_connection(conn)
+        begin
+          conn.finish
+        rescue PGError
+        end
+      end
+      
       # Execute the prepared statement with the given name on an available
       # connection, using the given args.  If the connection has not prepared
       # a statement with the given name yet, prepare it.  If the connection
@@ -329,11 +343,9 @@ module Sequel
           # Return an array of strings for each of the hash values, inserting
           # them to the correct position in the array.
           def map_to_prepared_args(hash)
-            array = []
-            @prepared_args.each{|k,v| array[v] = hash[k].to_s}
-            array
+            @prepared_args.map{|k| hash[k.to_sym].to_s}
           end
-          
+
           private
           
           # PostgreSQL most of the time requires type information for each of
@@ -343,21 +355,16 @@ module Sequel
           # elminate ambiguity (and PostgreSQL from raising an exception).
           def prepared_arg(k)
             y, type = k.to_s.split("__")
-            "#{prepared_arg_placeholder}#{@prepared_args[y.to_sym]}#{"::#{type}" if type}".lit
-          end
-          
-          # If the named argument has already been used, return the position in
-          # the output array that it is mapped to.  Otherwise, map it to the
-          # next position in the array.
-          def prepared_args_hash
-            max_prepared_arg = 0
-            Hash.new do |h,k|
-              h[k] = max_prepared_arg
-              max_prepared_arg += 1
+            if i = @prepared_args.index(y)
+              i += 1
+            else
+              @prepared_args << y
+              i = @prepared_args.length
             end
+            "#{prepared_arg_placeholder}#{i}#{"::#{type}" if type}".lit
           end
         end
-        
+
         # Allow use of bind arguments for PostgreSQL using the pg driver.
         module BindArgumentMethods
           include ArgumentMapper
@@ -414,11 +421,14 @@ module Sequel
         
         # Prepare the given type of statement with the given name, and store
         # it in the database to be called later.
-        def prepare(type, name, values=nil)
+        def prepare(type, name=nil, values=nil)
           ps = to_prepared_statement(type, values)
           ps.extend(PreparedStatementMethods)
-          ps.prepared_statement_name = name
-          db.prepared_statements[name] = ps
+          if name
+            ps.prepared_statement_name = name
+            db.prepared_statements[name] = ps
+          end
+          ps
         end
         
         private

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

@@ -35,6 +35,10 @@ module Sequel
     end
   
     module DatasetMethods
+      include Dataset::UnsupportedIntersectExcept
+
+      SELECT_CLAUSE_ORDER = %w'limit distinct columns from with join where group order having union'.freeze
+
       def complex_expression_sql(op, args)
         case op
         when :'||'
@@ -48,77 +52,48 @@ module Sequel
         filter("CONTAINS (#{literal(cols)}, #{literal(terms)})")
       end
       
-      # Allows you to do .nolock on a query
-      def nolock
-        clone(:with => "(NOLOCK)")
-      end
-
-      # Formats a SELECT statement using the given options and the dataset
-      # options.
-      def select_sql(opts = nil)
-        opts = opts ? @opts.merge(opts) : @opts
-
-        if sql = opts[:sql]
-          return sql
-        end
-
-        # ADD TOP to SELECT string for LIMITS
-        if limit = opts[:limit]
-          top = "TOP #{limit} "
-          raise Error, "Offset not supported" if opts[:offset]
-        end
-
-        columns = opts[:select]
-        # We had to reference const WILDCARD with its full path, because
-        # the Ruby constant scope rules played against us (it was resolving it
-        # as Sequel::Dataset::DatasetMethods::WILDCARD).
-        select_columns = columns ? column_list(columns) : Sequel::Dataset::WILDCARD
-
-        if distinct = opts[:distinct]
-          distinct_clause = distinct.empty? ? "DISTINCT" : "DISTINCT ON (#{expression_list(distinct)})"
-          sql = "SELECT #{top}#{distinct_clause} #{select_columns}"
+      def literal(v)
+        case v
+        when String
+          "N#{super}"
+        when Time
+          literal(v.iso8601)
+        when Date, DateTime
+          literal(v.to_s)
         else
-          sql = "SELECT #{top}#{select_columns}"
-        end
-
-        if opts[:from]
-          sql << " FROM #{source_list(opts[:from])}"
+          super
         end
+      end
 
-        # ADD WITH to SELECT string for NOLOCK
-        if with = opts[:with]
-          sql << " WITH #{with}"
-        end
+      def multi_insert_sql(columns, values)
+        values = values.map {|r| "SELECT #{expression_list(r)}" }.join(" UNION ALL ")
+        ["INSERT INTO #{source_list(@opts[:from])} (#{identifier_list(columns)}) #{values}"]
+      end
 
-        if join = opts[:join]
-          join.each{|j| sql << literal(j)}
-        end
+      # Allows you to do .nolock on a query
+      def nolock
+        clone(:with => "(NOLOCK)")
+      end
 
-        if where = opts[:where]
-          sql << " WHERE #{literal(where)}"
-        end
+      def quoted_identifier(name)
+        "[#{name}]"
+      end
 
-        if group = opts[:group]
-          sql << " GROUP BY #{expression_list(group)}"
-        end
+      private
 
-        if order = opts[:order]
-          sql << " ORDER BY #{expression_list(order)}"
-        end
+      def select_clause_order
+        SELECT_CLAUSE_ORDER
+      end
 
-        if having = opts[:having]
-          sql << " HAVING #{literal(having)}"
-        end
+      # MSSQL uses TOP for limit, with no offset support
+      def select_limit_sql(sql, opts)
+        raise(Error, "OFFSET not supported") if opts[:offset]
+        sql << " TOP #{opts[:limit]}" if opts[:limit]
+      end
 
-        if union = opts[:union]
-          sql << (opts[:union_all] ? \
-            " UNION ALL #{union.sql}" : " UNION #{union.sql}")
-        end
-        
-        raise Error, "Intersect not supported" if opts[:intersect]
-        raise Error, "Except not supported" if opts[:except]
-        
-        sql
+      # MSSQL uses the WITH statement to lock tables
+      def select_with_sql(sql, opts)
+        sql << " WITH #{opts[:with]}" if opts[:with]
       end
     end
   end

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

@@ -14,15 +14,13 @@ module Sequel
       # Use MySQL specific syntax for rename column, set column type, and
       # drop index cases.
       def alter_table_sql(table, op)
-        quoted_table = quote_identifier(table)
-        quoted_name = quote_identifier(op[:name]) if op[:name]
         case op[:op]
         when :rename_column
-          "ALTER TABLE #{quoted_table} CHANGE COLUMN #{quoted_name} #{quote_identifier(op[:new_name])} #{type_literal(op)}"
+          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{quote_identifier(op[:new_name])} #{type_literal(op)}"
         when :set_column_type
-          "ALTER TABLE #{quoted_table} CHANGE COLUMN #{quoted_name} #{quoted_name} #{type_literal(op)}"
+          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{quote_identifier(op[:name])} #{type_literal(op)}"
         when :drop_index
-          "#{drop_index_sql(table, op)} ON #{quoted_table}"
+          "#{drop_index_sql(table, op)} ON #{quote_schema_table(table)}"
         else
           super(table, op)
         end
@@ -50,7 +48,7 @@ module Sequel
           using = " USING #{index[:type]}" unless index[:type] == nil
           "UNIQUE " if index[:unique]
         end
-        "CREATE #{index_type}INDEX #{index_name} ON #{quote_identifier(table_name)} #{literal(index[:columns])}#{using}"
+        "CREATE #{index_type}INDEX #{index_name} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}#{using}"
       end
       
       # Get version of MySQL server, used for determined capabilities.
@@ -75,9 +73,14 @@ module Sequel
       
       private
       
+      # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers by default.
+      def upcase_identifiers_default
+        false
+      end
+
       # Use the MySQL specific DESCRIBE syntax to get a table description.
       def schema_parse_table(table_name, opts)
-        self["DESCRIBE ?", table_name].map do |row|
+        self["DESCRIBE ?", SQL::Identifier.new(table_name)].map do |row|
           row.delete(:Extra)
           row[:allow_null] = row.delete(:Null) == 'YES'
           row[:default] = row.delete(:Default)
@@ -92,6 +95,8 @@ module Sequel
   
     # Dataset methods shared by datasets that use MySQL databases.
     module DatasetMethods
+      include Dataset::UnsupportedIntersectExcept
+
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       COMMA_SEPARATOR = ', '.freeze
@@ -250,6 +255,16 @@ module Sequel
 
         sql
       end
+
+      private
+
+      # MySQL doesn't support DISTINCT ON
+      def select_distinct_sql(sql, opts)
+        if opts[:distinct]
+          raise(Error, "DISTINCT ON not supported by MySQL") unless opts[:distinct].empty?
+          sql << " DISTINCT"
+        end
+      end
     end
   end
 end