colincasey-sequel 2.10.0 → 2.10.1

data/lib/sequel_core/adapters/do.rb

@@ -0,0 +1,205 @@
+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|
+        require 'do_postgres'
+        require 'sequel_core/adapters/do/postgres'
+        db.converted_exceptions << PostgresError
+        db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
+      end,
+      :mysql=>proc do |db|
+        require 'do_mysql'
+        require 'sequel_core/adapters/do/mysql'
+        db.converted_exceptions << MysqlError
+        db.extend(Sequel::DataObjects::MySQL::DatabaseMethods)
+      end,
+      :sqlite3=>proc do |db|
+        require 'do_sqlite3'
+        require 'sequel_core/adapters/do/sqlite'
+        db.converted_exceptions << Sqlite3Error
+        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
+      
+      # Convert the given exceptions to Sequel:Errors, necessary
+      # because DO raises errors specific to database types in
+      # certain cases.
+      attr_accessor :converted_exceptions
+      
+      # 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)
+        @opts = opts
+        @converted_exceptions = []
+        raise(Error, "No connection string specified") unless uri
+        if prok = DATABASE_SETUP[subadapter.to_sym]
+          prok.call(self)
+        end
+        super(opts)
+      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={})
+        log_info(sql)
+        synchronize(opts[:server]) do |conn|
+          begin
+            command = conn.create_command(sql)
+            res = block_given? ? command.execute_reader : command.execute_non_query
+          rescue Exception => e
+            raise_error(e, :classes=>@converted_exceptions)
+          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
+      
+      # Use DataObject's transaction support for transactions.  This
+      # only supports single level transactions, and it always prepares
+      # transactions and commits them immediately after.  It's wasteful,
+      # but required by DataObject's API.
+      def transaction(server=nil)
+        th = Thread.current
+        synchronize(server) do |conn|
+          return yield(conn) if @transactions.include?(th)
+          t = ::DataObjects::Transaction.create_for_uri(uri)
+          t.instance_variable_get(:@connection).close
+          t.instance_variable_set(:@connection, conn)
+          begin
+            log_info("Transaction.begin")
+            t.begin
+            @transactions << th
+            yield(conn)
+          rescue Exception => e
+            log_info("Transaction.rollback")
+            t.rollback
+            transaction_error(e)
+          ensure
+            unless e
+              log_info("Transaction.commit")
+              t.prepare
+              t.commit 
+            end
+            @transactions.delete(th)
+          end
+        end
+      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
+
+      # Close the given database connection.
+      def disconnect_connection(c)
+        c.close
+      end
+      
+      # Allow extending the given connection when it is first created.
+      # By default, just returns the connection.
+      def setup_connection(conn)
+        conn
+      end
+      
+      # The DataObjects adapter should convert exceptions by default.
+      def connection_pool_default_options
+        super.merge(:pool_convert_exceptions=>false)
+      end
+    end
+    
+    # Dataset class for Sequel::DataObjects::Database objects.
+    class Dataset < Sequel::Dataset
+      # Handle the usual time class overrides.
+      def literal(v)
+        case v
+        when Time
+          literal(v.iso8601)
+        when Date, DateTime
+          literal(v.to_s)
+        else
+          super
+        end
+      end
+      
+      # 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_core/adapters/firebird.rb

@@ -0,0 +1,298 @@
+require 'fb'
+
+module Sequel
+  # The Sequel Firebird adapter requires the ruby fb driver located at
+  # http://github.com/wishdev/fb.
+  module Firebird
+    class Database < Sequel::Database
+      set_adapter_scheme :firebird
+
+      AUTO_INCREMENT = ''.freeze
+
+      # Add the primary_keys and primary_key_sequences instance variables,
+      # so we can get the correct return values for inserted rows.
+      def initialize(*args)
+        super
+        @primary_keys = {}
+        @primary_key_sequences = {}
+      end
+
+      # Use Firebird specific syntax for add column
+      def alter_table_sql(table, op)
+        case op[:op]
+        when :add_column
+          "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
+        when :drop_column
+          "ALTER TABLE #{quote_schema_table(table)} DROP #{column_definition_sql(op)}"
+        when :rename_column
+          "ALTER TABLE #{quote_schema_table(table)} ALTER #{quote_identifier(op[:name])} TO #{quote_identifier(op[:new_name])}"
+        when :set_column_type
+          "ALTER TABLE #{quote_schema_table(table)} ALTER #{quote_identifier(op[:name])} TYPE #{type_literal(op)}"
+        else
+          super(table, op)
+        end
+      end
+
+      def auto_increment_sql()
+        AUTO_INCREMENT
+      end
+      
+      def connect(server)
+        opts = server_opts(server)
+
+        db = Fb::Database.new(
+          :database => "#{opts[:host]}:#{opts[:database]}",
+          :username => opts[:user],
+          :password => opts[:password])
+        conn = db.connect
+        conn.downcase_names = true
+        conn
+      end
+
+      def create_sequence_sql(name, opts={})
+        "CREATE SEQUENCE #{quote_identifier(name)}"
+      end
+
+      # Creates a table with the columns given in the provided block:
+      #
+      #   DB.create_table :posts do
+      #     primary_key :id, :serial
+      #     column :title, :text
+      #     column :content, :text
+      #     index :title
+      #   end
+      #
+      # See Schema::Generator.
+      # Firebird gets an override because of the mess of creating a
+      # generator for auto-incrementing primary keys.
+      def create_table(name, options={}, &block)
+        options = {:generator=>options} if options.is_a?(Schema::Generator)
+        statements = create_table_sql_list(name, *((options[:generator] ||= Schema::Generator.new(self, &block)).create_info << options))
+        begin
+          execute_ddl(statements[1])
+        rescue
+          nil
+        end if statements[1]
+        statements[0].flatten.each {|sql| execute_ddl(sql)}
+      end
+
+      def create_table_sql_list(name, columns, indexes = nil, options={})
+        statements = super
+        drop_seq_statement = nil
+        columns.each do |c|
+          if c[:auto_increment]
+            c[:sequence_name] ||= "seq_#{name}_#{c[:name]}"
+            unless c[:create_sequence] == false
+              drop_seq_statement = drop_sequence_sql(c[:sequence_name])
+              statements << create_sequence_sql(c[:sequence_name])
+              statements << restart_sequence_sql(c[:sequence_name], {:restart_position => c[:sequence_start_position]}) if c[:sequence_start_position]
+            end
+            unless c[:create_trigger] == false
+              c[:trigger_name] ||= "BI_#{name}_#{c[:name]}"
+              c[:quoted_name] = quote_identifier(c[:name])
+              trigger_definition = <<-END
+              begin
+                if ((new.#{c[:quoted_name]} is null) or (new.#{c[:quoted_name]} = 0)) then
+                begin
+                  new.#{c[:quoted_name]} = next value for #{c[:sequence_name]};
+                end
+              end
+              END
+              statements << create_trigger_sql(name, c[:trigger_name], trigger_definition, {:events => [:insert]})
+            end
+          end
+        end
+        [statements, drop_seq_statement]
+      end
+
+      def create_trigger(*args)
+        self << create_trigger_sql(*args)
+      end
+
+      def create_trigger_sql(table, name, definition, opts={})
+        events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
+        whence = opts[:after] ? 'AFTER' : 'BEFORE'
+        inactive = opts[:inactive] ? 'INACTIVE' : 'ACTIVE'
+        position = opts[:position] ? opts[:position] : 0
+        sql = <<-end_sql
+          CREATE TRIGGER #{quote_identifier(name)} for #{quote_identifier(table)}
+          #{inactive} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} position #{position}
+          as #{definition}
+        end_sql
+        sql
+      end
+
+      def dataset(opts = nil)
+        Firebird::Dataset.new(self, opts)
+      end
+
+      def drop_sequence(name)
+        self << drop_sequence_sql(name)
+      end
+
+      def drop_sequence_sql(name)
+        "DROP SEQUENCE #{quote_identifier(name)}"
+      end
+
+      def execute(sql, opts={})
+        log_info(sql)
+        begin
+          synchronize(opts[:server]) do |conn|
+            r = conn.execute(sql)
+            yield(r) if block_given?
+            r
+          end
+        rescue => e
+          log_info(e.message)
+          raise_error(e, :classes=>[Fb::Error])
+        end
+      end
+
+      # Return primary key for the given table.
+      def primary_key(table, server=nil)
+        synchronize(server){|conn| primary_key_for_table(conn, table)}
+      end
+
+      # Returns primary key for the given table.  This information is
+      # cached, and if the primary key for a table is changed, the
+      # @primary_keys instance variable should be reset manually.
+      def primary_key_for_table(conn, table)
+        @primary_keys[quote_identifier(table)] ||= conn.table_primary_key(quote_identifier(table))
+      end
+
+      def restart_sequence(*args)
+        self << restart_sequence_sql(*args)
+      end
+
+      def restart_sequence_sql(name, opts={})
+        seq_name = quote_identifier(name)
+        "ALTER SEQUENCE #{seq_name} RESTART WITH #{opts[:restart_position]}"
+      end
+
+      def sequences(opts={})
+        ds = self[:"rdb$generators"].server(opts[:server]).filter(:"rdb$system_flag" => 0).select(:"rdb$generator_name")
+        block_given? ? yield(ds) : ds.map{|r| ds.send(:output_identifier, r[:"rdb$generator_name"])}
+      end
+
+      def tables(opts={})
+        ds = self[:"rdb$relations"].server(opts[:server]).filter(:"rdb$view_blr" => nil, Sequel::SQL::Function.new(:COALESCE, :"rdb$system_flag", 0) => 0).select(:"rdb$relation_name")
+        block_given? ? yield(ds) : ds.map{|r| ds.send(:output_identifier, r[:"rdb$relation_name"])}
+      end
+
+      def transaction(server=nil)
+        synchronize(server) do |conn|
+          return yield(conn) if @transactions.include?(Thread.current)
+          log_info("Transaction.begin")
+          conn.transaction
+          begin
+            @transactions << Thread.current
+            yield(conn)
+          rescue ::Exception => e
+            log_info("Transaction.rollback")
+            conn.rollback
+            transaction_error(e, Fb::Error)
+          ensure
+            unless e
+              log_info("Transaction.commit")
+              conn.commit
+            end
+            @transactions.delete(Thread.current)
+          end
+        end
+      end
+
+      private
+
+      def disconnect_connection(c)
+        c.close
+      end
+    end
+
+    # Dataset class for Firebird datasets
+    class Dataset < Sequel::Dataset
+      include UnsupportedIntersectExcept
+
+      BOOL_TRUE = '1'.freeze
+      BOOL_FALSE = '0'.freeze
+      COMMA_SEPARATOR = ', '.freeze
+      FIREBIRD_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
+      SELECT_CLAUSE_ORDER = %w'distinct limit columns from join where group having compounds order'.freeze
+
+      # Yield all rows returned by executing the given SQL and converting
+      # the types.
+      def fetch_rows(sql, &block)
+        execute(sql) do |s|
+          begin
+            @columns = s.fields.map{|c| output_identifier(c.name)}
+            s.fetchall(:symbols_hash).each do |r|
+              h = {}
+              r.each{|k,v| h[output_identifier(k)] = v}
+              yield h
+            end
+          ensure
+            s.close
+          end
+        end
+        self
+      end
+
+      # Insert given values into the database.
+      def insert(*values)
+        if !@opts[:sql]
+          single_value(default_server_opts(:sql=>insert_returning_pk_sql(*values)))
+        else
+          execute_insert(insert_sql(*values), :table=>opts[:from].first,
+            :values=>values.size == 1 ? values.first : values)
+        end
+      end
+
+      # Use the RETURNING clause to return the primary key of the inserted record, if it exists
+      def insert_returning_pk_sql(*values)
+        pk = db.primary_key(opts[:from].first)
+        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : 'NULL'.lit, *values)
+      end
+
+      # Use the RETURNING clause to return the columns listed in returning.
+      def insert_returning_sql(returning, *values)
+        "#{insert_sql(*values)} RETURNING #{column_list(Array(returning))}"
+      end
+
+      # Insert a record returning the record inserted
+      def insert_select(*values)
+        single_record(default_server_opts(:naked=>true, :sql=>insert_returning_sql(nil, *values)))
+      end
+
+      def literal(v)
+        case v
+        when Time, DateTime
+          "#{v.strftime(FIREBIRD_TIMESTAMP_FORMAT)}.#{sprintf("%04d",v.usec / 100)}'"
+        when TrueClass
+          BOOL_TRUE
+        when FalseClass
+          BOOL_FALSE
+        else
+          super
+        end
+      end
+
+      # The order of clauses in the SELECT SQL statement
+      def select_clause_order
+        SELECT_CLAUSE_ORDER
+      end
+      
+      def select_limit_sql(sql, opts)
+        sql << " FIRST #{opts[:limit]}" if opts[:limit]
+        sql << " SKIP #{opts[:offset]}" if opts[:offset]
+      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_core/adapters/informix.rb

@@ -0,0 +1,85 @@
+require 'informix'
+
+module Sequel
+  module Informix
+    class Database < Sequel::Database
+      set_adapter_scheme :informix
+      
+      def connect(server)
+        opts = server_opts(server)
+        ::Informix.connect(opts[:database], opts[:user], opts[:password])
+      end
+    
+      def dataset(opts = nil)
+        Sequel::Informix::Dataset.new(self, opts)
+      end
+      
+      # Returns number of rows affected
+      def execute_dui(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]){|c| c.immediate(sql)}
+      end
+      alias_method :do, :execute_dui
+      
+      def execute(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]){|c| yield c.cursor(sql)}
+      end
+      alias_method :query, :execute
+      
+      private
+
+      def disconnect_connection(c)
+        c.close
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      include UnsupportedIntersectExcept
+
+      SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where having group compounds order'.freeze
+
+      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)
+        execute(sql) do |cursor|
+          begin
+            col_map = nil
+            cursor.open.each_hash do |h|
+              unless col_map
+                col_map = {}
+                @columns = h.keys.map{|k| col_map[k] = output_identifier(k)}
+              end
+              h2 = {}
+              h.each{|k,v| h2[col_map[k]||k] = v}
+              yield h2
+            end
+          ensure
+            cursor.drop
+          end
+        end
+        self
+      end
+
+      private
+
+      def select_clause_order
+        SELECT_CLAUSE_ORDER
+      end
+
+      def select_limit_sql(sql, opts)
+        sql << " SKIP #{opts[:offset]}" if opts[:offset]
+        sql << " FIRST #{opts[:limit]}" if opts[:limit]
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/jdbc/h2.rb

@@ -0,0 +1,69 @@
+module Sequel
+  module JDBC
+    # Database and Dataset support for H2 databases accessed via JDBC.
+    module H2
+      # Instance methods for H2 Database objects accessed via JDBC.
+      module DatabaseMethods
+        # H2 needs to add a primary key column as a constraint
+        def alter_table_sql(table, op)
+          case op[:op]
+          when :add_column
+            if op.delete(:primary_key)
+              sql = super(table, op)
+              [sql, "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})"]
+            else
+              super(table, op)
+            end
+          else
+            super(table, op)
+          end
+        end
+      
+        # Return Sequel::JDBC::H2::Dataset object with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::H2::Dataset.new(self, opts)
+        end
+        
+        # H2 uses an IDENTITY type
+        def serial_primary_key_options
+          {:primary_key => true, :type => :identity}
+        end
+        
+        private
+        
+        # Use IDENTITY() to get the last inserted id.
+        def last_insert_id(conn, opts={})
+          stmt = conn.createStatement
+          begin
+            rs = stmt.executeQuery('SELECT IDENTITY();')
+            rs.next
+            rs.getInt(1)
+          ensure
+            stmt.close
+          end 
+        end
+        
+        # Default to a single connection for a memory database.
+        def connection_pool_default_options
+          o = super
+          uri == 'jdbc:h2:mem:' ? o.merge(:max_connections=>1) : o
+        end
+      end
+      
+      # Dataset class for H2 datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        # Use H2 syntax for Date, DateTime, and Time types.
+        def literal(v)
+          case v
+          when Date
+            v.strftime("DATE '%Y-%m-%d'") 
+          when DateTime, Time
+            v.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end