asana2flowdock 1.0.0

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/doc/virtual_rows.rdoc

@@ -0,0 +1,272 @@
+= Virtual Row Blocks
+
+Dataset methods where, order, and select all take blocks that are referred to as
+virtual row blocks.  Many other dataset methods pass the blocks
+they are given into one of those three methods, so there are actually
+many Sequel::Dataset methods that take virtual row blocks.
+
+== Why Virtual Rows
+
+Virtual Rows were created to work around the issue that some parts of
+Sequel's standard DSL could not be used on ruby 1.9.  For example, the
+following Sequel code historically worked on ruby 1.8, but not ruby 1.9:
+
+  dataset.where(:a > :b[:c])
+  # WHERE a > b(c)
+  
+This code does not work on ruby 1.9 for two reasons.  First, Symbol#>
+(like other inequality methods) is already defined in ruby 1.9, so Sequel
+does not override it to return an SQL inequality expression.  Second, Symbol#[]
+is already defined on ruby 1.9, so Sequel does not override it to return an
+SQL function expression.
+
+It's possible to use Sequel's DSL to represent such expressions, but it is a
+little verbose:
+
+  dataset.where(Sequel.expr(:a) > Sequel.function(:b, :c))
+  # WHERE a > b(c)
+
+The virtual row DSL makes such code more concise:
+
+  dataset.where{a > b(c)}
+
+== Regular Procs vs Instance Evaled Procs
+
+Virtual row blocks behave differently depending on whether the block accepts
+an argument.  If the block accepts an argument, it is called with an instance
+of Sequel::SQL::VirtualRow.  If it does not accept an argument, it is
+evaluated in the context of an instance of Sequel::SQL::VirtualRow.
+
+  ds = DB[:items]
+  # Regular proc
+  ds.where{|o| o.column > 1}
+  # WHERE column > 1
+  
+  # Instance-evaled proc
+  ds.where{column > 1}
+  # WHERE column > 1
+  
+If you aren't familiar with the difference between regular blocks and instance
+evaled blocks, you should probably consult a general ruby reference, but briefly,
+with regular procs, methods called without an explicit receiver inside the
+proc call the method on the receiver in the surrounding scope, while instance
+evaled procs call the method on the receiver of the instance_eval call.  However,
+in both cases, local variables available in the surrounding scope will be available
+inside the proc.  If that doesn't make sense, maybe this example will help:
+
+  def self.a
+    42
+  end
+  b = 32
+  
+  # Regular proc
+  ds.where{|o| o.c > a - b}
+  # WHERE c > 10
+  
+  # Instance-evaled proc
+  ds.where{c > a - b}
+  # WHERE c > (a - 32)
+  
+There are two related differences here.  First is the usage of <tt>o.c</tt> vs +c+,
+and second is the difference between the use of +a+.  In the regular proc,
+you couldn't call +c+ without an explicit receiver in the proc, unless the self of the
+surrounding scope responded to it.  For +a+, note how ruby calls the method on
+the receiver of the surrounding scope in the regular proc, which returns an integer,
+and does the subtraction before Sequel gets access to it.  In the instance evaled
+proc, calling +a+ without a receiver calls the a method on the VirtualRow instance.
+For +b+, note that it operates the same in both cases, as it is a local variable.
+
+Basically, the choice for whether to use a regular proc or an instance evaled proc is
+completely up to you.  The same things can be accomplished with both.
+Instance evaled procs tend to produce shorter code, but by modifying the scope
+can be more difficult for a new user to understand.  That being said, I usually
+use instance evaled procs unless I need to call methods on the receiver of the
+surrounding scope inside the proc.
+
+== Local Variables vs Method Calls
+
+If you have a method that accepts 0 arguments and has the same name as a local
+variable, you can call it with () to differentiate the method call from the
+local variable access.  This is mostly useful in instance_evaled procs:
+
+  b = 32
+  ds.where{b() > b}
+  # WHERE b > 32
+
+== VirtualRow Methods
+
+VirtualRow is a class that returns SQL::Identifiers, SQL::QualifiedIdentifiers, or
+SQL::Functions depending on how it is called.
+
+== SQL::Identifiers - Regular columns
+
+SQL::Identifiers can be thought of as regular column references in SQL,
+not qualified by any table. You get an SQL::Identifier if the method is called
+without a block or arguments, and doesn't have a double underscore in the method
+name:
+
+  ds.where{|o| o.column > 1}
+  ds.where{column > 1}
+  # WHERE column > 1
+  
+== SQL::QualifiedIdentifiers - Qualified columns
+
+SQL::QualifiedIdentifiers can be thought of as column references in SQL that
+are qualified to a specific table.  You get an SQL::QualifiedIdentifier if
+the method is called without a block or arguments, and has a double underscore
+in the method name:
+
+  ds.where{|o| o.table__column > 1}
+  ds.where{table__column > 1}
+  # 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.
+
+== SQL::Functions - SQL function calls
+
+SQL::Functions can be thought of as function calls in SQL.  You get a simple
+function call if you call a method with arguments and without a block:
+
+  ds.where{|o| o.function(1) > 1}
+  ds.where{function(1) > 1}
+  # WHERE function(1) > 1
+  
+To call a SQL function with multiple arguments, just use those arguments in
+your function call:
+  
+  ds.where{|o| o.function(1, o.a) > 1}
+  ds.where{function(1, a) > 1}
+  # WHERE function(1, a) > 1
+
+If the SQL function does not accept any arguments, create an identifier, then
+call the function method on it to produce a function:
+
+  ds.select{|o| o.version.function}
+  ds.select{version.function}
+  # SELECT version()
+  
+To use the SQL wildcard (*) as the sole argument in a function call, create a
+function without arguments, then call the * method on the function:
+  
+  ds.select{|o| o.count.function.*}
+  ds.select{count.function.*}
+  # SELECT count(*)
+
+To append the DISTINCT keyword before the method arguments, just call the
+distinct method on the returned Function:
+
+  ds.select{|o| o.count(o.col1).distinct}
+  ds.select{count(col1).distinct}
+  # SELECT count(DISTINCT col1)
+  
+  ds.select{|o| o.count(o.col1, o.col2).distinct}
+  ds.select{count(col1, col2).distinct}
+  # SELECT count(DISTINCT col1, col2)
+  
+== SQL::Functions with windows - SQL window function calls
+
+Not all databases support window functions, but they are very helpful for certain types of
+queries.  To use them, you should just call the over method on the Function
+object returned, with the options for the window:
+
+  ds.select{|o| o.rank.function.over}
+  ds.select{rank.function.over}
+  # SELECT rank() OVER ()
+  
+  ds.select{|o| o.count.function.*.over}
+  ds.select{count.function.*.over}
+  # SELECT count(*) OVER ()
+  
+  ds.select{|o| o.sum(o.col1).over(:partition=>o.col2, :order=>o.col3)}
+  ds.select{sum(col1).over(:partition=>col2, :order=>col3)}
+  # SELECT sum(col1) OVER (PARTITION BY col2 ORDER BY col3)
+
+== Operators
+
+VirtualRows use method_missing to handle almost all method calls.  However, they
+have special handling of some operator methods to make certain things easier. The
+operators all use a prefix form.
+
+=== Math Operators
+
+The standard +, -, *, and / mathematical operators are defined:
+
+  ds.select{|o| o.-(1, o.a).as(b)}
+  ds.select{self.-(1, a).as(b)}
+  # SELECT (1 - a) AS b
+
+=== Boolean Operators
+
+The & and | methods are defined to use AND and OR:
+
+  ds.where{|o| o.&({:a=>:b}, :c)}
+  ds.where{self.&({:a=>:b}, :c)}
+  # WHERE ((a = b) AND c)
+
+The ~ method is defined to do inversion:
+
+  ds.where{|o| o.~({:a=>1, :b=>2})}
+  ds.where{self.~({:a=>1, :b=>2})}
+  # WHERE ((a != 1) OR (b != 2))
+
+=== Inequality Operators
+
+The standard >, <, >=, and <= inequality operators are defined:
+
+  ds.where{|o| o.>(1, :c)}
+  ds.where{self.>(1, :c)}
+  # WHERE (1 > c)
+
+== Literal Strings
+
+The backtick operator can be used inside an instance-evaled
+virtual row block to create a literal string:
+
+  ds.where{a > `some SQL`}
+  # WHERE (a > some SQL)
+
+You can use this on a regular virtual row block too, but it
+doesn't look as nice:
+
+  ds.where{|o| o.>(:a, o.`('some SQL'))}
+
+== Returning multiple values
+
+It's common when using select and order virtual row blocks to want to
+return multiple values.  If you want to do that, you just need to return an 
+array:
+
+  ds.select{|o| [o.column1, o.sum(o.column2).as(o.sum)]}
+  ds.select{[column1, sum(column2).as(sum)]}
+  # SELECT column1, sum(column2) AS sum
+  
+Note that if you forget the array brackets, you'll end up with a syntax error:
+
+  # Invalid ruby syntax
+  ds.select{|o| o.column1, o.sum(o.column2).as(o.sum)}
+  ds.select{column1, sum(column2).as(sum)}
+  
+== Alternative Description of the VirtualRow method call rules
+
+* If a block is given:
+  * The block is currently not called.  This may change in a future version.
+  * If there are no arguments, an SQL::Function with the name of
+    method used, and no arguments.
+  * If the first argument is :*, an SQL::Function is created with a single
+    wildcard argument (*).
+  * If the first argument is :distinct, an SQL::Function is created with
+    the keyword DISTINCT prefacing all remaining arguments.
+  * If the first argument is :over, the second argument if provided should
+    be a hash of options to pass to SQL::Window.  The options hash can also
+    contain :*=>true to use a wildcard argument as the function argument, or
+    :args=>... to specify an array of arguments to use as the function arguments.
+* If a block is not given:
+  * If there are arguments, an SQL::Function is returned with the
+    name of the method used and the arguments given.
+  * If there are no arguments and the method contains a double
+    underscore, split on the double underscore and return an
+    SQL::QualifiedIdentifier with the table and column.
+  * Otherwise, create an SQL::Identifier with the name of the
+    method.

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel.rb

@@ -0,0 +1 @@
+require 'sequel/model'

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/adapters/ado.rb

@@ -0,0 +1,151 @@
+require 'win32ole'
+
+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
+
+      # In addition to the usual database options,
+      # the following options have an effect:
+      #
+      # :command_timeout :: Sets the time in seconds to wait while attempting
+      #                     to execute a command before cancelling the attempt and generating
+      #                     an error. Specifically, it sets the ADO CommandTimeout property.
+      #                     If this property is not set, the default of 30 seconds is used.
+      # :driver :: The driver to use in the ADO connection string.  If not provided, a default
+      #            of "SQL Server" is used.
+      # :conn_string :: The full ADO connection string.  If this is provided,
+      #                 the usual options are ignored.
+      # :provider :: Sets the Provider of this ADO connection (for example, "SQLOLEDB").
+      #              If you don't specify a provider, the default one used by WIN32OLE
+      #              has major problems, such as creating a new native database connection
+      #              for every query, which breaks things such as temporary tables.
+      #
+      # Pay special attention to the :provider option, as without specifying a provider,
+      # many things will be broken.  The SQLNCLI10 provider appears to work well if you
+      # are connecting to Microsoft SQL Server, but it is not the default as that would
+      # break backwards compatability.
+      def connect(server)
+        opts = server_opts(server)
+        s = opts[:conn_string] || "driver=#{opts[:driver]};server=#{opts[:host]};database=#{opts[:database]}#{";uid=#{opts[:user]};pwd=#{opts[:password]}" if opts[:user]}"
+        handle = WIN32OLE.new('ADODB.Connection')
+        handle.CommandTimeout = opts[:command_timeout] if opts[:command_timeout]
+        handle.Provider = opts[:provider] if opts[:provider]
+        handle.Open(s)
+        handle
+      end
+      
+      def disconnect_connection(conn)
+        conn.Close
+      rescue WIN32OLERuntimeError
+        nil
+      end
+
+      # Just execute so it doesn't attempt to return the number of rows modified.
+      def execute_ddl(sql, opts=OPTS)
+        execute(sql, opts)
+      end
+
+      # Just execute so it doesn't attempt to return the number of rows modified.
+      def execute_insert(sql, opts=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=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=OPTS)
+        synchronize(opts[:server]) do |conn|
+          begin
+            r = log_yield(sql){conn.Execute(sql)}
+            yield(r) if block_given?
+          rescue ::WIN32OLERuntimeError => e
+            raise_error(e)
+          end
+        end
+        nil
+      end
+
+      private
+      
+      def adapter_initialize
+        case @opts[:conn_string]
+        when /Microsoft\.(Jet|ACE)\.OLEDB/io
+          Sequel.require 'adapters/ado/access'
+          extend Sequel::ADO::Access::DatabaseMethods
+          self.dataset_class = ADO::Access::Dataset
+        else
+          @opts[:driver] ||= 'SQL Server'
+          case @opts[:driver]
+          when 'SQL Server'
+            Sequel.require 'adapters/ado/mssql'
+            extend Sequel::ADO::MSSQL::DatabaseMethods
+            self.dataset_class = ADO::MSSQL::Dataset
+            set_mssql_unicode_strings
+          end
+        end
+        super
+      end
+
+      # 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=OPTS)
+        super if @opts[:provider]
+      end
+
+      def commit_transaction(conn, opts=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=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)}
+          @columns = columns
+          s.getRows.transpose.each do |r|
+            row = {}
+            cols.each{|c| row[c] = r.shift}
+            yield row
+          end unless s.eof
+        end
+      end
+      
+      # ADO returns nil for all for delete and update statements.
+      def provides_accurate_rows_matched?
+        false
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/adapters/ado/access.rb

@@ -0,0 +1,335 @@
+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
+        extend Sequel::Database::ResetIdentifierMangling
+        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=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=OPTS)
+          m = output_identifier_meth
+          ado_schema_tables.map {|tbl| m.call(tbl['TABLE_NAME'])}
+        end
+
+        def views(opts=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=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=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=OPTS)
+          log_yield('Transaction.begin'){conn.BeginTrans}
+        end
+          
+        def commit_transaction(conn, opts=OPTS)
+          log_yield('Transaction.commit'){conn.CommitTrans}
+        end
+          
+        def rollback_transaction(conn, opts=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