sequel_core 2.2.0 → 3.8.0

data/lib/sequel_core/adapters/odbc.rb

@@ -1,167 +0,0 @@
-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
-    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
-          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
-      
-      def insert(*values)
-        @db.do insert_sql(*values)
-      end
-    
-      def update(*args, &block)
-        @db.do update_sql(*args, &block)
-        self
-      end
-    
-      def delete(opts = nil)
-        @db.do delete_sql(opts)
-      end
-    end
-  end
-end

data/lib/sequel_core/adapters/odbc_mssql.rb

@@ -1,106 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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
-      
-      def insert(*values)
-        @db.do insert_sql(*values)
-      end
-    
-      def update(*args, &block)
-        @db.do update_sql(*args, &block)
-      end
-    
-      def delete(opts = nil)
-        @db.do delete_sql(opts)
-      end
-    end
-  end
-end

data/lib/sequel_core/adapters/oracle.rb

@@ -1,182 +0,0 @@
-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[: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 insert(*values)
-        @db.do insert_sql(*values)
-      end
-    
-      def update(*args, &block)
-        @db.do update_sql(*args, &block)
-      end
-    
-      def delete(opts = nil)
-        @db.do delete_sql(opts)
-      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