Class Index [+]

Quicksearch

Sequel::Oracle::DatabaseMethods

Constants

TEMPORARY
AUTOINCREMENT

Attributes

autosequence[RW]

Public Instance Methods

create_sequence(name, opts={}) click to toggle source
    # File lib/sequel/adapters/shared/oracle.rb, line 11
11:       def create_sequence(name, opts={})
12:         self << create_sequence_sql(name, opts)
13:       end
create_trigger(*args) click to toggle source
    # File lib/sequel/adapters/shared/oracle.rb, line 15
15:       def create_trigger(*args)
16:         self << create_trigger_sql(*args)
17:       end
current_user() click to toggle source
    # File lib/sequel/adapters/shared/oracle.rb, line 19
19:       def current_user
20:         @current_user ||= metadata_dataset.get{sys_context('USERENV', 'CURRENT_USER')}
21:       end
database_type() click to toggle source

Oracle uses the :oracle database type

    # File lib/sequel/adapters/shared/oracle.rb, line 28
28:       def database_type
29:         :oracle
30:       end
drop_sequence(name) click to toggle source
    # File lib/sequel/adapters/shared/oracle.rb, line 23
23:       def drop_sequence(name)
24:         self << drop_sequence_sql(name)
25:       end
global_index_namespace?() click to toggle source

Oracle namespaces indexes per table.

    # File lib/sequel/adapters/shared/oracle.rb, line 33
33:       def global_index_namespace?
34:         false
35:       end
tables(opts={}) click to toggle source
    # File lib/sequel/adapters/shared/oracle.rb, line 37
37:       def tables(opts={})
38:         m = output_identifier_meth
39:         metadata_dataset.from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'TABLE').map{|r| m.call(r[:tname])}
40:       end
view_exists?(name) click to toggle source
    # File lib/sequel/adapters/shared/oracle.rb, line 47
47:       def view_exists?(name) 
48:         m = input_identifier_meth
49:         metadata_dataset.from(:tab).filter(:tname =>m.call(name), :tabtype => 'VIEW').count > 0 
50:       end
views(opts={}) click to toggle source
    # File lib/sequel/adapters/shared/oracle.rb, line 42
42:       def views(opts={}) 
43:         m = output_identifier_meth
44:         metadata_dataset.from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'VIEW').map{|r| m.call(r[:tname])}
45:       end

Private Instance Methods

alter_table_sql(table, op) click to toggle source

Handle Oracle specific ALTER TABLE SQL

    # File lib/sequel/adapters/shared/oracle.rb, line 55
55:       def alter_table_sql(table, op)
56:         case op[:op]
57:         when :add_column
58:           if op[:primary_key]
59:             sqls = []
60:             sqls << alter_table_sql(table, op.merge(:primary_key=>nil))
61:             if op[:auto_increment]
62:               seq_name = default_sequence_name(table, op[:name])
63:               sqls << drop_sequence_sql(seq_name)
64:               sqls << create_sequence_sql(seq_name, op)
65:               sqls << "UPDATE #{quote_schema_table(table)} SET #{quote_identifier(op[:name])} = #{seq_name}.nextval"
66:             end
67:             sqls << "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})"
68:             sqls
69:           else
70:              "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
71:           end
72:         when :set_column_null
73:           "ALTER TABLE #{quote_schema_table(table)} MODIFY #{quote_identifier(op[:name])} #{op[:null] ? 'NULL' : 'NOT NULL'}"
74:         when :set_column_type
75:           "ALTER TABLE #{quote_schema_table(table)} MODIFY #{quote_identifier(op[:name])} #{type_literal(op)}"
76:         when :set_column_default
77:           "ALTER TABLE #{quote_schema_table(table)} MODIFY #{quote_identifier(op[:name])} DEFAULT #{literal(op[:default])}"
78:         else
79:           super(table, op)
80:         end
81:       end
auto_increment_sql() click to toggle source
    # File lib/sequel/adapters/shared/oracle.rb, line 83
83:       def auto_increment_sql
84:         AUTOINCREMENT
85:       end
create_sequence_sql(name, opts={}) click to toggle source
    # File lib/sequel/adapters/shared/oracle.rb, line 87
87:       def create_sequence_sql(name, opts={})
88:         "CREATE SEQUENCE #{quote_identifier(name)} start with #{opts [:start_with]||1} increment by #{opts[:increment_by]||1} nomaxvalue"
89:       end
create_table_from_generator(name, generator, options) click to toggle source
    # File lib/sequel/adapters/shared/oracle.rb, line 91
91:       def create_table_from_generator(name, generator, options)
92:         drop_statement, create_statements = create_table_sql_list(name, generator, options)
93:         (execute_ddl(drop_statement) rescue nil) if drop_statement
94:         create_statements.each{|sql| execute_ddl(sql)}
95:       end
create_table_sql_list(name, generator, options={}) click to toggle source
     # File lib/sequel/adapters/shared/oracle.rb, line 97
 97:       def create_table_sql_list(name, generator, options={})
 98:         statements = [create_table_sql(name, generator, options)]
 99:         drop_seq_statement = nil
100:         generator.columns.each do |c|
101:           if c[:auto_increment]
102:             c[:sequence_name] ||= default_sequence_name(name, c[:name])
103:             unless c[:create_sequence] == false
104:               drop_seq_statement = drop_sequence_sql(c[:sequence_name])
105:               statements << create_sequence_sql(c[:sequence_name], c)
106:             end
107:             unless c[:create_trigger] == false
108:               c[:trigger_name] ||= "BI_#{name}_#{c[:name]}"
109:               trigger_definition =               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;
110:               statements << create_trigger_sql(name, c[:trigger_name], trigger_definition, {:events => [:insert]})
111:             end
112:           end
113:         end
114:         [drop_seq_statement, statements]
115:       end
create_trigger_sql(table, name, definition, opts={}) click to toggle source
     # File lib/sequel/adapters/shared/oracle.rb, line 123
123:       def create_trigger_sql(table, name, definition, opts={})
124:         events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
125:         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}
126:         sql
127:       end
default_sequence_name(table, column) click to toggle source
     # File lib/sequel/adapters/shared/oracle.rb, line 134
134:       def default_sequence_name(table, column)
135:         "seq_#{table}_#{column}"
136:       end
drop_sequence_sql(name) click to toggle source
     # File lib/sequel/adapters/shared/oracle.rb, line 138
138:       def drop_sequence_sql(name)
139:         "DROP SEQUENCE #{quote_identifier(name)}"
140:       end
remove_cached_schema(table) click to toggle source
     # File lib/sequel/adapters/shared/oracle.rb, line 142
142:       def remove_cached_schema(table)
143:         @primary_key_sequences.delete(table)
144:         super
145:       end
sequence_for_table(table) click to toggle source
     # File lib/sequel/adapters/shared/oracle.rb, line 147
147:       def sequence_for_table(table)
148:         return nil unless autosequence
149:         @primary_key_sequences.fetch(table) do |key|
150:           pk = schema(table).select{|k, v| v[:primary_key]}
151:           @primary_key_sequences[table] = if pk.length == 1
152:             seq = "seq_#{table}_#{pk.first.first}"
153:             seq.to_sym unless from(:user_sequences).filter(:sequence_name=>input_identifier_meth.call(seq)).empty?
154:           end
155:         end
156:       end
temporary_table_sql() click to toggle source

SQL fragment for showing a table is temporary

     # File lib/sequel/adapters/shared/oracle.rb, line 178
178:       def temporary_table_sql
179:         TEMPORARY
180:       end
type_literal_generic_bignum(column) click to toggle source

Oracle’s integer/:number type handles larger values than most other databases’s bigint types, so it should be safe to use for Bignum.

     # File lib/sequel/adapters/shared/oracle.rb, line 161
161:       def type_literal_generic_bignum(column)
162:         :integer
163:       end
type_literal_generic_time(column) click to toggle source

Oracle doesn’t have a time type, so use timestamp for all time columns.

     # File lib/sequel/adapters/shared/oracle.rb, line 167
167:       def type_literal_generic_time(column)
168:         :timestamp
169:       end
type_literal_generic_trueclass(column) click to toggle source

Oracle doesn’t have a boolean type or even a reasonable facsimile. Using a char(1) seems to be the recommended way.

     # File lib/sequel/adapters/shared/oracle.rb, line 173
173:       def type_literal_generic_trueclass(column)
174:         :'char(1)'
175:       end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.