viking-sequel 3.10.0

data/lib/sequel/adapters/db2.rb

@@ -0,0 +1,139 @@
+require 'db2/db2cli'
+
+module Sequel
+  module DB2
+    class Database < Sequel::Database
+      set_adapter_scheme :db2
+
+      include DB2CLI
+
+      TEMPORARY = 'GLOBAL TEMPORARY '.freeze
+      
+      rc, @@env = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE)
+      #check_error(rc, "Could not allocate DB2 environment")
+
+      def connect(server)
+        opts = server_opts(server)
+        rc, dbc = SQLAllocHandle(SQL_HANDLE_DBC, @@env) 
+        check_error(rc, "Could not allocate database connection")
+        
+        rc = SQLConnect(dbc, opts[:database], opts[:user], opts[:password]) 
+        check_error(rc, "Could not connect to database")
+        
+        dbc
+      end
+      
+      def test_connection(server=nil)
+        synchronize(server){|conn|}
+        true
+      end
+
+      def dataset(opts = nil)
+        DB2::Dataset.new(self, opts)
+      end
+      
+      def execute(sql, opts={})
+        synchronize(opts[:server]) do |conn|
+          rc, sth = SQLAllocHandle(SQL_HANDLE_STMT, @handle) 
+          check_error(rc, "Could not allocate statement")
+
+          begin
+            rc = log_yield(sql){SQLExecDirect(sth, sql)}
+            check_error(rc, "Could not execute statement")
+            
+            yield(sth) if block_given?
+
+            rc, rpc = SQLRowCount(sth)
+            check_error(rc, "Could not get RPC") 
+            rpc
+          ensure
+            rc = SQLFreeHandle(SQL_HANDLE_STMT, sth)
+            check_error(rc, "Could not free statement")
+          end
+        end
+      end
+      alias_method :do, :execute
+      
+      private
+      
+      def check_error(rc, msg)
+        case rc
+        when SQL_SUCCESS, SQL_SUCCESS_WITH_INFO
+          nil
+        else
+          raise DatabaseError, msg
+        end
+      end
+
+      def disconnect_connection(conn)
+        rc = SQLDisconnect(conn)
+        check_error(rc, "Could not disconnect from database")
+
+        rc = SQLFreeHandle(SQL_HANDLE_DBC, conn)
+        check_error(rc, "Could not free Database handle")
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      MAX_COL_SIZE = 256
+      
+      def fetch_rows(sql)
+        execute(sql) do |sth|
+          @column_info = get_column_info(sth)
+          @columns = @column_info.map {|c| output_identifier(c[:name])}
+          while (rc = SQLFetch(@handle)) != SQL_NO_DATA_FOUND
+            @db.check_error(rc, "Could not fetch row")
+            yield hash_row(sth)
+          end
+        end
+        self
+      end
+      
+      # DB2 supports window functions
+      def supports_window_functions?
+        true
+      end
+      
+      private
+
+      def get_column_info(sth)
+        rc, column_count = SQLNumResultCols(sth)
+        @db.check_error(rc, "Could not get number of result columns")
+
+        (1..column_count).map do |i| 
+          rc, name, buflen, datatype, size, digits, nullable = SQLDescribeCol(sth, i, MAX_COL_SIZE)
+          @b.check_error(rc, "Could not describe column")
+          
+          {:name => name, :db2_type => datatype, :precision => size}
+        end 
+      end
+      
+      def hash_row(sth)
+        row = {}
+        @column_info.each_with_index do |c, i|
+          rc, v = SQLGetData(sth, i+1, c[:db2_type], c[:precision]) 
+          @db.check_error(rc, "Could not get data")
+          
+          row[output_identifier(c[:name])] = convert_type(v)
+        end
+        row
+      end
+      
+      def convert_type(v)
+        case v
+        when DB2CLI::Date 
+          DBI::Date.new(v.year, v.month, v.day)
+        when DB2CLI::Time
+          DBI::Time.new(v.hour, v.minute, v.second)
+        when DB2CLI::Timestamp 
+          DBI::Timestamp.new(v.year, v.month, v.day,
+            v.hour, v.minute, v.second, v.fraction)
+        when DB2CLI::Null
+          nil
+        else  
+          v
+        end
+      end
+    end
+  end
+end

data/lib/sequel/adapters/dbi.rb

@@ -0,0 +1,113 @@
+require 'dbi'
+
+module Sequel
+  module DBI
+    class Database < Sequel::Database
+      set_adapter_scheme :dbi
+      
+      DBI_ADAPTERS = {
+        :ado => "ADO",
+        :db2 => "DB2",
+        :frontbase => "FrontBase",
+        :interbase => "InterBase",
+        :msql => "Msql",
+        :mysql => "Mysql",
+        :odbc => "ODBC",
+        :oracle => "Oracle",
+        :pg => "pg",
+        :proxy => "Proxy",
+        :sqlite => "SQLite",
+        :sqlrelay => "SQLRelay"
+      }
+      
+      def initialize(opts)
+        super
+        case @opts[:db_type]
+        when 'mssql'
+          Sequel.ts_require 'adapters/shared/mssql'
+          extend Sequel::MSSQL::DatabaseMethods
+          def self.dataset(*args)
+            ds = super
+            ds.extend Sequel::MSSQL::DatasetMethods
+            ds
+          end
+        end
+      end
+
+      # Converts a uri to an options hash. These options are then passed
+      # to a newly created database object.
+      def self.uri_to_options(uri) # :nodoc:
+        database = (m = /\/(.*)/.match(uri.path)) && (m[1])
+        if m = /dbi-(.+)/.match(uri.scheme)
+          adapter = DBI_ADAPTERS[m[1].to_sym] || m[1]
+          database = "#{adapter}:dbname=#{database}"
+        end
+        {
+          :user => uri.user,
+          :password => uri.password,
+          :host => uri.host,
+          :port => uri.port,
+          :database => database
+        }
+      end
+
+      private_class_method :uri_to_options
+      
+      def connect(server)
+        opts = server_opts(server)
+        dbname = opts[:database]
+        if dbname !~ /^DBI:/ then
+          dbname = "DBI:#{dbname}"
+          [:host, :port].each{|sym| dbname += ";#{sym}=#{opts[sym]}" unless blank_object?(opts[sym])}
+        end
+        ::DBI.connect(dbname, opts[:user], opts[:password])
+      end
+      
+      def dataset(opts = nil)
+        DBI::Dataset.new(self, opts)
+      end
+    
+      def execute(sql, opts={})
+        synchronize(opts[:server]) do |conn|
+          r = log_yield(sql){conn.execute(sql)}
+          yield(r) if block_given?
+          r
+        end
+      end
+      
+      def do(sql, opts={})
+        synchronize(opts[:server]){|conn| log_yield(sql){conn.do(sql)}}
+      end
+      alias_method :execute_dui, :do
+
+      private
+
+      def disconnect_connection(c)
+        c.disconnect
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      def fetch_rows(sql, &block)
+        execute(sql) do |s|
+          begin
+            @columns = s.column_names.map{|c| output_identifier(c)}
+            s.fetch{|r| yield hash_row(s, r)}
+          ensure
+            s.finish rescue nil
+          end
+        end
+        self
+      end
+      
+      private
+      
+      def hash_row(stmt, row)
+        @columns.inject({}) do |m, c|
+          m[c] = row.shift
+          m
+        end
+      end
+    end
+  end
+end

data/lib/sequel/adapters/do.rb

@@ -0,0 +1,188 @@
+require 'data_objects'
+
+module Sequel
+  # Module holding the DataObjects support for Sequel.  DataObjects is a
+  # ruby library with a standard API for accessing databases.
+  #
+  # The DataObjects adapter currently supports PostgreSQL, MySQL, and
+  # SQLite:
+  #
+  # *  Sequel.connect('do:sqlite3::memory:')
+  # *  Sequel.connect('do:postgres://user:password@host/database')
+  # *  Sequel.connect('do:mysql://user:password@host/database')
+  module DataObjects
+    # Contains procs keyed on sub adapter type that extend the
+    # given database object so it supports the correct database type.
+    DATABASE_SETUP = {:postgres=>proc do |db|
+        Sequel.tsk_require 'do_postgres'
+        Sequel.ts_require 'adapters/do/postgres'
+        db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
+      end,
+      :mysql=>proc do |db|
+        Sequel.tsk_require 'do_mysql'
+        Sequel.ts_require 'adapters/do/mysql'
+        db.extend(Sequel::DataObjects::MySQL::DatabaseMethods)
+      end,
+      :sqlite3=>proc do |db|
+        Sequel.tsk_require 'do_sqlite3'
+        Sequel.ts_require 'adapters/do/sqlite'
+        db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
+      end
+    }
+      
+    # DataObjects uses it's own internal connection pooling in addition to the
+    # pooling that Sequel uses.  You should make sure that you don't set
+    # the connection pool size to more than 8 for a
+    # Sequel::DataObjects::Database object, or hack DataObjects (or Extlib) to
+    # use a pool size at least as large as the pool size being used by Sequel.
+    class Database < Sequel::Database
+      set_adapter_scheme :do
+      
+      # Call the DATABASE_SETUP proc directly after initialization,
+      # so the object always uses sub adapter specific code.  Also,
+      # raise an error immediately if the connection doesn't have a
+      # uri, since DataObjects requires one.
+      def initialize(opts)
+        super
+        raise(Error, "No connection string specified") unless uri
+        if prok = DATABASE_SETUP[subadapter.to_sym]
+          prok.call(self)
+        end
+      end
+      
+      # Setup a DataObjects::Connection to the database.
+      def connect(server)
+        setup_connection(::DataObjects::Connection.new(uri(server_opts(server))))
+      end
+      
+      # Return a Sequel::DataObjects::Dataset object for this database.
+      def dataset(opts = nil)
+        DataObjects::Dataset.new(self, opts)
+      end
+    
+      # Execute the given SQL.  If a block is given, the DataObjects::Reader
+      # created is yielded to it. A block should not be provided unless a
+      # a SELECT statement is being used (or something else that returns rows).
+      # Otherwise, the return value is the insert id if opts[:type] is :insert,
+      # or the number of affected rows, otherwise.
+      def execute(sql, opts={})
+        synchronize(opts[:server]) do |conn|
+          begin
+            command = conn.create_command(sql)
+            res = log_yield(sql){block_given? ? command.execute_reader : command.execute_non_query}
+          rescue ::DataObjects::Error => e
+            raise_error(e)
+          end
+          if block_given?
+            begin
+              yield(res)
+            ensure
+             res.close if res
+            end
+          elsif opts[:type] == :insert
+            res.insert_id
+          else
+            res.affected_rows
+          end
+        end
+      end
+      
+      # Execute the SQL on the this database, returning the number of affected
+      # rows.
+      def execute_dui(sql, opts={})
+        execute(sql, opts)
+      end
+      
+      # Execute the SQL on this database, returning the primary key of the
+      # table being inserted to.
+      def execute_insert(sql, opts={})
+        execute(sql, opts.merge(:type=>:insert))
+      end
+      
+      # Return the subadapter type for this database, i.e. sqlite3 for
+      # do:sqlite3::memory:.
+      def subadapter
+        uri.split(":").first
+      end
+      
+      # Return the DataObjects URI for the Sequel URI, removing the do:
+      # prefix.
+      def uri(opts={})
+        opts = @opts.merge(opts)
+        (opts[:uri] || opts[:url]).sub(/\Ado:/, '')
+      end
+
+      private
+      
+      # DataObjects uses a special transaction object to keep track of
+      # transactions.  Unfortunately, it tries to create a new connection
+      # to do a transaction.  So we close the connection created and
+      # substitute our own.
+      def begin_transaction(conn)
+        return super if supports_savepoints?
+        log_yield(TRANSACTION_BEGIN) do
+          t = ::DataObjects::Transaction.create_for_uri(uri)
+          t.instance_variable_get(:@connection).close
+          t.instance_variable_set(:@connection, conn)
+          t.begin
+          t
+        end
+      end
+      
+      # DataObjects requires transactions be prepared before being
+      # committed, so we do that.
+      def commit_transaction(t)
+        return super if supports_savepoints?
+        log_yield(TRANSACTION_ROLLBACK) do
+          t.prepare
+          t.commit 
+        end
+      end
+      
+      # Method to call on a statement object to execute SQL that does
+      # not return any rows.
+      def connection_execute_method
+        :execute_non_query
+      end
+      
+      # Close the given database connection.
+      def disconnect_connection(c)
+        c.close
+      end
+      
+      # Execute SQL on the connection by creating a command first
+      def log_connection_execute(conn, sql)
+        log_yield(sql){conn.create_command(sql).execute_non_query}
+      end
+      
+      # We use the transactions rollback method to rollback.
+      def rollback_transaction(t)
+        return super if supports_savepoints?
+        log_yield(TRANSACTION_COMMIT){t.rollback}
+      end
+      
+      # Allow extending the given connection when it is first created.
+      # By default, just returns the connection.
+      def setup_connection(conn)
+        conn
+      end
+    end
+    
+    # Dataset class for Sequel::DataObjects::Database objects.
+    class Dataset < Sequel::Dataset
+      # Execute the SQL on the database and yield the rows as hashes
+      # with symbol keys.
+      def fetch_rows(sql)
+        execute(sql) do |reader|
+          cols = @columns = reader.fields.map{|f| output_identifier(f)}
+          while(reader.next!) do
+            h = {}
+            cols.zip(reader.values).each{|k, v| h[k] = v}
+            yield h
+          end
+        end
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+Sequel.require 'adapters/shared/mysql'
+
+module Sequel
+  module DataObjects
+    # Database and Dataset instance methods for MySQL specific
+    # support via DataObjects.
+    module MySQL
+      # Database instance methods for MySQL databases accessed via DataObjects.
+      module DatabaseMethods
+        include Sequel::MySQL::DatabaseMethods
+        
+        # Return instance of Sequel::DataObjects::MySQL::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::DataObjects::MySQL::Dataset.new(self, opts)
+        end
+        
+        private
+        
+        # The database name for the given database.  Need to parse it out
+        # of the connection string, since the DataObjects does no parsing on the
+        # given connection string by default.
+        def database_name
+          (m = /\/(.*)/.match(URI.parse(uri).path)) && m[1]
+        end
+
+        def schema_column_type(db_type)
+          db_type == 'tinyint(1)' ? :boolean : super
+        end
+      end
+      
+      # Dataset class for MySQL datasets accessed via DataObjects.
+      class Dataset < DataObjects::Dataset
+        include Sequel::MySQL::DatasetMethods
+        
+        # Use execute_insert to execute the replace_sql.
+        def replace(*args)
+          execute_insert(replace_sql(*args))
+        end
+        
+        private
+        
+        # do_mysql sets NO_BACKSLASH_ESCAPES, so use standard SQL string escaping
+        def literal_string(s)
+          "'#{s.gsub("'", "''")}'"
+        end
+      end
+    end
+  end
+end