asana2flowdock 1.0.0

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

@@ -0,0 +1,82 @@
+Sequel.require 'adapters/shared/sqlanywhere'
+Sequel.require 'adapters/jdbc/transactions'
+
+module Sequel
+  module JDBC
+    drv = [
+      lambda{Java::sybase.jdbc4.sqlanywhere.IDriver},
+      lambda{Java::ianywhere.ml.jdbcodbc.jdbc4.IDriver},
+      lambda{Java::sybase.jdbc.sqlanywhere.IDriver},
+      lambda{Java::ianywhere.ml.jdbcodbc.jdbc.IDriver},
+      lambda{Java::com.sybase.jdbc4.jdbc.Sybdriver},
+      lambda{Java::com.sybase.jdbc3.jdbc.Sybdriver}
+    ].each do |class_proc|
+      begin
+        break class_proc.call
+      rescue NameError
+      end
+    end
+    raise(Sequel::AdapterNotFound, "no suitable SQLAnywhere JDBC driver found") unless drv
+
+    Sequel.synchronize do
+      DATABASE_SETUP[:sqlanywhere] = proc do |db|
+        db.extend(Sequel::JDBC::SqlAnywhere::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::SqlAnywhere::Dataset
+        drv
+      end
+    end
+
+    class TypeConvertor
+      def SqlAnywhereBoolean(r, i)
+        if v = Short(r, i)
+          v != 0
+        end
+      end
+    end
+
+    module SqlAnywhere
+      # Database instance methods for Sybase databases accessed via JDBC.
+      module DatabaseMethods
+        extend Sequel::Database::ResetIdentifierMangling
+        include Sequel::SqlAnywhere::DatabaseMethods
+        include Sequel::JDBC::Transactions
+
+        LAST_INSERT_ID = 'SELECT @@IDENTITY'.freeze
+
+        private
+
+        # Get the last inserted id.
+        def last_insert_id(conn, opts=OPTS)
+          statement(conn) do |stmt|
+            sql = LAST_INSERT_ID
+            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs.next
+            rs.getInt(1)
+          end
+        end
+
+        def setup_type_convertor_map
+          super
+          @type_convertor_map[:SqlAnywhereBoolean] = TypeConvertor::INSTANCE.method(:SqlAnywhereBoolean)
+        end
+      end
+
+      #Dataset class for Sybase datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::SqlAnywhere::DatasetMethods
+
+        private
+
+        SMALLINT_TYPE = Java::JavaSQL::Types::SMALLINT
+
+        def type_convertor(map, meta, type, i)
+          if convert_smallint_to_bool && type == SMALLINT_TYPE
+            map[:SqlAnywhereBoolean]
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+Sequel::JDBC.load_driver('org.sqlite.JDBC', :SQLite3)
+Sequel.require 'adapters/shared/sqlite'
+
+module Sequel
+  module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:sqlite] = proc do |db|
+        db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
+        db.extend_datasets Sequel::SQLite::DatasetMethods
+        db.set_integer_booleans
+        org.sqlite.JDBC
+      end
+    end
+
+    # Database and Dataset support for SQLite databases accessed via JDBC.
+    module SQLite
+      # Instance methods for SQLite Database objects accessed via JDBC.
+      module DatabaseMethods
+        extend Sequel::Database::ResetIdentifierMangling
+        include Sequel::SQLite::DatabaseMethods
+        LAST_INSERT_ROWID = 'SELECT last_insert_rowid()'.freeze
+        FOREIGN_KEY_ERROR_RE = /query does not return ResultSet/.freeze
+        
+        # Swallow pointless exceptions when the foreign key list pragma
+        # doesn't return any rows.
+        def foreign_key_list(table, opts=OPTS)
+          super
+        rescue Sequel::DatabaseError => e
+          raise unless e.message =~ FOREIGN_KEY_ERROR_RE
+          []
+        end
+
+        # Swallow pointless exceptions when the index list pragma
+        # doesn't return any rows.
+        def indexes(table, opts=OPTS)
+          super
+        rescue Sequel::DatabaseError => e
+          raise unless e.message =~ FOREIGN_KEY_ERROR_RE
+          {}
+        end
+
+        private
+        
+        DATABASE_ERROR_REGEXPS = Sequel::SQLite::DatabaseMethods::DATABASE_ERROR_REGEXPS.merge(/Abort due to constraint violation/ => ConstraintViolation).freeze
+        def database_error_regexps
+          DATABASE_ERROR_REGEXPS
+        end
+
+        # Use last_insert_rowid() to get the last inserted id.
+        def last_insert_id(conn, opts=OPTS)
+          statement(conn) do |stmt|
+            rs = stmt.executeQuery(LAST_INSERT_ROWID)
+            rs.next
+            rs.getInt(1)
+          end
+        end
+        
+        # Default to a single connection for a memory database.
+        def connection_pool_default_options
+          o = super
+          uri == 'jdbc:sqlite::memory:' ? o.merge(:max_connections=>1) : o
+        end
+        
+        # Execute the connection pragmas on the connection.
+        def setup_connection(conn)
+          conn = super(conn)
+          statement(conn) do |stmt|
+            connection_pragmas.each{|s| log_yield(s){stmt.execute(s)}}
+          end
+          conn
+        end
+
+        # Use getLong instead of getInt for converting integers on SQLite, since SQLite does not enforce a limit of 2**32.
+        def setup_type_convertor_map
+          super
+          @type_convertor_map[Java::JavaSQL::Types::INTEGER] = @type_convertor_map[Java::JavaSQL::Types::BIGINT]
+          @basic_type_convertor_map[Java::JavaSQL::Types::INTEGER] = @basic_type_convertor_map[Java::JavaSQL::Types::BIGINT]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+Sequel::JDBC.load_driver('com.microsoft.sqlserver.jdbc.SQLServerDriver')
+Sequel.require 'adapters/jdbc/mssql'
+
+module Sequel
+  module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:sqlserver] = proc do |db|
+        db.extend(Sequel::JDBC::SQLServer::DatabaseMethods)
+        db.extend_datasets Sequel::MSSQL::DatasetMethods
+        db.send(:set_mssql_unicode_strings)
+        com.microsoft.sqlserver.jdbc.SQLServerDriver
+      end
+    end
+
+    # Database and Dataset instance methods for SQLServer specific
+    # support via JDBC.
+    module SQLServer
+      # Database instance methods for SQLServer databases accessed via JDBC.
+      module DatabaseMethods
+        extend Sequel::Database::ResetIdentifierMangling
+        include Sequel::JDBC::MSSQL::DatabaseMethods
+
+        # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
+        # for the getColumns result set specifies an incorrect type for the
+        # IS_AUTOINCREMENT column. The column is a string, but the type is
+        # specified as a short. This causes getObject() to throw a
+        # com.microsoft.sqlserver.jdbc.SQLServerException: "The conversion
+        # from char to SMALLINT is unsupported." Using getString() rather
+        # than getObject() for this column avoids the problem.
+        # Reference: http://social.msdn.microsoft.com/Forums/en/sqldataaccess/thread/20df12f3-d1bf-4526-9daa-239a83a8e435
+        module MetadataDatasetMethods
+          def type_convertor(map, meta, type, i)
+            if output_identifier(meta.getColumnLabel(i)) == :is_autoincrement
+              map[Java::JavaSQL::Types::VARCHAR]
+            else
+              super
+            end
+          end
+
+          def basic_type_convertor(map, meta, type, i)
+            if output_identifier(meta.getColumnLabel(i)) == :is_autoincrement
+              map[Java::JavaSQL::Types::VARCHAR]
+            else
+              super
+            end
+          end
+        end
+        
+        def metadata_dataset
+          super.extend(MetadataDatasetMethods)
+        end
+
+        private
+
+        def disconnect_error?(exception, opts)
+          super || (exception.message =~ /connection is closed/)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+module Sequel
+  module JDBC
+    module Transactions
+      TRANSACTION_BEGIN = 'Transaction.begin'.freeze
+      TRANSACTION_COMMIT = 'Transaction.commit'.freeze
+      TRANSACTION_RELEASE_SP = 'Transaction.release_savepoint'.freeze
+      TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+      TRANSACTION_ROLLBACK_SP = 'Transaction.rollback_savepoint'.freeze
+      TRANSACTION_SAVEPOINT= 'Transaction.savepoint'.freeze
+
+      # Check the JDBC DatabaseMetaData for savepoint support
+      def supports_savepoints?
+        return @supports_savepoints if defined?(@supports_savepoints)
+        @supports_savepoints = synchronize{|c| c.getMetaData.supports_savepoints}
+      end
+
+      # Check the JDBC DatabaseMetaData for support for serializable isolation,
+      # since that's the value most people will use.
+      def supports_transaction_isolation_levels?
+        synchronize{|conn| conn.getMetaData.supportsTransactionIsolationLevel(JavaSQL::Connection::TRANSACTION_SERIALIZABLE)}
+      end
+
+      private
+
+      JDBC_TRANSACTION_ISOLATION_LEVELS = {:uncommitted=>JavaSQL::Connection::TRANSACTION_READ_UNCOMMITTED,
+        :committed=>JavaSQL::Connection::TRANSACTION_READ_COMMITTED,
+        :repeatable=>JavaSQL::Connection::TRANSACTION_REPEATABLE_READ,
+        :serializable=>JavaSQL::Connection::TRANSACTION_SERIALIZABLE}
+
+      # Set the transaction isolation level on the given connection using
+      # the JDBC API.
+      def set_transaction_isolation(conn, opts)
+        level = opts.fetch(:isolation, transaction_isolation_level)
+        if (jdbc_level = JDBC_TRANSACTION_ISOLATION_LEVELS[level]) &&
+            conn.getMetaData.supportsTransactionIsolationLevel(jdbc_level)
+          _trans(conn)[:original_jdbc_isolation_level] = conn.getTransactionIsolation
+          log_yield("Transaction.isolation_level = #{level}"){conn.setTransactionIsolation(jdbc_level)}
+        end
+      end
+
+      # Most JDBC drivers that support savepoints support releasing them.
+      def supports_releasing_savepoints?
+        true
+      end
+
+      # Use JDBC connection's setAutoCommit to false to start transactions
+      def begin_transaction(conn, opts=OPTS)
+        if supports_savepoints?
+          th = _trans(conn)
+          if sps = th[:savepoint_objs]
+            sps << log_yield(TRANSACTION_SAVEPOINT){conn.set_savepoint}
+          else
+            log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+            th[:savepoint_objs] = []
+            set_transaction_isolation(conn, opts)
+          end
+        else
+          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+          set_transaction_isolation(conn, opts)
+        end
+      end
+      
+      # Use JDBC connection's commit method to commit transactions
+      def commit_transaction(conn, opts=OPTS)
+        if supports_savepoints?
+          sps = _trans(conn)[:savepoint_objs]
+          if sps.empty?
+            log_yield(TRANSACTION_COMMIT){conn.commit}
+          elsif supports_releasing_savepoints?
+            log_yield(TRANSACTION_RELEASE_SP){supports_releasing_savepoints? ? conn.release_savepoint(sps.last) : sps.last}
+          end
+        else
+          log_yield(TRANSACTION_COMMIT){conn.commit}
+        end
+      end
+      
+      # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
+      def remove_transaction(conn, committed)
+        if jdbc_level = _trans(conn)[:original_jdbc_isolation_level]
+          conn.setTransactionIsolation(jdbc_level)
+        end
+        if supports_savepoints?
+          sps = _trans(conn)[:savepoint_objs]
+          conn.setAutoCommit(true) if sps.empty?
+          sps.pop
+        else
+          conn.setAutoCommit(true)
+        end
+      ensure
+        super
+      end
+      
+      # Use JDBC connection's rollback method to rollback transactions
+      def rollback_transaction(conn, opts=OPTS)
+        if supports_savepoints?
+          sps = _trans(conn)[:savepoint_objs]
+          if sps.empty?
+            log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+          else
+            log_yield(TRANSACTION_ROLLBACK_SP){conn.rollback(sps.last)}
+          end
+        else
+          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,391 @@
+module Sequel
+  module Mock
+    # Connection class for Sequel's mock adapter.
+    class Connection
+      # Sequel::Mock::Database object that created this connection
+      attr_reader :db
+
+      # Shard this connection operates on, when using Sequel's
+      # sharding support (always :default for databases not using
+      # sharding).
+      attr_reader :server
+
+      # The specific database options for this connection.
+      attr_reader :opts
+
+      # Store the db, server, and opts.
+      def initialize(db, server, opts)
+        @db = db
+        @server = server
+        @opts = opts
+      end
+
+      # Delegate to the db's #_execute method.
+      def execute(sql)
+        @db.send(:_execute, self, sql, :log=>false) 
+      end
+    end
+
+    # Database class for Sequel's mock adapter.
+    class Database < Sequel::Database
+      set_adapter_scheme :mock
+
+      # Map of database type names to module names, used for handling
+      # mock adapters for specific database types.
+      SHARED_ADAPTERS = {
+        'access'=>'Access',
+        'cubrid'=>'Cubrid',
+        'db2'=>'DB2',
+        'firebird'=>'Firebird',
+        'fdbsql'=>'Fdbsql',
+        'informix'=>'Informix',
+        'mssql'=>'MSSQL',
+        'mysql'=>'MySQL',
+        'oracle'=>'Oracle',
+        'postgres'=>'Postgres',
+        'sqlanywhere'=>'SqlAnywhere',
+        'sqlite'=>'SQLite'
+      }
+
+      # Procs to run for specific database types to get the mock adapter
+      # to work with the shared adapter
+      SHARED_ADAPTER_SETUP = {
+        'postgres' => lambda do |db|
+          db.instance_eval do
+            @server_version = 90400
+            initialize_postgres_adapter
+          end
+          db.extend(Module.new do
+            def bound_variable_arg(arg, conn)
+              arg
+            end
+
+            def primary_key(table)
+              :id
+            end
+          end)
+        end,
+        'oracle' => lambda do |db|
+          db.instance_eval do
+            @primary_key_sequences = {}
+          end
+        end,
+        'mysql' => lambda do |db|
+          db.instance_eval do
+            @server_version = 50617
+          end
+        end,
+        'mssql' => lambda do |db|
+          db.instance_eval do
+            @server_version = 11000000
+          end
+        end,
+        'sqlite' => lambda do |db|
+          db.instance_eval do
+            @sqlite_version = 30804
+          end
+        end
+      }
+
+      # Set the autogenerated primary key integer
+      # to be returned when running an insert query.
+      # Argument types supported:
+      #
+      # nil :: Return nil for all inserts
+      # Integer :: Starting integer for next insert, with
+      #            futher inserts getting an incremented
+      #            value
+      # Array :: First insert gets the first value in the
+      #          array, second gets the second value, etc.
+      # Proc :: Called with the insert SQL query, uses
+      #         the value returned
+      # Class :: Should be an Exception subclass, will create a new
+      #          instance an raise it wrapped in a DatabaseError.
+      attr_writer :autoid
+
+      # Set the columns to set in the dataset when the dataset fetches
+      # rows.  Argument types supported:
+      # nil :: Set no columns
+      # Array of Symbols: Used for all datasets
+      # Array (otherwise): First retrieval gets the first value in the
+      #                    array, second gets the second value, etc.
+      # Proc :: Called with the select SQL query, uses the value
+      #         returned, which should be an array of symbols
+      attr_writer :columns
+
+      # Set the hashes to yield by execute when retrieving rows.
+      # Argument types supported:
+      #
+      # nil :: Yield no rows
+      # Hash :: Always yield a single row with this hash
+      # Array of Hashes :: Yield separately for each hash in this array
+      # Array (otherwise) :: First retrieval gets the first value
+      #                      in the array, second gets the second value, etc.
+      # Proc :: Called with the select SQL query, uses
+      #         the value returned, which should be a hash or
+      #         array of hashes.
+      # Class :: Should be an Exception subclass, will create a new
+      #          instance an raise it wrapped in a DatabaseError.
+      attr_writer :fetch
+
+      # Set the number of rows to return from update or delete.
+      # Argument types supported:
+      #
+      # nil :: Return 0 for all updates and deletes
+      # Integer :: Used for all updates and deletes
+      # Array :: First update/delete gets the first value in the
+      #          array, second gets the second value, etc.
+      # Proc :: Called with the update/delete SQL query, uses
+      #         the value returned.
+      # Class :: Should be an Exception subclass, will create a new
+      #          instance an raise it wrapped in a DatabaseError.
+      attr_writer :numrows
+
+      # Mock the server version, useful when using the shared adapters
+      attr_accessor :server_version
+
+      # Return a related Connection option connecting to the given shard.
+      def connect(server)
+        Connection.new(self, server, server_opts(server))
+      end
+
+      def disconnect_connection(c)
+      end
+
+      # Store the sql used for later retrieval with #sqls, and return
+      # the appropriate value using either the #autoid, #fetch, or
+      # #numrows methods.
+      def execute(sql, opts=OPTS, &block)
+        synchronize(opts[:server]){|c| _execute(c, sql, opts, &block)} 
+      end
+      alias execute_ddl execute
+
+      # Store the sql used, and return the value of the #numrows method.
+      def execute_dui(sql, opts=OPTS)
+        execute(sql, opts.merge(:meth=>:numrows))
+      end
+
+      # Store the sql used, and return the value of the #autoid method.
+      def execute_insert(sql, opts=OPTS)
+        execute(sql, opts.merge(:meth=>:autoid))
+      end
+
+      # Return all stored SQL queries, and clear the cache
+      # of SQL queries.
+      def sqls
+        s = @sqls.dup
+        @sqls.clear
+        s
+      end
+
+      # Enable use of savepoints.
+      def supports_savepoints?
+        shared_adapter? ? super : true
+      end
+
+      private
+
+      def _autoid(sql, v, ds=nil)
+        case v
+        when Integer
+          if ds
+            ds.autoid += 1 if ds.autoid.is_a?(Integer)
+          else
+            @autoid += 1
+          end
+          v
+        else
+          _nextres(v, sql, nil)
+        end
+      end
+
+      def _execute(c, sql, opts=OPTS, &block)
+        sql += " -- args: #{opts[:arguments].inspect}" if opts[:arguments]
+        sql += " -- #{@opts[:append]}" if @opts[:append]
+        sql += " -- #{c.server.is_a?(Symbol) ? c.server : c.server.inspect}" if c.server != :default
+        log_info(sql) unless opts[:log] == false
+        @sqls << sql 
+
+        ds = opts[:dataset]
+        begin
+          if block
+            columns(ds, sql) if ds
+            _fetch(sql, (ds._fetch if ds) || @fetch, &block)
+          elsif meth = opts[:meth]
+            if meth == :numrows
+              _numrows(sql, (ds.numrows if ds) || @numrows)
+            else
+              v = ds.autoid if ds
+              _autoid(sql, v || @autoid, (ds if v))
+            end
+          end
+        rescue => e
+          raise_error(e)
+        end
+      end
+
+      def _fetch(sql, f, &block)
+        case f
+        when Hash
+          yield f.dup
+        when Array
+          if f.all?{|h| h.is_a?(Hash)}
+            f.each{|h| yield h.dup}
+          else
+            _fetch(sql, f.shift, &block)
+          end
+        when Proc
+          h = f.call(sql)
+          if h.is_a?(Hash)
+            yield h.dup
+          elsif h
+            h.each{|h1| yield h1.dup}
+          end
+        when Class
+          if f < Exception
+            raise f
+          else
+            raise Error, "Invalid @autoid/@numrows attribute: #{v.inspect}"
+          end
+        when nil
+          # nothing
+        else
+          raise Error, "Invalid @fetch attribute: #{f.inspect}"
+        end
+      end
+
+      def _nextres(v, sql, default)
+        case v
+        when Integer
+          v
+        when Array
+          v.empty? ? default : _nextres(v.shift, sql, default)
+        when Proc
+          v.call(sql)
+        when Class
+          if v < Exception
+            raise v
+          else
+            raise Error, "Invalid @autoid/@numrows attribute: #{v.inspect}"
+          end
+        when nil
+          default
+        else
+          raise Error, "Invalid @autoid/@numrows attribute: #{v.inspect}"
+        end
+      end
+
+      def _numrows(sql, v)
+        _nextres(v, sql, 0)
+      end
+
+      # Additional options supported:
+      #
+      # :autoid :: Call #autoid= with the value
+      # :columns :: Call #columns= with the value
+      # :fetch ::  Call #fetch= with the value
+      # :numrows :: Call #numrows= with the value
+      # :extend :: A module the object is extended with.
+      # :sqls :: The array to store the SQL queries in.
+      def adapter_initialize
+        opts = @opts
+        @sqls = opts[:sqls] || []
+        if mod_name = SHARED_ADAPTERS[opts[:host]]
+          @shared_adapter = true
+          require "sequel/adapters/shared/#{opts[:host]}"
+          extend Sequel.const_get(mod_name)::DatabaseMethods
+          extend_datasets Sequel.const_get(mod_name)::DatasetMethods
+          if pr = SHARED_ADAPTER_SETUP[opts[:host]]
+            pr.call(self)
+          end
+        else
+          @shared_adapter = false
+        end
+        self.autoid = opts[:autoid]
+        self.columns = opts[:columns]
+        self.fetch = opts[:fetch]
+        self.numrows = opts[:numrows]
+        extend(opts[:extend]) if opts[:extend]
+        sqls
+      end
+
+      def columns(ds, sql, cs=@columns)
+        case cs
+        when Array
+          unless cs.empty?
+            if cs.all?{|c| c.is_a?(Symbol)}
+              ds.columns(*cs)
+            else
+              columns(ds, sql, cs.shift)
+            end
+          end
+        when Proc
+          ds.columns(*cs.call(sql))
+        when nil
+          # nothing
+        else
+          raise Error, "Invalid @columns attribute: #{cs.inspect}"
+        end
+      end
+
+      def quote_identifiers_default
+        shared_adapter? ? super : false
+      end
+
+      def identifier_input_method_default
+        shared_adapter? ? super : nil
+      end
+
+      def identifier_output_method_default
+        shared_adapter? ? super : nil
+      end
+
+      def shared_adapter?
+        @shared_adapter
+      end
+    end
+
+    class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+
+      # Override the databases's autoid setting for this dataset
+      attr_accessor :autoid
+
+      # Override the databases's fetch setting for this dataset
+      attr_accessor :_fetch
+
+      # Override the databases's numrows setting for this dataset
+      attr_accessor :numrows
+
+      # If arguments are provided, use them to set the columns
+      # for this dataset and return self.  Otherwise, use the
+      # default Sequel behavior and return the columns.
+      def columns(*cs)
+        if cs.empty?
+          super
+        else
+          @columns = cs
+          self
+        end
+      end
+
+      def fetch_rows(sql, &block)
+        execute(sql, &block)
+      end
+
+      private
+
+      def execute(sql, opts=OPTS, &block)
+        super(sql, opts.merge(:dataset=>self), &block)
+      end
+
+      def execute_dui(sql, opts=OPTS, &block)
+        super(sql, opts.merge(:dataset=>self), &block)
+      end
+
+      def execute_insert(sql, opts=OPTS, &block)
+        super(sql, opts.merge(:dataset=>self), &block)
+      end
+    end
+  end
+end