sequel_core 2.2.0 → 3.8.0

data/lib/sequel_core.rb

@@ -1,136 +0,0 @@
-%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 worker 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

@@ -1,68 +0,0 @@
-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
-      
-      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
-          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
-      
-      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/ado.rb

@@ -1,90 +0,0 @@
-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
-        # how do we disconnect? couldn't find anything in the docs
-      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}
-          
-          s.moveFirst
-          s.getRows.transpose.each {|r| yield hash_row(r)}
-        end
-        self
-      end
-      
-      def hash_row(row)
-        @columns.inject({}) do |m, c|
-          m[c] = row.shift
-          m
-        end
-      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/db2.rb

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