sequel 2.2.0 → 2.3.0

data/lib/sequel_core.rb

@@ -0,0 +1,136 @@
+%w'bigdecimal bigdecimal/util date enumerator thread time uri yaml'.each do |f|
+  require f
+end
+%w"core_ext sql core_sql connection_pool exceptions pretty_table
+  dataset migration schema database object_graph".each do |f|
+  require "sequel_core/#{f}"
+end
+
+# Top level module for Sequel
+#
+# There are some class methods that are added via metaprogramming, one for
+# each supported adapter.  For example:
+#
+#   DB = Sequel.sqlite # Memory database
+#   DB = Sequel.sqlite('blog.db')
+#   DB = Sequel.postgres('database_name', :user=>'user', 
+#          :password=>'password', :host=>'host', :port=>5432, 
+#          :max_connections=>10)
+#
+# If a block is given to these methods, it is passed the opened Database
+# object, which is closed (disconnected) when the block exits.  For example:
+#
+#   Sequel.sqlite('blog.db'){|db| puts db.users.count}  
+#
+# Sequel can use either Time or DateTime for times returned from the
+# database.  It defaults to Time.  To change it to DateTime, use:
+#
+#   Sequel.datetime_class = DateTime
+#
+# Sequel converts the column type tinyint to a boolean by default,
+# you can override the conversion to use tinyint as an integer:
+#
+#   Sequel.convert_tinyint_to_bool = false
+module Sequel
+  @datetime_class = Time
+  @convert_tinyint_to_bool = true
+  
+  metaattr_accessor :datetime_class
+  metaattr_accessor :convert_tinyint_to_bool
+
+  # Creates a new database object based on the supplied connection string
+  # and optional arguments.  The specified scheme determines the database
+  # class used, and the rest of the string specifies the connection options.
+  # For example:
+  #
+  #   DB = Sequel.connect('sqlite:/') # Memory database
+  #   DB = Sequel.connect('sqlite://blog.db') # ./blog.db
+  #   DB = Sequel.connect('sqlite:///blog.db') # /blog.db
+  #   DB = Sequel.connect('postgres://user:password@host:port/database_name')
+  #   DB = Sequel.connect('sqlite:///blog.db', :max_connections=>10)
+  #
+  # If a block is given, it is passed the opened Database object, which is
+  # closed when the block exits.  For example:
+  #
+  #   Sequel.connect('sqlite://blog.db'){|db| puts db.users.count}  
+  #
+  # This is also aliased as Sequel.open.
+  def self.connect(*args, &block)
+    Database.connect(*args, &block)
+  end
+  metaalias :open, :connect
+  
+  # Set whether to quote identifiers for all databases by default. By default,
+  # Sequel quotes identifiers in all SQL strings, so to turn that off:
+  #
+  #   Sequel.quote_identifiers = false
+  def self.quote_identifiers=(value)
+    Database.quote_identifiers = value
+  end
+  
+  # Set whether to set the single threaded mode for all databases by default. By default,
+  # Sequel uses a threadsafe connection pool, which isn't as fast as the
+  # single threaded connection pool.  If your program will only have one thread,
+  # and speed is a priority, you may want to set this to true:
+  #
+  #   Sequel.single_threaded = true
+  #
+  # Note that some database adapters (e.g. MySQL) have issues with single threaded mode if
+  # you try to perform more than one query simultaneously.  For example, the
+  # following code will not work well in single threaded mode on MySQL:
+  #
+  #   DB[:items].each{|i| DB[:nodes].filter(:item_id=>i[:id]).each{|n| puts "#{i} #{n}"}}
+  #
+  # Basically, you can't issue another query inside a call to Dataset#each in single
+  # threaded mode.  There is a fairly easy fix, just use Dataset#all inside
+  # Dataset#each for the outer query:
+  #
+  #   DB[:items].all{|i| DB[:nodes].filter(:item_id=>i[:id]).each{|n| puts "#{i} #{n}"}}
+  #
+  # Dataset#all gets all of the returned objects before calling the block, so the query
+  # isn't left open. Some of the adapters do this internally, and thus don't have a
+  # problem issuing queries inside of Dataset#each.
+  def self.single_threaded=(value)
+    Database.single_threaded = value
+  end
+
+  # Always returns false, since ParseTree support has been removed.
+  def self.use_parse_tree
+    false
+  end
+
+  # Raises an error if attempting to turn ParseTree support on (since it no longer exists).
+  # Otherwise, is a no-op.
+  def self.use_parse_tree=(val)
+    raise(Error, 'ParseTree support has been removed from Sequel') if val
+  end
+  
+  ### Private Class Methods ###
+
+  # Helper method that the database adapter class methods that are added to Sequel via
+  # metaprogramming use to parse arguments.
+  def self.adapter_method(adapter, *args, &block) # :nodoc:
+    raise(::Sequel::Error, "Wrong number of arguments, 0-2 arguments valid") if args.length > 2
+    opts = {:adapter=>adapter.to_sym}
+    opts[:database] = args.shift if args.length >= 1 && !(args[0].is_a?(Hash))
+    if Hash === (arg = args[0])
+      opts.merge!(arg)
+    elsif !arg.nil?
+      raise ::Sequel::Error, "Wrong format of arguments, either use (), (String), (Hash), or (String, Hash)"
+    end
+    connect(opts, &block)
+  end
+
+  # Method that adds a database adapter class method to Sequel that calls
+  # Sequel.adapter_method.
+  def self.def_adapter_method(*adapters) # :nodoc:
+    adapters.each do |adapter|
+      instance_eval("def #{adapter}(*args, &block); adapter_method('#{adapter}', *args, &block) end")
+    end
+  end
+
+  private_class_method :adapter_method, :def_adapter_method
+  
+  # Add the database adapter class methods to Sequel via metaprogramming
+  def_adapter_method(*Database::ADAPTERS)
+end

data/lib/sequel_core/adapters/adapter_skeleton.rb

@@ -0,0 +1,54 @@
+module Sequel
+  module Adapter
+    class Database < Sequel::Database
+      set_adapter_scheme :adapter
+      
+      def connect
+        AdapterDB.new(@opts[:database], @opts[:user], @opts[:password])
+      end
+      
+      def disconnect
+        @pool.disconnect {|c| c.disconnect}
+      end
+    
+      def dataset(opts = nil)
+        Adapter::Dataset.new(self, opts)
+      end
+      
+      def execute(sql)
+        log_info(sql)
+        @pool.hold {|conn| conn.exec(sql)}
+      end
+    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
+          cursor = @db.execute sql
+          begin
+            @columns = cursor.get_col_names.map {|c| c.to_sym}
+            while r = cursor.fetch
+              row = {}
+              r.each_with_index {|v, i| row[@columns[i]] = v}
+              yield row
+            end
+          ensure
+            cursor.close
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/ado.rb

@@ -0,0 +1,80 @@
+require 'win32ole'
+
+module Sequel
+  # The ADO adapter provides connectivity to ADO databases in Windows. ADO
+  # databases can be opened using a URL with the ado schema:
+  #
+  #   DB = Sequel.open('ado://mydb')
+  # 
+  # or using the Sequel.ado method:
+  #
+  #   DB = Sequel.ado('mydb')
+  #
+  module ADO
+    class Database < Sequel::Database
+      set_adapter_scheme :ado
+      
+      AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
+      
+      def auto_increment_sql
+        AUTO_INCREMENT
+      end
+      
+      def connect
+        s = "driver=#{@opts[:driver] || 'SQL Server'};server=#{@opts[:host]};database=#{@opts[:database]}#{";uid=#{@opts[:user]};pwd=#{@opts[:password]}" if @opts[:user]}"
+        handle = WIN32OLE.new('ADODB.Connection')
+        handle.Open(s)
+        handle
+      end
+      
+      def disconnect
+        @pool.disconnect {|conn| conn.Close}
+      end
+    
+      def dataset(opts = nil)
+        ADO::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
+          s = @db.execute sql
+          
+          @columns = s.Fields.extend(Enumerable).map {|x| x.Name.to_sym}
+          
+          unless s.eof
+            s.moveFirst
+            s.getRows.transpose.each {|r| yield hash_row(r)}
+          end
+        end
+        self
+      end
+      
+      def hash_row(row)
+        @columns.inject({}) do |m, c|
+          m[c] = row.shift
+          m
+        end
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/db2.rb

@@ -0,0 +1,148 @@
+require 'db2/db2cli'
+
+module Sequel
+  module DB2
+    class Database < Sequel::Database
+      set_adapter_scheme :db2
+      include DB2CLI
+      
+      # AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
+      # 
+      # def auto_increment_sql
+      #   AUTO_INCREMENT
+      # end
+      
+      def check_error(rc, msg)
+        case rc
+        when SQL_SUCCESS, SQL_SUCCESS_WITH_INFO
+          nil
+        else
+          raise Error, msg
+        end
+      end
+      
+      rc, @@env = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE)
+      check_error(rc, "Could not allocate DB2 environment")
+
+      def connect
+        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 disconnect
+        @pool.disconnect do |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
+    
+      def test_connection
+        @pool.hold {|conn|}
+        true
+      end
+
+      def dataset(opts = nil)
+        DB2::Dataset.new(self, opts)
+      end
+      
+      def execute(sql, &block)
+        log_info(sql)
+        @pool.hold do |conn|
+          rc, sth = SQLAllocHandle(SQL_HANDLE_STMT, @handle) 
+          check_error(rc, "Could not allocate statement")
+
+          begin
+            rc = SQLExecDirect(sth, sql) 
+            check_error(rc, "Could not execute statement")
+            
+            block[sth] if block
+
+            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
+    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
+          @db.execute(sql) do |sth|
+            @column_info = get_column_info(sth)
+            @columns = @column_info.map {|c| c[:name]}
+            while (rc = SQLFetch(@handle)) != SQL_NO_DATA_FOUND
+              @db.check_error(rc, "Could not fetch row")
+              yield hash_row(sth)
+            end
+          end
+        end
+        self
+      end
+      
+      MAX_COL_SIZE = 256
+
+      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[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_core/adapters/dbi.rb

@@ -0,0 +1,117 @@
+require 'dbi'
+
+module Sequel
+  module DBI
+    class Database < Sequel::Database
+      attr_writer :lowercase
+      
+      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"
+      }
+
+      # 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
+        dbname = @opts[:database]
+        if dbname !~ /^DBI:/ then
+          dbname = "DBI:#{dbname}"
+          [:host, :port].each{|sym| dbname += ";#{sym}=#{@opts[sym]}" unless @opts[sym].blank?}
+        end
+        ::DBI.connect(dbname, @opts[:user], @opts[:password])
+      end
+      
+      def disconnect
+        @pool.disconnect {|c| c.disconnect}
+      end
+    
+      def dataset(opts = nil)
+        DBI::Dataset.new(self, opts)
+      end
+    
+      def execute(sql)
+        log_info(sql)
+        @pool.hold do |conn|
+          conn.execute(sql)
+        end
+      end
+      
+      def do(sql)
+        log_info(sql)
+        @pool.hold do |conn|
+          conn.do(sql)
+        end
+      end
+      alias_method :execute_dui, :do
+      
+      # Converts all column names to lowercase
+      def lowercase
+        @lowercase ||= false
+      end
+    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
+          s = @db.execute sql
+          begin
+            @columns = s.column_names.map do |c|
+              @db.lowercase ? c.downcase.to_sym : c.to_sym
+            end
+            s.fetch {|r| yield hash_row(s, r)}
+          ensure
+            s.finish rescue nil
+          end
+        end
+        self
+      end
+      
+      def hash_row(stmt, row)
+        @columns.inject({}) do |m, c|
+          m[c] = row.shift
+          m
+        end
+      end
+    end
+  end
+end