sequel 2.2.0 → 2.3.0

data/lib/sequel_core/adapters/odbc.rb

@@ -0,0 +1,155 @@
+require 'odbc'
+
+module Sequel
+  module ODBC
+    class Database < Sequel::Database
+      set_adapter_scheme :odbc
+    
+      # def connect
+      #   conn = ::ODBC::connect(@opts[:database], @opts[:user], @opts[:password])
+      #   conn.autocommit = true
+      #   conn
+      # end
+
+      GUARDED_DRV_NAME = /^\{.+\}$/.freeze
+      DRV_NAME_GUARDS = '{%s}'.freeze
+
+      def connect
+        if @opts.include? :driver
+          drv = ::ODBC::Driver.new
+          drv.name = 'Sequel ODBC Driver130'
+          @opts.each do |param, value|
+            if :driver == param and not (value =~ GUARDED_DRV_NAME)
+              value = DRV_NAME_GUARDS % value
+            end
+            drv.attrs[param.to_s.capitalize] = value
+          end
+          db = ::ODBC::Database.new
+          conn = db.drvconnect(drv)
+        else
+          conn = ::ODBC::connect(@opts[:database], @opts[:user], @opts[:password])
+        end
+        conn.autocommit = true
+        conn
+      end      
+
+      def disconnect
+        @pool.disconnect {|c| c.disconnect}
+      end
+    
+      def dataset(opts = nil)
+        ODBC::Dataset.new(self, opts)
+      end
+    
+      # ODBC returns native statement objects, which must be dropped if
+      # you call execute manually, or you will get warnings.  See the
+      # fetch_rows method source code for an example of how to drop
+      # the statements.
+      def execute(sql)
+        log_info(sql)
+        @pool.hold do |conn|
+          conn.run(sql)
+        end
+      end
+      
+      def do(sql)
+        log_info(sql)
+        @pool.hold do |conn|
+          conn.do(sql)
+        end
+      end
+      alias_method :execute_dui, :do
+    end
+    
+    class Dataset < Sequel::Dataset
+      BOOL_TRUE = '1'.freeze
+      BOOL_FALSE = '0'.freeze
+      ODBC_TIMESTAMP_FORMAT = "{ts '%Y-%m-%d %H:%M:%S'}".freeze
+      ODBC_TIMESTAMP_AFTER_SECONDS =
+        ODBC_TIMESTAMP_FORMAT.index( '%S' ).succ - ODBC_TIMESTAMP_FORMAT.length
+      ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
+      
+      def literal(v)
+        case v
+        when true
+          BOOL_TRUE
+        when false
+          BOOL_FALSE
+        when Time, DateTime
+          formatted = v.strftime(ODBC_TIMESTAMP_FORMAT)
+          usec = (Time === v ? v.usec : (v.sec_fraction * 86400000000))
+          formatted.insert(ODBC_TIMESTAMP_AFTER_SECONDS, ".#{(usec.to_f/1000).round}") if usec >= 1000
+          formatted
+        when Date
+          v.strftime(ODBC_DATE_FORMAT)
+        else
+          super
+        end
+      end
+
+      UNTITLED_COLUMN = 'untitled_%d'.freeze
+
+      def fetch_rows(sql, &block)
+        @db.synchronize do
+          s = @db.execute sql
+          begin
+            untitled_count = 0
+            @columns = s.columns(true).map do |c|
+              if (n = c.name).empty?
+                n = UNTITLED_COLUMN % (untitled_count += 1)
+              end
+              n.to_sym
+            end
+            rows = s.fetch_all
+            rows.each {|row| yield hash_row(row)} if rows
+          ensure
+            s.drop unless s.nil? rescue nil
+          end
+        end
+        self
+      end
+    
+      # def fetch_rows(sql, &block)
+      #   @db.synchronize do
+      #     s = @db.execute sql
+      #     begin
+      #       @columns = s.columns(true).map {|c| c.name.to_sym}
+      #       rows = s.fetch_all
+      #       rows.each {|row| yield hash_row(row)}
+      #     ensure
+      #       s.drop unless s.nil? rescue nil
+      #     end
+      #   end
+      #   self
+      # end
+      
+      def hash_row(row)
+        hash = {}
+        row.each_with_index do |v, idx|
+          hash[@columns[idx]] = convert_odbc_value(v)
+        end
+        hash
+      end
+      
+      def convert_odbc_value(v)
+        # When fetching a result set, the Ruby ODBC driver converts all ODBC 
+        # SQL types to an equivalent Ruby type; with the exception of
+        # SQL_TYPE_DATE, SQL_TYPE_TIME and SQL_TYPE_TIMESTAMP.
+        #
+        # The conversions below are consistent with the mappings in
+        # ODBCColumn#mapSqlTypeToGenericType and Column#klass.
+        case v
+        when ::ODBC::TimeStamp
+          DateTime.new(v.year, v.month, v.day, v.hour, v.minute, v.second)
+        when ::ODBC::Time
+          now = DateTime.now
+          Time.gm(now.year, now.month, now.day, v.hour, v.minute, v.second)
+        when ::ODBC::Date
+          Date.new(v.year, v.month, v.day)
+        else
+          v
+        end
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/odbc_mssql.rb

@@ -0,0 +1,106 @@
+if !Sequel.const_defined?('ODBC')
+  require File.join(File.dirname(__FILE__), 'odbc')
+end
+
+module Sequel
+  module ODBC
+    module MSSQL
+      class Database < ODBC::Database
+        set_adapter_scheme :odbc_mssql
+        
+        def dataset(opts = nil)
+          MSSQL::Dataset.new(self, opts)
+        end
+      end
+      
+      class Dataset < ODBC::Dataset
+        # 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]
+          select_columns = columns ? column_list(columns) : WILDCARD
+
+          if distinct = opts[:distinct]
+            distinct_clause = distinct.empty? ? "DISTINCT" : "DISTINCT ON (#{expression_list(distinct)})"
+            sql = "SELECT #{top}#{distinct_clause} #{select_columns}"
+          else
+            sql = "SELECT #{top}#{select_columns}"
+          end
+
+          if opts[:from]
+            sql << " FROM #{source_list(opts[:from])}"
+          end
+
+          # ADD WITH to SELECT string for NOLOCK
+          if with = opts[:with]
+            sql << " WITH #{with}"
+          end
+
+          if join = opts[:join]
+            join.each{|j| sql << literal(j)}
+          end
+
+          if where = opts[:where]
+            sql << " WHERE #{literal(where)}"
+          end
+
+          if group = opts[:group]
+            sql << " GROUP BY #{expression_list(group)}"
+          end
+
+          if order = opts[:order]
+            sql << " ORDER BY #{expression_list(order)}"
+          end
+
+          if having = opts[:having]
+            sql << " HAVING #{literal(having)}"
+          end
+
+          if union = opts[:union]
+            sql << (opts[:union_all] ? \
+              " UNION ALL #{union.sql}" : " UNION #{union.sql}")
+          elsif intersect = opts[:intersect]
+            sql << (opts[:intersect_all] ? \
+              " INTERSECT ALL #{intersect.sql}" : " INTERSECT #{intersect.sql}")
+          elsif except = opts[:except]
+            sql << (opts[:except_all] ? \
+              " EXCEPT ALL #{except.sql}" : " EXCEPT #{except.sql}")
+          end
+
+          sql
+        end
+        alias_method :sql, :select_sql
+        
+        def full_text_search(cols, terms, opts = {})
+          filter("CONTAINS (#{literal(cols)}, #{literal(terms)})")
+        end
+
+        def complex_expression_sql(op, args)
+          case op
+          when :'||'
+            super(:+, args)
+          else
+            super(op, args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/openbase.rb

@@ -0,0 +1,64 @@
+require 'openbase'
+
+module Sequel
+  module OpenBase
+    class Database < Sequel::Database
+      set_adapter_scheme :openbase
+      
+      def connect
+        OpenBase.new(
+          opts[:database],
+          opts[:host] || 'localhost',
+          opts[:user],
+          opts[:password]
+        )
+      end
+      
+      def disconnect
+        # would this work?
+        @pool.disconnect {|c| c.disconnect}
+      end
+    
+      def dataset(opts = nil)
+        OpenBase::Dataset.new(self, opts)
+      end
+    
+      def execute(sql)
+        log_info(sql)
+        @pool.hold {|conn| conn.execute(sql)}
+      end
+      
+      alias_method :do, :execute
+    end
+    
+    class Dataset < Sequel::Dataset
+      def literal(v)
+        case v
+        when Time
+          literal(v.iso8601)
+        when Date, DateTime
+          literal(v.to_s)
+        else
+          super
+        end
+      end
+
+      def fetch_rows(sql, &block)
+        @db.synchronize do
+          result = @db.execute sql
+          begin
+            @columns = result.column_infos.map {|c| c.name.to_sym}
+            result.each do |r|
+              row = {}
+              r.each_with_index {|v, i| row[@columns[i]] = v}
+              yield row
+            end
+          ensure
+            # result.close
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/oracle.rb

@@ -0,0 +1,170 @@
+require 'oci8'
+
+module Sequel
+  module Oracle
+    class Database < Sequel::Database
+      set_adapter_scheme :oracle
+      
+      # AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
+      # 
+      # def auto_increment_sql
+      #   AUTO_INCREMENT
+      # end
+
+      def connect
+        if @opts[:database]
+          dbname = @opts[:host] ? \
+            "//#{@opts[:host]}#{":#{@opts[:port]}" if @opts[:port]}/#{@opts[:database]}" : @opts[:database]
+        else
+          dbname = @opts[:host]
+        end
+        conn = OCI8.new(@opts[:user], @opts[:password], dbname, @opts[:privilege])
+        conn.autocommit = true
+        conn.non_blocking = true
+        conn
+      end
+      
+      def disconnect
+        @pool.disconnect {|c| c.logoff}
+      end
+    
+      def dataset(opts = nil)
+        Oracle::Dataset.new(self, opts)
+      end
+    
+      def execute(sql)
+        log_info(sql)
+        @pool.hold {|conn| conn.exec(sql)}
+      end
+      
+      alias_method :do, :execute
+      
+      def tables
+        from(:tab).select(:tname).filter(:tabtype => 'TABLE').map do |r|
+          r[:tname].downcase.to_sym
+        end
+      end
+
+      def table_exists?(name)
+        from(:tab).filter(:tname => name.to_s.upcase, :tabtype => 'TABLE').count > 0
+      end
+
+      def transaction
+        @pool.hold do |conn|
+          @transactions ||= []
+          if @transactions.include? Thread.current
+            return yield(conn)
+          end
+          
+          conn.autocommit = false
+          begin
+            @transactions << Thread.current
+            yield(conn)
+          rescue => e
+            conn.rollback
+            raise e unless Error::Rollback === e
+          ensure
+            conn.commit unless e
+            conn.autocommit = true
+            @transactions.delete(Thread.current)
+          end
+        end
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      def literal(v)
+        case v
+        when OraDate
+          literal(Time.local(*v.to_a))
+        else
+          super
+        end
+      end
+
+      def fetch_rows(sql, &block)
+        @db.synchronize do
+          cursor = @db.execute sql
+          begin
+            @columns = cursor.get_col_names.map {|c| c.downcase.to_sym}
+            while r = cursor.fetch
+              row = {}
+              r.each_with_index {|v, i| row[columns[i]] = v unless columns[i] == :raw_rnum_}
+              yield row
+            end
+          ensure
+            cursor.close
+          end
+        end
+        self
+      end
+
+      def empty?
+        db[:dual].where(exists).get(1) == nil
+      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
+
+        columns = opts[:select]
+        select_columns = columns ? column_list(columns) : WILDCARD
+        sql = opts[:distinct] ? \
+        "SELECT DISTINCT #{select_columns}" : \
+        "SELECT #{select_columns}"
+        
+        if opts[:from]
+          sql << " FROM #{source_list(opts[:from])}"
+        end
+        
+        if join = opts[:join]
+          join.each{|j| sql << literal(j)}
+        end
+
+        if where = opts[:where]
+          sql << " WHERE #{literal(where)}"
+        end
+
+        if group = opts[:group]
+          sql << " GROUP BY #{expression_list(group)}"
+        end
+
+        if having = opts[:having]
+          sql << " HAVING #{literal(having)}"
+        end
+
+        if union = opts[:union]
+          sql << (opts[:union_all] ? \
+            " UNION ALL #{union.sql}" : " UNION #{union.sql}")
+        elsif intersect = opts[:intersect]
+          sql << (opts[:intersect_all] ? \
+            " INTERSECT ALL #{intersect.sql}" : " INTERSECT #{intersect.sql}")
+        elsif except = opts[:except]
+          sql << (opts[:except_all] ? \
+            " EXCEPT ALL #{except.sql}" : " EXCEPT #{except.sql}")
+        end
+
+        if order = opts[:order]
+          sql << " ORDER BY #{expression_list(order)}"
+        end
+
+        if limit = opts[:limit]
+          if (offset = opts[:offset]) && (offset > 0)
+            sql = "SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM(#{sql}) raw_sql_ WHERE ROWNUM <= #{limit + offset}) WHERE raw_rnum_ > #{offset}"
+          else
+            sql = "SELECT * FROM (#{sql}) WHERE ROWNUM <= #{limit}"
+          end
+        end
+
+        sql
+      end
+
+      alias sql select_sql
+    end
+  end
+end