sequel 3.21.0 → 3.41.0

data/lib/sequel/adapters/do.rb

@@ -17,16 +17,20 @@ module Sequel
         Sequel.tsk_require 'do_postgres'
         Sequel.ts_require 'adapters/do/postgres'
         db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
+        db.extend_datasets Sequel::Postgres::DatasetMethods
       end,
       :mysql=>proc do |db|
         Sequel.tsk_require 'do_mysql'
         Sequel.ts_require 'adapters/do/mysql'
         db.extend(Sequel::DataObjects::MySQL::DatabaseMethods)
+        db.dataset_class = Sequel::DataObjects::MySQL::Dataset
       end,
       :sqlite3=>proc do |db|
         Sequel.tsk_require 'do_sqlite3'
         Sequel.ts_require 'adapters/do/sqlite'
         db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
+        db.extend_datasets Sequel::SQLite::DatasetMethods
+        db.set_integer_booleans
       end
     }
       
@@ -36,6 +40,8 @@ module Sequel
     # 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
+      DISCONNECT_ERROR_RE = /terminating connection due to administrator command/
+
       set_adapter_scheme :do
       
       # Call the DATABASE_SETUP proc directly after initialization,
@@ -54,12 +60,11 @@ module Sequel
       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)
+
+      def disconnect_connection(conn)
+        conn.dispose
       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).
@@ -114,40 +119,20 @@ module Sequel
 
       private
       
-      # DataObjects uses a special transaction object to keep track of
-      # transactions.  Unfortunately, it tries to create a new connection
-      # to do a transaction.  So we close the connection created and
-      # substitute our own.
-      def begin_transaction(conn, opts={})
-        return super if supports_savepoints?
-        log_yield(TRANSACTION_BEGIN) do
-          t = ::DataObjects::Transaction.create_for_uri(uri)
-          t.instance_variable_get(:@connection).close
-          t.instance_variable_set(:@connection, conn)
-          t.begin
-          t
-        end
-      end
-      
-      # DataObjects requires transactions be prepared before being
-      # committed, so we do that.
-      def commit_transaction(t, opts={})
-        return super if supports_savepoints?
-        log_yield(TRANSACTION_ROLLBACK) do
-          t.prepare
-          t.commit 
-        end
-      end
-      
       # Method to call on a statement object to execute SQL that does
       # not return any rows.
       def connection_execute_method
         :execute_non_query
       end
       
-      # Close the given database connection.
-      def disconnect_connection(c)
-        c.close
+      # dataobjects uses the DataObjects::Error class as the main error class.
+      def database_error_classes
+        [::DataObjects::Error]
+      end
+
+      # Recognize DataObjects::ConnectionError instances as disconnect errors.
+      def disconnect_error?(e, opts)
+        super || (e.is_a?(::DataObjects::Error) && (e.is_a?(::DataObjects::ConnectionError) || e.message =~ DISCONNECT_ERROR_RE))
       end
       
       # Execute SQL on the connection by creating a command first
@@ -155,12 +140,6 @@ module Sequel
         log_yield(sql){conn.create_command(sql).execute_non_query}
       end
       
-      # We use the transactions rollback method to rollback.
-      def rollback_transaction(t, opts={})
-        return super if supports_savepoints?
-        log_yield(TRANSACTION_COMMIT){t.rollback}
-      end
-      
       # Allow extending the given connection when it is first created.
       # By default, just returns the connection.
       def setup_connection(conn)
@@ -170,6 +149,8 @@ module Sequel
     
     # Dataset class for Sequel::DataObjects::Database objects.
     class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+
       # Execute the SQL on the database and yield the rows as hashes
       # with symbol keys.
       def fetch_rows(sql)

data/lib/sequel/adapters/firebird.rb

@@ -1,213 +1,98 @@
 require 'fb'
+Sequel.require 'adapters/shared/firebird'
 
 module Sequel
   # The Sequel Firebird adapter requires the ruby fb driver located at
   # http://github.com/wishdev/fb.
   module Firebird
     class Database < Sequel::Database
+      include Sequel::Firebird::DatabaseMethods
+
       set_adapter_scheme :firebird
 
-      AUTO_INCREMENT = ''.freeze
-      TEMPORARY = 'GLOBAL TEMPORARY '.freeze
+      DISCONNECT_ERRORS = /Unsuccessful execution caused by a system error that precludes successful execution of subsequent statements/
 
-      # Add the primary_keys and primary_key_sequences instance variables,
+      # Add the primary_keys instance variables.
       # so we can get the correct return values for inserted rows.
       def initialize(*args)
         super
         @primary_keys = {}
-        @primary_key_sequences = {}
       end
 
       def connect(server)
         opts = server_opts(server)
 
-        db = Fb::Database.new(
+        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_trigger(*args)
-        self << create_trigger_sql(*args)
-      end
-
-      def dataset(opts = nil)
-        Firebird::Dataset.new(self, opts)
+          :password => opts[:password]).connect
       end
 
-      def drop_sequence(name)
-        self << drop_sequence_sql(name)
+      def disconnect_connection(conn)
+        begin
+          conn.close
+        rescue Fb::Error
+          nil
+        end
       end
 
       def execute(sql, opts={})
         begin
           synchronize(opts[:server]) do |conn|
+            if conn.transaction_started && !_trans(conn)
+              conn.rollback
+              raise DatabaseDisconnectError, "transaction accidently left open, rolling back and disconnecting"
+            end
             r = log_yield(sql){conn.execute(sql)}
             yield(r) if block_given?
             r
           end
-        rescue => e
-          raise_error(e, :classes=>[Fb::Error])
+        rescue Fb::Error => e
+          raise_error(e, :disconnect=>DISCONNECT_ERRORS.match(e.message))
         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 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
-
       private
 
-      # 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 begin_transaction(conn, opts={})
-        log_yield(TRANSACTION_BEGIN){conn.transaction}
-        conn
-      end
-
-      def commit_transaction(conn, opts={})
-        log_yield(TRANSACTION_COMMIT){conn.commit}
-      end
-      
-      def create_sequence_sql(name, opts={})
-        "CREATE SEQUENCE #{quote_identifier(name)}"
-      end
-
-      # Firebird gets an override because of the mess of creating a
-      # sequence and trigger for auto-incrementing primary keys.
-      def create_table_from_generator(name, generator, options)
-        drop_statement, create_statements = create_table_sql_list(name, generator, options)
-        (execute_ddl(drop_statement) rescue nil) if drop_statement
-        create_statements.each{|sql| execute_ddl(sql)}
-      end
-
-      def create_table_sql_list(name, generator, options={})
-        statements = [create_table_sql(name, generator, options)]
-        drop_seq_statement = nil
-        generator.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
+        log_yield(TRANSACTION_BEGIN) do
+          begin
+            conn.transaction
+          rescue Fb::Error => e
+            conn.rollback
+            raise_error(e, :disconnect=>true) 
           end
         end
-        [drop_seq_statement, statements]
       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.fetch(: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
+      def commit_transaction(conn, opts={})
+        log_yield(TRANSACTION_COMMIT){conn.commit}
       end
       
       def database_error_classes
         [Fb::Error]
       end
 
-      def disconnect_connection(c)
-        c.close
-      end
-
-      def drop_sequence_sql(name)
-        "DROP SEQUENCE #{quote_identifier(name)}"
-      end
-
-      def restart_sequence_sql(name, opts={})
-        seq_name = quote_identifier(name)
-        "ALTER SEQUENCE #{seq_name} RESTART WITH #{opts[:restart_position]}"
-      end
-      
       def rollback_transaction(conn, opts={})
         log_yield(TRANSACTION_ROLLBACK){conn.rollback}
       end
-
-      def type_literal_generic_string(column)
-        column[:text] ? :"BLOB SUB_TYPE TEXT" : super
-      end
     end
 
     # Dataset class for Firebird datasets
     class Dataset < Sequel::Dataset
-      BOOL_TRUE = '1'.freeze
-      BOOL_FALSE = '0'.freeze
-      NULL = LiteralString.new('NULL').freeze
-      COMMA_SEPARATOR = ', '.freeze
-      SELECT_CLAUSE_METHODS = clause_methods(:select, %w'with distinct limit columns from join where group having compounds order')
+      include Sequel::Firebird::DatasetMethods
+
+      Database::DatasetClass = self
 
       # Yield all rows returned by executing the given SQL and converting
       # the types.
       def fetch_rows(sql)
         execute(sql) do |s|
           begin
-            @columns = s.fields.map{|c| output_identifier(c.name)}
-            s.fetchall(:symbols_hash).each do |r|
+            @columns = columns = s.fields.map{|c| output_identifier(c.name)}
+            s.fetchall.each do |r|
               h = {}
-              r.each{|k,v| h[output_identifier(k)] = v}
+              r.zip(columns).each{|v, c| h[c] = v}
               yield h
             end
           ensure
@@ -216,68 +101,6 @@ module Sequel
         end
         self
       end
-
-      # Insert given values into the database.
-      def insert(*values)
-        if !@opts[:sql]
-          clone(default_server_opts(:sql=>insert_returning_pk_sql(*values))).single_value
-        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, *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)
-        naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record
-      end
-      
-      def requires_sql_standard_datetimes?
-        true
-      end
-
-      # The order of clauses in the SELECT SQL statement
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
-      end
-      
-      def select_limit_sql(sql)
-        sql << " FIRST #{@opts[:limit]}" if @opts[:limit]
-        sql << " SKIP #{@opts[:offset]}" if @opts[:offset]
-      end
-
-      # Firebird does not support INTERSECT or EXCEPT
-      def supports_intersect_except?
-        false
-      end
-
-      private
-
-      def hash_row(stmt, row)
-        @columns.inject({}) do |m, c|
-          m[c] = row.shift
-          m
-        end
-      end
-
-      def literal_false
-        BOOL_FALSE
-      end
-
-      def literal_true
-        BOOL_TRUE
-      end
     end
   end
 end