sequel 2.12.0 → 3.0.0

data/lib/sequel/adapters/shared/oracle.rb

@@ -3,6 +3,34 @@ Sequel.require %w'date_format unsupported', 'adapters/utils'
 module Sequel
   module Oracle
     module DatabaseMethods
+      TEMPORARY = 'GLOBAL TEMPORARY '.freeze
+      AUTOINCREMENT = ''.freeze
+
+      def create_sequence(name, opts={})
+        self << create_sequence_sql(name, opts)
+      end
+
+      def create_table(name, options={}, &block)
+        options = {:generator=>options} if options.is_a?(Schema::Generator)
+        generator = options[:generator] || Schema::Generator.new(self, &block)
+        drop_statement, create_statements = create_table_sql_list(name, generator, options)
+        (execute_ddl(drop_statement) rescue nil) if drop_statement
+        (create_statements + index_sql_list(name, generator.indexes)).each{|sql| execute_ddl(sql)}
+      end
+
+      def create_trigger(*args)
+        self << create_trigger_sql(*args)
+      end
+
+      def drop_sequence(name)
+        self << drop_sequence_sql(name)
+      end
+
+      # Oracle uses the :oracle database type
+      def database_type
+        :oracle
+      end
+
       def tables(opts={})
         ds = from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'TABLE')
         ds.map{|r| ds.send(:output_identifier, r[:tname])}
@@ -11,6 +39,62 @@ module Sequel
       def table_exists?(name)
         from(:tab).filter(:tname =>dataset.send(:input_identifier, name), :tabtype => 'TABLE').count > 0
       end
+
+      private
+
+      def auto_increment_sql
+        AUTOINCREMENT
+      end
+
+      # SQL fragment for showing a table is temporary
+      def temporary_table_sql
+        TEMPORARY
+      end
+
+      def create_sequence_sql(name, opts={})
+        "CREATE SEQUENCE #{quote_identifier(name)} start with #{opts [:start_with]||1} increment by #{opts[:increment_by]||1} nomaxvalue"
+      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], c)
+            end
+            unless c[:create_trigger] == false
+              c[:trigger_name] ||= "BI_#{name}_#{c[:name]}"
+              trigger_definition = <<-end_sql
+              BEGIN
+                IF :NEW.#{quote_identifier(c[:name])} IS NULL THEN
+                  SELECT #{c[:sequence_name]}.nextval INTO :NEW.#{quote_identifier(c[:name])} FROM dual;
+                END IF;
+              END;
+              end_sql
+              statements << create_trigger_sql(name, c[:trigger_name], trigger_definition, {:events => [:insert]})
+            end
+          end
+        end
+        [drop_seq_statement, statements]
+      end
+
+      def create_trigger_sql(table, name, definition, opts={})
+        events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
+        sql = <<-end_sql
+          CREATE#{' OR REPLACE' if opts[:replace]} TRIGGER #{quote_identifier(name)}
+          #{opts[:after] ? 'AFTER' : 'BEFORE'} #{events.map{|e| e.to_s.upcase}.join(' OR ')} ON #{quote_schema_table(table)}
+          REFERENCING NEW AS NEW FOR EACH ROW
+          #{definition}
+        end_sql
+        sql
+      end
+
+      def drop_sequence_sql(name)
+        "DROP SEQUENCE #{quote_identifier(name)}"
+      end
     end
     
     module DatasetMethods
@@ -43,14 +127,19 @@ module Sequel
         "#{expression} #{quote_identifier(aliaz)}"
       end
 
+      # Oracle uses the SQL standard of only doubling ' inside strings.
+      def literal_string(v)
+        "'#{v.gsub("'", "''")}'"
+      end
+
       def select_clause_order
         SELECT_CLAUSE_ORDER
       end
 
       # Oracle requires a subselect to do limit and offset
-      def select_limit_sql(sql, opts)
-        if limit = opts[:limit]
-          if (offset = opts[:offset]) && (offset > 0)
+      def select_limit_sql(sql)
+        if limit = @opts[:limit]
+          if (offset = @opts[:offset]) && (offset > 0)
             sql.replace("SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM(#{sql}) raw_sql_ WHERE ROWNUM <= #{limit + offset}) WHERE raw_rnum_ > #{offset}")
           else
             sql.replace("SELECT * FROM (#{sql}) WHERE ROWNUM <= #{limit}")

data/lib/sequel/adapters/shared/postgres.rb

@@ -56,12 +56,12 @@ module Sequel
       
       SELECT_CURRVAL = "SELECT currval('%s')".freeze
       SELECT_CUSTOM_SEQUENCE = proc do |schema, table| <<-end_sql
-        SELECT '"' || name.nspname || '"."' || CASE  
+        SELECT '"' || name.nspname || '".' || CASE  
             WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN  
               substr(split_part(def.adsrc, '''', 2),  
                      strpos(split_part(def.adsrc, '''', 2), '.')+1) 
             ELSE split_part(def.adsrc, '''', 2)  
-          END || '"'
+          END
         FROM pg_class t
         JOIN pg_namespace  name ON (t.relnamespace = name.oid)
         JOIN pg_attribute  attr ON (t.oid = attrelid)
@@ -86,7 +86,7 @@ module Sequel
       end_sql
       end
       SELECT_SERIAL_SEQUENCE = proc do |schema, table| <<-end_sql
-        SELECT  '"' || name.nspname || '"."' || seq.relname || '"'
+        SELECT  '"' || name.nspname || '".' || seq.relname || ''
         FROM pg_class seq, pg_attribute attr, pg_depend dep,
           pg_namespace name, pg_constraint cons
         WHERE seq.oid = dep.objid
@@ -172,7 +172,6 @@ module Sequel
       SQL_ROLLBACK = 'ROLLBACK'.freeze
       SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
       SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
-      TYPES = Sequel::Database::TYPES.merge(File=>'bytea', String=>'text')
 
       # Creates the function in the database.  Arguments:
       # * name : name of the function to create
@@ -222,6 +221,11 @@ module Sequel
         self << create_trigger_sql(table, name, function, opts)
       end
       
+      # PostgreSQL uses the :postgres database type.
+      def database_type
+        :postgres
+      end
+
       # Drops the function from the database. Arguments:
       # * name : name of the function to drop
       # * opts : options hash:
@@ -261,6 +265,34 @@ module Sequel
         self << drop_trigger_sql(table, name, opts)
       end
       
+      # Return a hash containing index information. Hash keys are index name symbols.
+      # Values are subhashes with two keys, :columns and :unique.  The value of :columns
+      # is an array of symbols of column names.  The value of :unique is true or false
+      # depending on if the index is unique.
+      def indexes(table)
+        m = output_identifier_meth
+        im = input_identifier_meth
+        schema, table = schema_and_table(table)
+        ds = metadata_dataset.
+          from(:pg_class___tab).
+          join(:pg_index___ind, :indrelid=>:oid, im.call(table)=>:relname).
+          join(:pg_class___indc, :oid=>:indexrelid).
+          join(:pg_attribute___att, :attrelid=>:tab__oid, :attnum=>SQL::Function.new(:ANY, :ind__indkey)).
+          filter(:indc__relkind=>'i', :ind__indisprimary=>false).
+          exclude(0=>SQL::Function.new(:ANY, :ind__indkey)).
+          order(:indc__relname, (0...32).map{|x| [SQL::Subscript.new(:ind__indkey, [x]), x]}.case(32, :att__attnum)).
+          select(:indc__relname___name, :ind__indisunique___unique, :att__attname___column)
+        
+        ds.join!(:pg_namespace___nsp, :oid=>:tab__relnamespace, :nspname=>schema) if schema
+        
+        indexes = {}
+        ds.each do |r|
+          i = indexes[m.call(r[:name])] ||= {:columns=>[], :unique=>r[:unique]}
+          i[:columns] << m.call(r[:column])
+        end
+        indexes
+      end
+
       # Dataset containing all current database locks 
       def locks
         dataset.from(:pg_class).join(:pg_locks, :relation=>:relfilenode).select(:pg_class__relname, Sequel::SQL::ColumnAll.new(:pg_locks))
@@ -287,6 +319,16 @@ module Sequel
           synchronize(opts[:server]){|con| con.sequence(*schema_and_table(table))}
         end
       end
+      
+      # Reset the primary key sequence for the given table, baseing it on the
+      # maximum current value of the table's primary key.
+      def reset_primary_key_sequence(table)
+        pk = SQL::Identifier.new(primary_key(table))
+        seq = primary_key_sequence(table)
+        db = self
+        seq_ds = db.from(seq.lit)
+        get{setval(seq, db[table].select{coalesce(max(pk)+seq_ds.select{:increment_by}, seq_ds.select(:min_value))}, false)}
+      end
 
       # PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for
       # managing incrementing primary keys.
@@ -313,9 +355,10 @@ module Sequel
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
       def table_exists?(table, opts={})
+        im = input_identifier_meth
         schema, table = schema_and_table(table)
         opts[:schema] ||= schema
-        tables(opts){|ds| !ds.first(:relname=>ds.send(:input_identifier, table)).nil?}
+        tables(opts){|ds| !ds.first(:relname=>im.call(table)).nil?}
       end
       
       # Array of symbols specifying table names in the current database.
@@ -326,22 +369,16 @@ module Sequel
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
       def tables(opts={})
-        ds = self[:pg_class].filter(:relkind=>'r').select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server])
+        ds = metadata_dataset.from(:pg_class).filter(:relkind=>'r').select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server])
         ds.join!(:pg_namespace, :oid=>:relnamespace, :nspname=>(opts[:schema]||default_schema).to_s) if opts[:schema] || default_schema
-        ds.identifier_input_method = nil
-        ds.identifier_output_method = nil
-        ds2 = dataset
-        block_given? ? yield(ds) : ds.map{|r| ds2.send(:output_identifier, r[:relname])}
+        m = output_identifier_meth
+        block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
       end
       
       # PostgreSQL supports multi-level transactions using save points.
       # To use a savepoint instead of reusing the current transaction,
       # use the :savepoint=>true option.
       def transaction(opts={})
-        unless opts.is_a?(Hash)
-          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
-          opts = {:server=>opts}
-        end
         synchronize(opts[:server]) do |conn|
           return yield(conn) if @transactions.include?(Thread.current) and !opts[:savepoint]
           conn.transaction_depth ||= 0
@@ -388,7 +425,7 @@ module Sequel
       end
 
       private
-
+      
       # SQL statement to create database function.
       def create_function_sql(name, definition, opts={})
         args = opts[:args]
@@ -511,10 +548,17 @@ module Sequel
         "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_identifier(schema_and_table(new_name).last)}"
       end 
 
+      # PostgreSQL's autoincrementing primary keys are of type integer or bigint
+      # using a nextval function call as a default.
+      def schema_autoincrementing_primary_key?(schema)
+        super and schema[:db_type] =~ /\A(?:integer|bigint)\z/io and schema[:default]=~/\Anextval/io
+      end
+
       # The dataset used for parsing table schemas, using the pg_* system catalogs.
       def schema_parse_table(table_name, opts)
-        ds2 = dataset
-        ds = dataset.select(:pg_attribute__attname___name,
+        m = output_identifier_meth
+        m2 = input_identifier_meth
+        ds = metadata_dataset.select(:pg_attribute__attname___name,
             SQL::Function.new(:format_type, :pg_type__oid, :pg_attribute__atttypmod).as(:db_type),
             SQL::Function.new(:pg_get_expr, :pg_attrdef__adbin, :pg_class__oid).as(:default),
             SQL::BooleanExpression.new(:NOT, :pg_attribute__attnotnull).as(:allow_null),
@@ -526,15 +570,13 @@ module Sequel
           left_outer_join(:pg_index, :indrelid=>:pg_class__oid, :indisprimary=>true).
           filter(:pg_attribute__attisdropped=>false).
           filter{|o| o.pg_attribute__attnum > 0}.
-          filter(:pg_class__relname=>ds2.send(:input_identifier, table_name)).
+          filter(:pg_class__relname=>m2.call(table_name)).
           order(:pg_attribute__attnum)
         ds.join!(:pg_namespace, :oid=>:pg_class__relnamespace, :nspname=>(opts[:schema] || default_schema).to_s) if opts[:schema] || default_schema
-        ds.identifier_input_method = nil
-        ds.identifier_output_method = nil
         ds.map do |row|
           row[:default] = nil if blank_object?(row[:default])
           row[:type] = schema_column_type(row[:db_type])
-          [ds2.send(:output_identifier, row.delete(:name)), row]
+          [m.call(row.delete(:name)), row]
         end
       end
 
@@ -543,9 +585,23 @@ module Sequel
         "(#{Array(args).map{|a| Array(a).reverse.join(' ')}.join(', ')})"
       end
       
-      # Override the standard type conversions with PostgreSQL specific ones
-      def type_literal_base(column)
-        TYPES[column[:type]]
+      # PostgreSQL uses the bytea data type for blobs
+      def type_literal_generic_file(column)
+        :bytea
+      end
+
+      # PostgreSQL prefers the text datatype.  If a fixed size is requested,
+      # the char type is used.  If the text type is specifically
+      # disallowed or there is a size specified, use the varchar type.
+      # Otherwise use the type type.
+      def type_literal_generic_string(column)
+        if column[:fixed]
+          "char(#{column[:size]||255})"
+        elsif column[:text] == false or column[:size]
+          "varchar(#{column[:size]||255})"
+        else
+          :text
+        end
       end
     end
     
@@ -712,9 +768,9 @@ module Sequel
 
       # PostgreSQL is smart and can use parantheses around all datasets to get
       # the correct answers.
-      def select_compounds_sql(sql, opts)
-        return unless opts[:compounds]
-        opts[:compounds].each do |type, dataset, all|
+      def select_compounds_sql(sql)
+        return unless @opts[:compounds]
+        @opts[:compounds].each do |type, dataset, all|
           sql.replace("(#{sql} #{type.to_s.upcase}#{' ALL' if all} #{subselect_sql(dataset)})")
         end
       end
@@ -725,8 +781,8 @@ module Sequel
       end
 
       # Support lock mode, allowing FOR SHARE and FOR UPDATE queries.
-      def select_lock_sql(sql, opts)
-        case opts[:lock]
+      def select_lock_sql(sql)
+        case @opts[:lock]
         when :update
           sql << FOR_UPDATE
         when :share

data/lib/sequel/adapters/shared/progress.rb

@@ -4,6 +4,11 @@ module Sequel
   module Progress
     module DatabaseMethods
 
+      # Progress uses the :progress database type.
+      def database_type
+        :progress
+      end
+
       def dataset(opts = nil)
         ds = super
         ds.extend(DatasetMethods)
@@ -25,9 +30,9 @@ module Sequel
 
       # Progress uses TOP for limit, but it is only supported in Progress 10.
       # The Progress adapter targets Progress 9, so it silently ignores the option.
-      def select_limit_sql(sql, opts)
-        raise(Error, "OFFSET not supported") if opts[:offset]
-        #sql << " TOP #{opts[:limit]}" if opts[:limit]
+      def select_limit_sql(sql)
+        raise(Error, "OFFSET not supported") if @opts[:offset]
+        #sql << " TOP #{@opts[:limit]}" if @opts[:limit]
       end
     end
   end

data/lib/sequel/adapters/shared/sqlite.rb

@@ -4,10 +4,10 @@ module Sequel
   module SQLite
     module DatabaseMethods
       AUTO_VACUUM = [:none, :full, :incremental].freeze
+      PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
       SYNCHRONOUS = [:off, :normal, :full].freeze
       TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'"
       TEMP_STORE = [:default, :file, :memory].freeze
-      TYPES = Sequel::Database::TYPES.merge(Bignum=>'integer')
       
       # Run all alter_table commands in a transaction.  This is technically only
       # needed for drop column.
@@ -27,6 +27,34 @@ module Sequel
         pragma_set(:auto_vacuum, value)
       end
       
+      # SQLite uses the :sqlite database type.
+      def database_type
+        :sqlite
+      end
+
+      # Return a hash containing index information. Hash keys are index name symbols.
+      # Values are subhashes with two keys, :columns and :unique.  The value of :columns
+      # is an array of symbols of column names.  The value of :unique is true or false
+      # depending on if the index is unique.
+      def indexes(table)
+        m = output_identifier_meth
+        im = input_identifier_meth
+        indexes = {}
+        begin
+          metadata_dataset.with_sql("PRAGMA index_list(?)", im.call(table)).each do |r|
+            next if r[:name] =~ PRIMARY_KEY_INDEX_RE
+            indexes[m.call(r[:name])] = {:unique=>r[:unique].to_i==1}
+          end
+        rescue Sequel::DatabaseError
+          nil
+        else
+          indexes.each do |k, v|
+            v[:columns] = metadata_dataset.with_sql("PRAGMA index_info(?)", im.call(k)).map(:name).map{|x| m.call(x)}
+          end
+        end
+        indexes
+      end
+
       # Get the value of the given PRAGMA.
       def pragma_get(name)
         self["PRAGMA #{name}"].single_value
@@ -53,11 +81,8 @@ module Sequel
       # Options:
       # * :server - Set the server to use.
       def tables(opts={})
-        ds = self[:sqlite_master].server(opts[:server]).filter(TABLES_FILTER)
-        ds.identifier_output_method = nil
-        ds.identifier_input_method = nil
-        ds2 = dataset
-        ds.map{|r| ds2.send(:output_identifier, r[:name])}
+        m = output_identifier_meth
+        metadata_dataset.from(:sqlite_master).server(opts[:server]).filter(TABLES_FILTER).map{|r| m.call(r[:name])}
       end
       
       # A symbol signifying the value of the temp_store PRAGMA.
@@ -141,6 +166,11 @@ module Sequel
         cols
       end
 
+      # Allow use without a generator, needed for the alter table hackery that Sequel allows.
+      def column_list_sql(generator)
+        generator.is_a?(Schema::Generator) ? super : generator.map{|c| column_definition_sql(c)}.join(', ')
+      end
+
       # The array of column schema hashes, except for the ones given in opts[:except]
       def defined_columns_for(table, opts={})
         cols = parse_pragma(table, {})
@@ -164,10 +194,7 @@ module Sequel
 
       # Parse the output of the table_info pragma
       def parse_pragma(table_name, opts)
-        ds2 = dataset
-        ds = self["PRAGMA table_info(?)", ds2.send(:input_identifier, table_name)]
-        ds.identifier_output_method = nil
-        ds.map do |row|
+        metadata_dataset.with_sql("PRAGMA table_info(?)", input_identifier_meth.call(table_name)).map do |row|
           row.delete(:cid)
           row[:allow_null] = row.delete(:notnull).to_i == 0
           row[:default] = row.delete(:dflt_value)
@@ -179,18 +206,26 @@ module Sequel
         end
       end
       
+      # SQLite treats integer primary keys as autoincrementing (alias of rowid).
+      def schema_autoincrementing_primary_key?(schema)
+        super and schema[:db_type].downcase == 'integer'
+      end
+
       # SQLite supports schema parsing using the table_info PRAGMA, so
       # parse the output of that into the format Sequel expects.
       def schema_parse_table(table_name, opts)
-        ds = dataset
+        m = output_identifier_meth
         parse_pragma(table_name, opts).map do |row|
-          [ds.send(:output_identifier, row.delete(:name)), row]
+          [m.call(row.delete(:name)), row]
         end
       end
       
-      # Override the standard type conversions with SQLite specific ones
-      def type_literal_base(column)
-        TYPES[column[:type]]
+      # SQLite uses the integer data type even for bignums.  This is because they
+      # are both stored internally as text, and converted when returned from
+      # the database.  Using an integer type instead of bigint makes it more likely
+      # that software will automatically return the column as an integer.
+      def type_literal_generic_bignum(column)
+        :integer
       end
     end
     
@@ -217,14 +252,8 @@ module Sequel
       # SQLite performs a TRUNCATE style DELETE if no filter is specified.
       # Since we want to always return the count of records, add a condition
       # that is always true and then delete.
-      def delete(opts = (defarg=true;{}))
-        # check if no filter is specified
-        if defarg
-          @opts[:where] ? super() : filter(1=>1).delete
-        else
-          opts = @opts.merge(opts)
-          super(opts[:where] ? opts : opts.merge(:where=>{1=>1}))
-        end
+      def delete
+        @opts[:where] ? super : filter(1=>1).delete
       end
       
       # Insert the values into the database.
@@ -256,6 +285,7 @@ module Sequel
       
       # SQLite uses string literals instead of identifiers in AS clauses.
       def as_sql(expression, aliaz)
+        aliaz = aliaz.value if aliaz.is_a?(SQL::Identifier)
         "#{expression} AS #{literal(aliaz.to_s)}"
       end
     end