sequel 3.21.0 → 3.41.0

data/lib/sequel/adapters/ado/access.rb

@@ -0,0 +1,334 @@
+Sequel.require 'adapters/shared/access'
+Sequel.require 'adapters/utils/split_alter_table'
+
+module Sequel
+  module ADO
+    # Database and Dataset instance methods for Access specific
+    # support via ADO.
+    module Access
+      class AdoSchema
+        QUERY_TYPE = {
+          :columns => 4,
+          :indexes => 12,
+          :tables  => 20,
+          :views   => 23,
+          :foreign_keys => 27
+        }
+        
+        attr_reader :type, :criteria
+
+        def initialize(type, crit)
+          @type     = QUERY_TYPE[type]
+          @criteria = Array(crit)
+        end
+        
+        class Column
+          DATA_TYPE = {
+            2   => "SMALLINT",
+            3   => "INTEGER",
+            4   => "REAL",
+            5   => "DOUBLE",
+            6   => "MONEY",
+            7   => "DATETIME",
+            11  => "BIT",
+            14  => "DECIMAL",
+            16  => "TINYINT",
+            17  => "BYTE",
+            72  => "GUID",
+            128 => "BINARY",
+            130 => "TEXT",
+            131 => "DECIMAL",
+            201 => "TEXT",
+            205 => "IMAGE"
+          }
+          
+          def initialize(row)
+            @row = row
+          end
+          
+          def [](col)
+            @row[col]
+          end
+          
+          def allow_null
+            self["IS_NULLABLE"]
+          end
+          
+          def default
+            self["COLUMN_DEFAULT"]
+          end
+          
+          def db_type
+            t = DATA_TYPE[self["DATA_TYPE"]]
+            if t == "DECIMAL" && precision
+              t + "(#{precision.to_i},#{(scale || 0).to_i})"
+            elsif t == "TEXT" && maximum_length && maximum_length > 0
+              t + "(#{maximum_length.to_i})"
+            else
+              t
+            end
+          end
+          
+          def precision
+            self["NUMERIC_PRECISION"]
+          end
+          
+          def scale
+            self["NUMERIC_SCALE"]
+          end
+          
+          def maximum_length
+            self["CHARACTER_MAXIMUM_LENGTH"]
+          end
+        end
+      end      
+
+      module DatabaseMethods
+        include Sequel::Access::DatabaseMethods
+        include Sequel::Database::SplitAlterTable
+    
+        DECIMAL_TYPE_RE = /decimal/io
+        LAST_INSERT_ID = "SELECT @@IDENTITY".freeze
+
+        # Remove cached schema after altering a table, since otherwise it can be cached
+        # incorrectly in the rename column case.
+        def alter_table(name, *)
+          super
+          remove_cached_schema(name)
+          nil
+        end
+
+        # Access doesn't let you disconnect if inside a transaction, so
+        # try rolling back an existing transaction first.
+        def disconnect_connection(conn)
+          conn.RollbackTrans rescue nil
+          super
+        end
+
+        def execute_insert(sql, opts={})
+          synchronize(opts[:server]) do |conn|
+            begin
+              r = log_yield(sql){conn.Execute(sql)}
+              res = log_yield(LAST_INSERT_ID){conn.Execute(LAST_INSERT_ID)}
+              res.getRows.transpose.each{|r| return r.shift}
+            rescue ::WIN32OLERuntimeError => e
+              raise_error(e)
+            end
+          end
+          nil
+        end
+
+        def tables(opts={})
+          m = output_identifier_meth
+          ado_schema_tables.map {|tbl| m.call(tbl['TABLE_NAME'])}
+        end
+
+        def views(opts={})
+          m = output_identifier_meth
+          ado_schema_views.map {|tbl| m.call(tbl['TABLE_NAME'])}
+        end
+        
+        # Note OpenSchema returns compound indexes as multiple rows
+        def indexes(table_name,opts={})
+          m = output_identifier_meth
+          idxs = ado_schema_indexes(table_name).inject({}) do |memo, idx|
+            unless idx["PRIMARY_KEY"]
+              index = memo[m.call(idx["INDEX_NAME"])] ||= {
+                :columns=>[], :unique=>idx["UNIQUE"]
+              }
+              index[:columns] << m.call(idx["COLUMN_NAME"])
+            end
+            memo
+          end
+          idxs
+        end
+
+        # Note OpenSchema returns compound foreign key relationships as multiple rows
+        def foreign_key_list(table, opts={})
+          m = output_identifier_meth
+          fks = ado_schema_foreign_keys(table).inject({}) do |memo, fk|
+            name = m.call(fk['FK_NAME'])
+            specs = memo[name] ||= {
+              :columns => [],
+              :table   => m.call(fk['PK_TABLE_NAME']),
+              :key     => [],
+              :deferrable => fk['DEFERRABILITY'],
+              :name    => name,
+              :on_delete => fk['DELETE_RULE'],
+              :on_update => fk['UPDATE_RULE']
+            }
+            specs[:columns] << m.call(fk['FK_COLUMN_NAME'])
+            specs[:key]     << m.call(fk['PK_COLUMN_NAME'])
+            memo
+          end
+          fks.values
+        end
+                
+        private
+
+        # Emulate rename_column by adding the column, copying data from the old
+        # column, and dropping the old column.
+        def alter_table_sql(table, op)
+          case op[:op]
+          when :rename_column
+            unless sch = op[:schema]
+              raise(Error, "can't find existing schema entry for #{op[:name]}") unless sch = op[:schema] || schema(table).find{|c| c.first == op[:name]}
+              sch = sch.last
+            end
+            [
+              alter_table_sql(table, :op=>:add_column, :name=>op[:new_name], :default=>sch[:ruby_default], :type=>sch[:db_type], :null=>sch[:allow_null]),
+              from(table).update_sql(op[:new_name]=>op[:name]),
+              alter_table_sql(table, :op=>:drop_column, :name=>op[:name])
+            ]
+          when :set_column_null, :set_column_default
+            raise(Error, "can't find existing schema entry for #{op[:name]}") unless sch = op[:schema] || schema(table).find{|c| c.first == op[:name]}
+            sch = sch.last
+
+            sch = if op[:op] == :set_column_null
+              sch.merge(:allow_null=>op[:null])
+            else
+              sch.merge(:ruby_default=>op[:default])
+            end
+
+            [
+              alter_table_sql(table, :op=>:rename_column, :name=>op[:name], :new_name=>:sequel_access_backup_column, :schema=>sch),
+              alter_table_sql(table, :op=>:rename_column, :new_name=>op[:name], :name=>:sequel_access_backup_column, :schema=>sch)
+            ]
+          else
+            super
+          end
+        end
+
+        def begin_transaction(conn, opts={})
+          log_yield('Transaction.begin'){conn.BeginTrans}
+        end
+          
+        def commit_transaction(conn, opts={})
+          log_yield('Transaction.commit'){conn.CommitTrans}
+        end
+          
+        def rollback_transaction(conn, opts={})
+          log_yield('Transaction.rollback'){conn.RollbackTrans}
+        end
+          
+        def schema_column_type(db_type)
+          case db_type.downcase
+          when 'bit'
+            :boolean
+          when 'byte', 'guid'
+            :integer
+          when 'image'
+            :blob
+          else
+            super
+          end
+        end
+        
+        def schema_parse_table(table_name, opts)
+          m = output_identifier_meth(opts[:dataset])
+          m2 = input_identifier_meth(opts[:dataset])
+          tn = m2.call(table_name.to_s)
+          idxs = ado_schema_indexes(tn)
+          ado_schema_columns(tn).map {|row|
+            specs = { 
+              :allow_null => row.allow_null,
+              :db_type => row.db_type,
+              :default => row.default,
+              :primary_key => !!idxs.find {|idx| 
+                                idx["COLUMN_NAME"] == row["COLUMN_NAME"] &&
+                                idx["PRIMARY_KEY"]
+                              },
+              :type =>  if row.db_type =~ DECIMAL_TYPE_RE && row.scale == 0
+                          :integer
+                        else
+                          schema_column_type(row.db_type)
+                        end,
+              :ado_type => row["DATA_TYPE"]
+            }
+            specs[:default] = nil if blank_object?(specs[:default])
+            specs[:allow_null] = specs[:allow_null] && !specs[:primary_key]
+            [ m.call(row["COLUMN_NAME"]), specs ]
+          }
+        end
+
+        def ado_schema_tables
+          rows=[]
+          fetch_ado_schema(:tables, [nil,nil,nil,'TABLE']) do |row|
+            rows << row
+          end
+          rows
+        end
+
+        def ado_schema_views
+          rows=[]
+          fetch_ado_schema(:views, [nil,nil,nil]) do |row|
+            rows << row
+          end
+          rows
+        end
+        
+        def ado_schema_indexes(table_name)
+          rows=[]
+          fetch_ado_schema(:indexes, [nil,nil,nil,nil,table_name.to_s]) do |row|
+            rows << row
+          end
+          rows
+        end
+        
+        def ado_schema_columns(table_name)
+          rows=[]
+          fetch_ado_schema(:columns, [nil,nil,table_name.to_s,nil]) do |row| 
+            rows << AdoSchema::Column.new(row)
+          end
+          rows.sort!{|a,b| a["ORDINAL_POSITION"] <=> b["ORDINAL_POSITION"]}
+        end
+        
+        def ado_schema_foreign_keys(table_name)
+          rows=[]
+          fetch_ado_schema(:foreign_keys, [nil,nil,nil,nil,nil,table_name.to_s]) do |row| 
+            rows << row
+          end
+          rows.sort!{|a,b| a["ORDINAL"] <=> b["ORDINAL"]}
+        end
+        
+        def fetch_ado_schema(type, criteria=[])
+          execute_open_ado_schema(type, criteria) do |s|
+            cols = s.Fields.extend(Enumerable).map {|c| c.Name}
+            s.getRows.transpose.each do |r|
+              row = {}
+              cols.each{|c| row[c] = r.shift}
+              yield row
+            end unless s.eof
+          end
+        end
+             
+        # This is like execute() in that it yields an ADO RecordSet, except
+        # instead of an SQL interface there's this OpenSchema call
+        # cf. http://msdn.microsoft.com/en-us/library/ee275721(v=bts.10)
+        #
+        def execute_open_ado_schema(type, criteria=[])
+          ado_schema = AdoSchema.new(type, criteria)
+          synchronize(opts[:server]) do |conn|
+            begin
+              r = log_yield("OpenSchema #{type.inspect}, #{criteria.inspect}") { 
+                if ado_schema.criteria.empty?
+                  conn.OpenSchema(ado_schema.type) 
+                else
+                  conn.OpenSchema(ado_schema.type, ado_schema.criteria) 
+                end
+              }
+              yield(r) if block_given?
+            rescue ::WIN32OLERuntimeError => e
+              raise_error(e)
+            end
+          end
+          nil
+        end
+      end
+      
+      class Dataset < ADO::Dataset
+        include Sequel::Access::DatasetMethods
+      end
+    end
+  end
+end

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

@@ -11,17 +11,6 @@ module Sequel
         # delete query.
         ROWS_AFFECTED = "SELECT @@ROWCOUNT AS AffectedRows"
         
-        # Return instance of Sequel::ADO::MSSQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::ADO::MSSQL::Dataset.new(self, opts)
-        end
-        
-        # Just execute so it doesn't attempt to return the number of rows modified.
-        def execute_ddl(sql, opts={})
-          execute(sql, opts)
-        end
-        alias execute_insert execute_ddl
-        
         # Issue a separate query to get the rows modified.  ADO appears to
         # use pass by reference with an integer variable, which is obviously
         # not supported directly in ruby, and I'm not aware of a workaround.
@@ -37,11 +26,28 @@ module Sequel
             end
           end
         end
+
+        private
+
+        # The ADO adapter's default provider doesn't support transactions, since it 
+        # creates a new native connection for each query.  So Sequel only attempts
+        # to use transactions if an explicit :provider is given.
+        def begin_transaction(conn, opts={})
+          super if @opts[:provider]
+        end
+
+        def commit_transaction(conn, opts={})
+          super if @opts[:provider]
+        end
+
+        def rollback_transaction(conn, opts={})
+          super if @opts[:provider]
+        end
       end
       
       class Dataset < ADO::Dataset
         include Sequel::MSSQL::DatasetMethods
-        
+
         # Use a nasty hack of multiple SQL statements in the same call and
         # having the last one return the most recently inserted id.  This
         # is necessary as ADO's default :provider uses a separate native

data/lib/sequel/adapters/ado.rb

@@ -4,20 +4,25 @@ module Sequel
   # The ADO adapter provides connectivity to ADO databases in Windows.
   module ADO
     class Database < Sequel::Database
+      DISCONNECT_ERROR_RE = /Communication link failure/
+
       set_adapter_scheme :ado
 
       def initialize(opts)
         super
         case @opts[:conn_string]
         when /Microsoft\.(Jet|ACE)\.OLEDB/io
-          Sequel.ts_require 'adapters/shared/access'
-          extend Sequel::Access::DatabaseMethods
-        when nil
+          Sequel.ts_require 'adapters/ado/access'
+          extend Sequel::ADO::Access::DatabaseMethods
+          @dataset_class = ADO::Access::Dataset
+        else
           @opts[:driver] ||= 'SQL Server'
           case @opts[:driver]
           when 'SQL Server'
             Sequel.ts_require 'adapters/ado/mssql'
             extend Sequel::ADO::MSSQL::DatabaseMethods
+            @dataset_class = ADO::MSSQL::Dataset
+            set_mssql_unicode_strings
           end
         end
       end
@@ -52,10 +57,36 @@ module Sequel
         handle
       end
       
-      def dataset(opts = nil)
-        ADO::Dataset.new(self, opts)
+      def disconnect_connection(conn)
+        conn.Close
       end
-    
+
+      # Just execute so it doesn't attempt to return the number of rows modified.
+      def execute_ddl(sql, opts={})
+        execute(sql, opts)
+      end
+
+      # Just execute so it doesn't attempt to return the number of rows modified.
+      def execute_insert(sql, opts={})
+        execute(sql, opts)
+      end
+      
+      # Use pass by reference in WIN32OLE to get the number of affected rows,
+      # unless is a provider is in use (since some providers don't seem to
+      # return the number of affected rows, but the default provider appears
+      # to).
+      def execute_dui(sql, opts={})
+        return super if opts[:provider]
+        synchronize(opts[:server]) do |conn|
+          begin
+            log_yield(sql){conn.Execute(sql, 1)}
+            WIN32OLE::ARGV[1]
+          rescue ::WIN32OLERuntimeError => e
+            raise_error(e)
+          end
+        end
+      end
+
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
           begin
@@ -74,28 +105,45 @@ module Sequel
       # The ADO adapter's default provider doesn't support transactions, since it 
       # creates a new native connection for each query.  So Sequel only attempts
       # to use transactions if an explicit :provider is given.
-      def _transaction(conn, o={})
-        return super if opts[:provider]
-        th = Thread.current
-        begin
-          @transactions << th
-          yield conn
-        rescue Sequel::Rollback
-        ensure
-          @transactions.delete(th)
-        end
+      def begin_transaction(conn, opts={})
+        super if @opts[:provider]
       end
-      
-      def disconnect_connection(conn)
-        conn.Close
+
+      def commit_transaction(conn, opts={})
+        super if @opts[:provider]
+      end
+
+      def database_error_classes
+        [::WIN32OLERuntimeError]
+      end
+
+      def disconnect_error?(e, opts)
+        super || (e.is_a?(::WIN32OLERuntimeError) && e.message =~ DISCONNECT_ERROR_RE)
+      end
+
+      def rollback_transaction(conn, opts={})
+        super if @opts[:provider]
       end
     end
     
     class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+
       def fetch_rows(sql)
         execute(sql) do |s|
-          @columns = cols = s.Fields.extend(Enumerable).map{|column| output_identifier(column.Name)}
-          s.getRows.transpose.each{|r| yield cols.inject({}){|m,c| m[c] = r.shift; m}} unless s.eof
+          columns = cols = s.Fields.extend(Enumerable).map{|column| output_identifier(column.Name)}
+          if opts[:offset] && offset_returns_row_number_column?
+            rn = row_number_column
+            columns = columns.dup
+            columns.delete(rn)
+          end
+          @columns = columns
+          s.getRows.transpose.each do |r|
+            row = {}
+            cols.each{|c| row[c] = r.shift}
+            row.delete(rn) if rn
+            yield row
+          end unless s.eof
         end
       end
       

data/lib/sequel/adapters/amalgalite.rb

@@ -14,6 +14,12 @@ module Sequel
         'float' => ['float', 'double', 'real', 'double precision'],
         'decimal' => %w'numeric decimal money'
       )
+
+      # Store the related database object, in order to be able to correctly
+      # handle the database timezone.
+      def initialize(db)
+        @db = db
+      end
       
       # Return blobs as instances of Sequel::SQL::Blob instead of
       # Amalgamite::Blob
@@ -29,7 +35,11 @@ module Sequel
       
       # Return datetime types as instances of Sequel.datetime_class
       def datetime(s)
-        Sequel.database_to_application_timestamp(s)
+        @db.to_application_timestamp(s)
+      end
+
+      def time(s)
+        Sequel.string_to_time(s)
       end
       
       # Don't raise an error if the value is a string and the declared
@@ -68,7 +78,8 @@ module Sequel
         opts[:database] = ':memory:' if blank_object?(opts[:database])
         db = ::Amalgalite::Database.new(opts[:database])
         db.busy_handler(::Amalgalite::BusyTimeout.new(opts.fetch(:timeout, 5000)/50, 50))
-        db.type_map = SequelTypeMap.new
+        db.type_map = SequelTypeMap.new(self)
+        connection_pragmas.each{|s| log_yield(s){db.execute_batch(s)}}
         db
       end
       
@@ -77,11 +88,6 @@ module Sequel
         :sqlite
       end
 
-      # Return instance of Sequel::Amalgalite::Dataset with the given options.
-      def dataset(opts = nil)
-        Amalgalite::Dataset.new(self, opts)
-      end
-      
       # Run the given SQL with the given arguments. Returns nil.
       def execute_ddl(sql, opts={})
         _execute(sql, opts){|conn| log_yield(sql){conn.execute_batch(sql)}}
@@ -141,16 +147,13 @@ module Sequel
       def database_error_classes
         [::Amalgalite::Error, ::Amalgalite::SQLite3::Error]
       end
-
-      # Disconnect given connections from the database.
-      def disconnect_connection(c)
-        c.close
-      end
     end
     
     # Dataset class for SQLite datasets that use the amalgalite driver.
     class Dataset < Sequel::Dataset
       include ::Sequel::SQLite::DatasetMethods
+
+      Database::DatasetClass = self
       
       # Yield a hash for each row in the dataset.
       def fetch_rows(sql)
@@ -168,8 +171,8 @@ module Sequel
       private
       
       # Quote the string using the adapter instance method.
-      def literal_string(v)
-        db.synchronize{|c| c.quote(v)}
+      def literal_string_append(sql, v)
+        db.synchronize{|c| sql << c.quote(v)}
       end
     end
   end