Module: ArJdbc::Oracle

Included in:
ActiveRecord::ConnectionAdapters::OracleAdapter
Defined in:
lib/arjdbc/oracle/column.rb,
lib/arjdbc/oracle/adapter.rb

Defined Under Namespace

Modules: Column Classes: TableDefinition

Constant Summary collapse

ADAPTER_NAME = 
'Oracle'.freeze
NATIVE_DATABASE_TYPES = 
{
  :primary_key => "NUMBER(38) NOT NULL PRIMARY KEY",
  :string => { :name => "VARCHAR2", :limit => 255 },
  :text => { :name => "CLOB" },
  :integer => { :name => "NUMBER", :limit => 38 },
  :float => { :name => "NUMBER" },
  :decimal => { :name => "DECIMAL" },
  :datetime => { :name => "DATE" },
  :timestamp => { :name => "TIMESTAMP" },
  :time => { :name => "DATE" },
  :date => { :name => "DATE" },
  :binary => { :name => "BLOB" },
  :boolean => { :name => "NUMBER", :limit => 1 },
  :raw => { :name => "RAW", :limit => 2000 },
  :xml => { :name => 'XMLTYPE' }
}
IDENTIFIER_LENGTH = 
30

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.arel_visitor_type(config = nil) ⇒ Object 



85
86
87
 
# File 'lib/arjdbc/oracle/adapter.rb', line 85

def self.arel_visitor_type(config = nil)
  ::Arel::Visitors::Oracle
end

.column_selector ⇒ Object

See Also:

  • ActiveRecord::ConnectionAdapters::JdbcColumn#column_types


5
6
7
 
# File 'lib/arjdbc/oracle/column.rb', line 5

def self.column_selector
  [ /oracle/i, lambda { |config, column| column.extend(Column) } ]
end

.emulate_booleans ⇒ Object

Deprecated.

Use #emulate_booleans? instead.



65
 
# File 'lib/arjdbc/oracle/adapter.rb', line 65

def self.emulate_booleans; @@emulate_booleans; end

.emulate_booleans=(emulate) ⇒ Object

See Also:

  • #emulate_booleans?


67
 
# File 'lib/arjdbc/oracle/adapter.rb', line 67

def self.emulate_booleans=(emulate); @@emulate_booleans = emulate; end

.emulate_booleans? ⇒ Boolean

Boolean emulation can be disabled using :

ArJdbc::Oracle.emulate_booleans = false

Returns:

  • (Boolean)

See Also:

  • ActiveRecord::ConnectionAdapters::OracleAdapter#emulate_booleans


63
 
# File 'lib/arjdbc/oracle/adapter.rb', line 63

def self.emulate_booleans?; @@emulate_booleans; end

.jdbc_connection_class ⇒ Object

See Also:



29
30
31
 
# File 'lib/arjdbc/oracle/adapter.rb', line 29

def self.jdbc_connection_class
  ::ActiveRecord::ConnectionAdapters::OracleJdbcConnection
end

.update_lob_values=(update) ⇒ Object

See Also:

  • #update_lob_values?


47
 
# File 'lib/arjdbc/oracle/adapter.rb', line 47

def self.update_lob_values=(update); @@update_lob_values = update; end

.update_lob_values? ⇒ Boolean

Note:

This only applies when prepared statements are not used.

Updating records with LOB values (binary/text columns) in a separate statement can be disabled using :

ArJdbc::Oracle.update_lob_values = false

Returns:

  • (Boolean) 


45
 
# File 'lib/arjdbc/oracle/adapter.rb', line 45

def self.update_lob_values?; @@update_lob_values; end

Instance Method Details

#adapter_name ⇒ Object 



97
98
99
 
# File 'lib/arjdbc/oracle/adapter.rb', line 97

def adapter_name
  ADAPTER_NAME
end

#add_column_options!(sql, options) ⇒ Object 



258
259
260
261
262
263
264
 
# File 'lib/arjdbc/oracle/adapter.rb', line 258

def add_column_options!(sql, options)
  # handle case  of defaults for CLOB columns, which would otherwise get "quoted" incorrectly
  if options_include_default?(options) && (column = options[:column]) && column.type == :text
    sql << " DEFAULT #{quote(options.delete(:default))}"
  end
  super
end

#add_limit_offset!(sql, options) ⇒ Object

Note:

Only used with (non-AREL) ActiveRecord 2.3.

See Also:

  • Arel::Visitors::Oracle


214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/arjdbc/oracle/adapter.rb', line 214

def add_limit_offset!(sql, options)
  offset = options[:offset] || 0
  if limit = options[:limit]
    sql.replace "SELECT * FROM " <<
      "(select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_ where rownum <= #{offset + limit})" <<
      " WHERE raw_rnum_ > #{offset}"
  elsif offset > 0
    sql.replace "SELECT * FROM " <<
      "(select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_)" <<
      " WHERE raw_rnum_ > #{offset}"
  end
end

#add_order_by_for_association_limiting!(sql, options) ⇒ Object

ORDER BY clause for the passed order option.

Uses column aliases as defined by #distinct.



340
341
342
343
344
345
346
347
348
349
 
# File 'lib/arjdbc/oracle/adapter.rb', line 340

def add_order_by_for_association_limiting!(sql, options)
  return sql if options[:order].blank?

  order_columns = extract_order_columns(options[:order]) do |columns|
    columns.map! { |s| $1 if s =~ / (.*)/ }; columns
  end
  order = order_columns.map { |s, i| "alias_#{i}__ #{s}" } # @see {#distinct}

  sql << "ORDER BY #{order.join(', ')}"
end

#change_column(table_name, column_name, type, options = {}) ⇒ Object 



267
268
269
270
271
272
 
# File 'lib/arjdbc/oracle/adapter.rb', line 267

def change_column(table_name, column_name, type, options = {})
  change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} " <<
    "MODIFY #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit])}"
  add_column_options!(change_column_sql, options)
  execute(change_column_sql)
end

#change_column_default(table_name, column_name, default) ⇒ Object 



252
253
254
255
 
# File 'lib/arjdbc/oracle/adapter.rb', line 252

def change_column_default(table_name, column_name, default)
  execute "ALTER TABLE #{quote_table_name(table_name)} " +
    "MODIFY #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
end

#charset ⇒ Object 



376
377
378
 
# File 'lib/arjdbc/oracle/adapter.rb', line 376

def charset
  database_parameters['NLS_CHARACTERSET']
end

#collation ⇒ Object 



380
381
382
 
# File 'lib/arjdbc/oracle/adapter.rb', line 380

def collation
  database_parameters['NLS_COMP']
end

#column_name_length ⇒ Object 



142
 
# File 'lib/arjdbc/oracle/adapter.rb', line 142

def column_name_length; IDENTIFIER_LENGTH; end

#columns(table_name, name = nil) ⇒ Object

NOTE: better to use current_schema instead of the configured one ?!



368
369
370
 
# File 'lib/arjdbc/oracle/adapter.rb', line 368

def columns(table_name, name = nil)
  @connection.columns_internal(table_name.to_s, nil, oracle_schema)
end

#columns_for_distinct(columns, orders) ⇒ Object 



321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
 
# File 'lib/arjdbc/oracle/adapter.rb', line 321

def columns_for_distinct(columns, orders)
  return columns if orders.blank?
  if orders.is_a?(Array) # AR 3.x vs 4.x
    orders = orders.map { |column| column.is_a?(String) ? column : column.to_sql }
  else
    orders = extract_order_columns(orders)
  end
  # construct a valid DISTINCT clause, ie. one that includes the ORDER BY columns, using
  # FIRST_VALUE such that the inclusion of these columns doesn't invalidate the DISTINCT
  order_columns = orders.map do |c, i|
    "FIRST_VALUE(#{c.split.first}) OVER (PARTITION BY #{columns} ORDER BY #{c}) AS alias_#{i}__"
  end
  columns = [ columns ]; columns.flatten!
  columns.push( *order_columns ).join(', ')
end

#create_table(name, options = {}) ⇒ Object 



151
152
153
154
155
156
157
158
159
 
# File 'lib/arjdbc/oracle/adapter.rb', line 151

def create_table(name, options = {})
  super(name, options)
  unless options[:id] == false
    seq_name = options[:sequence_name] || default_sequence_name(name)
    start_value = options[:sequence_start_value] || 10000
    raise ActiveRecord::StatementInvalid.new("name #{seq_name} too long") if seq_name.length > table_alias_length
    execute "CREATE SEQUENCE #{quote_table_name(seq_name)} START WITH #{start_value}"
  end
end

#current_database ⇒ Object 



231
232
233
 
# File 'lib/arjdbc/oracle/adapter.rb', line 231

def current_database
  @current_database ||= execute("SELECT sys_context('userenv', 'db_name') db FROM dual").first['db']
end

#current_schema ⇒ Object 



235
236
237
 
# File 'lib/arjdbc/oracle/adapter.rb', line 235

def current_schema
  execute("SELECT sys_context('userenv', 'current_schema') schema FROM dual").first['schema']
end

#current_schema=(schema_owner) ⇒ Object 



239
240
241
 
# File 'lib/arjdbc/oracle/adapter.rb', line 239

def current_schema=(schema_owner)
  execute("ALTER SESSION SET current_schema=#{schema_owner}")
end

#current_user ⇒ Object 



227
228
229
 
# File 'lib/arjdbc/oracle/adapter.rb', line 227

def current_user
  @current_user ||= execute("SELECT sys_context('userenv', 'session_user') su FROM dual").first['su']
end

#database_parameters ⇒ Object 



384
385
386
387
388
389
390
 
# File 'lib/arjdbc/oracle/adapter.rb', line 384

def database_parameters
  return @database_parameters unless ( @database_parameters ||= {} ).empty?
  @connection.execute_query_raw("SELECT * FROM NLS_DATABASE_PARAMETERS") do
    |name, value| @database_parameters[name] = value
  end
  @database_parameters
end

#default_sequence_name(table_name, column = nil) ⇒ Object 



145
146
147
148
 
# File 'lib/arjdbc/oracle/adapter.rb', line 145

def default_sequence_name(table_name, column = nil)
  # TODO: remove schema prefix if present (before truncating)
  "#{table_name.to_s[0, IDENTIFIER_LENGTH - 4]}_seq"
end

#distinct(columns, order_by) ⇒ Object

SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.

Oracle requires the ORDER BY columns to be in the SELECT list for DISTINCT queries. However, with those columns included in the SELECT DISTINCT list, you won't actually get a distinct list of the column you want (presuming the column has duplicates with multiple values for the ordered-by columns. So we use the FIRST_VALUE function to get a single (first) value for each column, effectively making every row the same.

distinct("posts.id", "posts.created_at desc")



316
317
318
 
# File 'lib/arjdbc/oracle/adapter.rb', line 316

def distinct(columns, order_by)
  "DISTINCT #{columns_for_distinct(columns, order_by)}"
end

#drop_table(name, options = {}) ⇒ Object 



174
175
176
177
178
179
180
181
 
# File 'lib/arjdbc/oracle/adapter.rb', line 174

def drop_table(name, options = {})
  outcome = super(name)
  return outcome if name == 'schema_migrations'
  seq_name = options.key?(:sequence_name) ? # pass nil/false - no sequence
    options[:sequence_name] : default_sequence_name(name)
  return outcome unless seq_name
  execute "DROP SEQUENCE #{quote_table_name(seq_name)}" rescue nil
end

#exec_insert(sql, name, binds, pk = nil, sequence_name = nil) ⇒ Object 



578
579
580
581
582
583
584
585
 
# File 'lib/arjdbc/oracle/adapter.rb', line 578

def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
  if pk && use_insert_returning?
    if sql.is_a?(String) && sql.index('RETURNING')
      return exec_insert_returning(sql, name, binds, pk)
    end
  end
  super(sql, name, binds) # assume no generated id for table
end

#exec_insert_returning(sql, name, binds, pk = nil) ⇒ Object 



587
588
589
590
591
592
593
594
 
# File 'lib/arjdbc/oracle/adapter.rb', line 587

def exec_insert_returning(sql, name, binds, pk = nil)
  sql = to_sql(sql, binds) if sql.respond_to?(:to_sql)
  if prepared_statements?
    log(sql, name, binds) { @connection.execute_insert_returning(sql, binds) }
  else
    log(sql, name) { @connection.execute_insert_returning(sql, nil) }
  end
end

#explain(arel, binds = []) ⇒ Object 



505
506
507
508
509
510
 
# File 'lib/arjdbc/oracle/adapter.rb', line 505

def explain(arel, binds = [])
  sql = "EXPLAIN PLAN FOR #{to_sql(arel, binds)}"
  return if sql =~ /FROM all_/
  exec_update(sql, 'EXPLAIN', binds)
  select_values("SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY)", 'EXPLAIN').join("\n")
end

#in_clause_length ⇒ Object Also known as: ids_in_list_limit

Prevent ORA-01795 for in clauses with more than 1000



131
132
133
 
# File 'lib/arjdbc/oracle/adapter.rb', line 131

def in_clause_length
  1000
end

#index_name_length ⇒ Object 



141
 
# File 'lib/arjdbc/oracle/adapter.rb', line 141

def index_name_length;  IDENTIFIER_LENGTH; end

#indexes(table, name = nil) ⇒ Object 



208
209
210
 
# File 'lib/arjdbc/oracle/adapter.rb', line 208

def indexes(table, name = nil)
  @connection.indexes(table, name, @connection.connection.meta_data.user_name)
end

#insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) ⇒ Object 



564
565
566
567
568
569
570
571
572
573
574
575
 
# File 'lib/arjdbc/oracle/adapter.rb', line 564

def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
  # NOTE: ActiveRecord::Relation calls our {#next_sequence_value}
  # (from its `insert`) and passes the returned id_value here ...
  sql, binds = sql_for_insert(to_sql(arel, binds), pk, id_value, sequence_name, binds)
  if id_value
    exec_update(sql, name, binds)
    return id_value
  else
    value = exec_insert(sql, name, binds, pk, sequence_name)
    id_value || last_inserted_id(value)
  end
end

#insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) ⇒ Object (protected) 



537
538
539
540
541
542
543
544
545
546
547
548
549
550
 
# File 'lib/arjdbc/oracle/adapter.rb', line 537

def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
  # if PK is already pre-fetched from sequence or if there is no PK :
  if id_value || pk.nil?
    execute(sql, name)
    return id_value
  end

  if pk && use_insert_returning? # true by default on AR <= 3.0
    sql = "#{sql} RETURNING #{quote_column_name(pk)} INTO ?"
    exec_insert_returning(sql, name, nil, pk)
  else
    execute(sql, name)
  end
end

#jdbc_column_class ⇒ Object

See Also:



34
 
# File 'lib/arjdbc/oracle/adapter.rb', line 34

def jdbc_column_class; ::ActiveRecord::ConnectionAdapters::OracleColumn end

#modify_types(types) ⇒ Object 



122
123
124
125
126
127
128
 
# File 'lib/arjdbc/oracle/adapter.rb', line 122

def modify_types(types)
  super(types)
  NATIVE_DATABASE_TYPES.each do |key, value|
    types[key] = value.dup
  end
  types
end

#native_database_types ⇒ Object 



118
119
120
 
# File 'lib/arjdbc/oracle/adapter.rb', line 118

def native_database_types
  super.merge(NATIVE_DATABASE_TYPES)
end

#next_sequence_value(sequence_name) ⇒ Object 



530
531
532
533
534
 
# File 'lib/arjdbc/oracle/adapter.rb', line 530

def next_sequence_value(sequence_name)
  sequence_name = quote_table_name(sequence_name)
  sql = "SELECT #{sequence_name}.NEXTVAL id FROM dual"
  log(sql, 'SQL') { @connection.next_sequence_value(sequence_name) }
end

#prefetch_primary_key?(table_name = nil) ⇒ Boolean

Returns true for Oracle adapter (since Oracle requires primary key values to be pre-fetched before insert).

Returns:

  • (Boolean)

See Also:



523
524
525
526
527
 
# File 'lib/arjdbc/oracle/adapter.rb', line 523

def prefetch_primary_key?(table_name = nil)
  return true if table_name.nil?
  table_name = table_name.to_s
  columns(table_name).count { |column| column.primary } == 1
end

#quote(value, column = nil) ⇒ Object 



419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
 
# File 'lib/arjdbc/oracle/adapter.rb', line 419

def quote(value, column = nil)
  return value if sql_literal?(value)

  column_type = column && column.type
  if column_type == :text || column_type == :binary
    return 'NULL' if value.nil? || value == ''
    if update_lob_value?(value, column)
      if /(.*?)\([0-9]+\)/ =~ ( sql_type = column.sql_type )
        %Q{empty_#{ $1.downcase }()}
      else
        %Q{empty_#{ sql_type.respond_to?(:downcase) ? sql_type.downcase : 'blob' }()}
      end
    else
      "'#{quote_string(value.to_s)}'"
    end
  elsif column_type == :xml
    "XMLTYPE('#{quote_string(value)}')" # XMLTYPE ?
  elsif column_type == :raw
    quote_raw(value)
  else
    if column.respond_to?(:primary) && column.primary && column.klass != String
      return value.to_i.to_s
    end

    if column_type == :datetime || column_type == :time
      if value.acts_like?(:time)
        %Q{TO_DATE('#{get_time(value).strftime("%Y-%m-%d %H:%M:%S")}','YYYY-MM-DD HH24:MI:SS')}
      else
        value.blank? ? 'NULL' : %Q{DATE'#{value}'} # assume correctly formated DATE (string)
      end
    elsif ( like_date = value.acts_like?(:date) ) || column_type == :date
      if value.acts_like?(:time) # value.respond_to?(:strftime)
        %Q{DATE'#{get_time(value).strftime("%Y-%m-%d")}'}
      elsif like_date
        %Q{DATE'#{quoted_date(value)}'} # DATE 'YYYY-MM-DD'
      else
        value.blank? ? 'NULL' : %Q{DATE'#{value}'} # assume correctly formated DATE (string)
      end
    elsif ( like_time = value.acts_like?(:time) ) || column_type == :timestamp
      if like_time
        %Q{TIMESTAMP'#{quoted_date(value, true)}'} # TIMESTAMP 'YYYY-MM-DD HH24:MI:SS.FF'
      else
        value.blank? ? 'NULL' : %Q{TIMESTAMP'#{value}'} # assume correctly formated TIMESTAMP (string)
      end
    else
      super
    end
  end
end

#quote_column_name(name) ⇒ Object 



400
401
402
403
404
405
406
407
408
409
410
411
 
# File 'lib/arjdbc/oracle/adapter.rb', line 400

def quote_column_name(name)
  # if only valid lowercase column characters in name
  if ( name = name.to_s ) =~ /\A[a-z][a-z_0-9\$#]*\Z/
    # putting double-quotes around an identifier causes Oracle to treat the
    # identifier as case sensitive (otherwise assumes case-insensitivity) !
    # all upper case is an exception, where double-quotes are meaningless
    "\"#{name.upcase}\"" # name.upcase
  else
    # remove double quotes which cannot be used inside quoted identifier
    "\"#{name.gsub('"', '')}\""
  end
end

#quote_raw(value) ⇒ Object 



481
482
483
484
 
# File 'lib/arjdbc/oracle/adapter.rb', line 481

def quote_raw(value)
  value = value.unpack('C*') if value.is_a?(String)
  "'#{value.map { |x| "%02X" % x }.join}'"
end

#quote_table_name(name) ⇒ Object 



395
396
397
 
# File 'lib/arjdbc/oracle/adapter.rb', line 395

def quote_table_name(name)
  name.to_s.split('.').map{ |n| n.split('@').map{ |m| quote_column_name(m) }.join('@') }.join('.')
end

#quoted_date(value, time = nil) ⇒ Object

Quote date/time values for use in SQL input. Includes milliseconds if the value is a Time responding to usec.



472
473
474
475
476
477
478
479
 
# File 'lib/arjdbc/oracle/adapter.rb', line 472

def quoted_date(value, time = nil)
  if time || ( time.nil? && value.acts_like?(:time) )
    usec = value.respond_to?(:usec) && (value.usec / 10000.0).round # .428000 -> .43
    return "#{get_time(value).to_s(:db)}.#{sprintf("%02d", usec)}" if usec
    # value.strftime("%Y-%m-%d %H:%M:%S")
  end
  value.to_s(:db)
end

#release_savepoint(name = nil) ⇒ Object 



244
245
246
 
# File 'lib/arjdbc/oracle/adapter.rb', line 244

def release_savepoint(name = nil)
  # no RELEASE SAVEPOINT statement in Oracle (JDBC driver throws "Unsupported feature")
end

#remove_column(table_name, *column_names) ⇒ Object Also known as: remove_columns 



283
284
285
 
# File 'lib/arjdbc/oracle/adapter.rb', line 283

def remove_column(table_name, column_name, type = nil, options = {})
  do_remove_column(table_name, column_name)
end

#remove_index(table_name, options = {}) ⇒ Object 



248
249
250
 
# File 'lib/arjdbc/oracle/adapter.rb', line 248

def remove_index(table_name, options = {})
  execute "DROP INDEX #{index_name(table_name, options)}"
end

#rename_column(table_name, column_name, new_column_name) ⇒ Object 



275
276
277
278
 
# File 'lib/arjdbc/oracle/adapter.rb', line 275

def rename_column(table_name, column_name, new_column_name)
  execute "ALTER TABLE #{quote_table_name(table_name)} " <<
    "RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
end

#rename_table(name, new_name) ⇒ Object 



162
163
164
165
166
167
168
169
170
171
 
# File 'lib/arjdbc/oracle/adapter.rb', line 162

def rename_table(name, new_name)
  if new_name.to_s.length > table_name_length
    raise ArgumentError, "New table name '#{new_name}' is too long; the limit is #{table_name_length} characters"
  end
  if "#{new_name}_seq".to_s.length > sequence_name_length
    raise ArgumentError, "New sequence name '#{new_name}_seq' is too long; the limit is #{sequence_name_length} characters"
  end
  execute "RENAME #{quote_table_name(name)} TO #{quote_table_name(new_name)}"
  execute "RENAME #{quote_table_name("#{name}_seq")} TO #{quote_table_name("#{new_name}_seq")}" rescue nil
end

#select(sql, name = nil, binds = []) ⇒ Object 



512
513
514
515
516
517
 
# File 'lib/arjdbc/oracle/adapter.rb', line 512

def select(sql, name = nil, binds = [])
  result = super # AR::Result (4.0) or Array (<= 3.2)
  result.columns.delete('raw_rnum_') if result.respond_to?(:columns)
  result.each { |row| row.delete('raw_rnum_') } # Hash rows even for AR::Result
  result
end

#sequence_name_length ⇒ Object 



143
 
# File 'lib/arjdbc/oracle/adapter.rb', line 143

def sequence_name_length; IDENTIFIER_LENGTH end

#sql_for_insert(sql, pk, id_value, sequence_name, binds) ⇒ Object 



554
555
556
557
558
559
560
561
 
# File 'lib/arjdbc/oracle/adapter.rb', line 554

def sql_for_insert(sql, pk, id_value, sequence_name, binds)
  unless id_value || pk.nil?
    if pk && use_insert_returning?
      sql = "#{sql} RETURNING #{quote_column_name(pk)} INTO ?"
    end
  end
  [ sql, binds ]
end

#supports_explain? ⇒ Boolean

Returns:

  • (Boolean) 


496
 
# File 'lib/arjdbc/oracle/adapter.rb', line 496

def supports_explain?; true end

#supports_migrations? ⇒ Boolean

Returns:

  • (Boolean) 


487
 
# File 'lib/arjdbc/oracle/adapter.rb', line 487

def supports_migrations?; true end

#supports_primary_key? ⇒ Boolean

Returns:

  • (Boolean) 


490
 
# File 'lib/arjdbc/oracle/adapter.rb', line 490

def supports_primary_key?; true end

#supports_savepoints? ⇒ Boolean

Returns:

  • (Boolean) 


493
 
# File 'lib/arjdbc/oracle/adapter.rb', line 493

def supports_savepoints?; true end

#supports_views? ⇒ Boolean

Returns:

  • (Boolean) 


499
 
# File 'lib/arjdbc/oracle/adapter.rb', line 499

def supports_views?; true end

#table_alias_length ⇒ Object

maximum length of Oracle identifiers is 30



139
 
# File 'lib/arjdbc/oracle/adapter.rb', line 139

def table_alias_length; IDENTIFIER_LENGTH; end

#table_definition(*args) ⇒ Object 



81
82
83
 
# File 'lib/arjdbc/oracle/adapter.rb', line 81

def table_definition(*args)
  new_table_definition(TableDefinition, *args)
end

#table_name_length ⇒ Object 



140
 
# File 'lib/arjdbc/oracle/adapter.rb', line 140

def table_name_length;  IDENTIFIER_LENGTH; end

#tables ⇒ Object 



363
364
365
 
# File 'lib/arjdbc/oracle/adapter.rb', line 363

def tables
  @connection.tables(nil, oracle_schema)
end

#tablespace(table_name) ⇒ Object 



372
373
374
 
# File 'lib/arjdbc/oracle/adapter.rb', line 372

def tablespace(table_name)
  select_value "SELECT tablespace_name FROM user_tables WHERE table_name='#{table_name.to_s.upcase}'"
end

#temporary_table?(table_name) ⇒ Boolean

Returns:

  • (Boolean) 


359
360
361
 
# File 'lib/arjdbc/oracle/adapter.rb', line 359

def temporary_table?(table_name)
  select_value("SELECT temporary FROM user_tables WHERE table_name = '#{table_name.upcase}'") == 'Y'
end

#truncate(table_name, name = nil) ⇒ Object 



501
502
503
 
# File 'lib/arjdbc/oracle/adapter.rb', line 501

def truncate(table_name, name = nil)
  execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
end

#type_to_sql(type, limit = nil, precision = nil, scale = nil) ⇒ Object 



184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'lib/arjdbc/oracle/adapter.rb', line 184

def type_to_sql(type, limit = nil, precision = nil, scale = nil)
  case type.to_sym
  when :binary
    # { BLOB | BINARY LARGE OBJECT } [ ( length [{K |M |G }] ) ]
    # although Oracle does not like limit (length) with BLOB (or CLOB) :
    #
    # CREATE TABLE binaries (data BLOB, short_data BLOB(1024));
    # ORA-00907: missing right parenthesis             *
    #
    # TODO do we need to worry about NORMAL vs. non IN-TABLE BLOBs ?!
    # http://dba.stackexchange.com/questions/8770/improve-blob-writing-performance-in-oracle-11g
    # - if the LOB is smaller than 3900 bytes it can be stored inside the
    #   table row; by default this is enabled,
    #   unless you specify DISABLE STORAGE IN ROW
    # - normal LOB - stored in a separate segment, outside of table,
    #   you may even put it in another tablespace;
    super(type, nil, nil, nil)
  when :text
    super(type, nil, nil, nil)
  else
    super
  end
end

#unquote_table_name(name) ⇒ Object 



413
414
415
416
 
# File 'lib/arjdbc/oracle/adapter.rb', line 413

def unquote_table_name(name)
  name = name[1...-1] if name[0, 1] == '"'
  name.upcase == name ? name.downcase : name
end

#update_lob_value?(value, column = nil) ⇒ Boolean

Returns:

  • (Boolean)

See Also:



51
52
53
 
# File 'lib/arjdbc/oracle/adapter.rb', line 51

def update_lob_value?(value, column = nil)
  Oracle.update_lob_values? && ! prepared_statements? && ! ( value.nil? || value == '' )
end

#use_insert_returning? ⇒ Boolean

Returns:

  • (Boolean) 


608
609
610
611
612
613
 
# File 'lib/arjdbc/oracle/adapter.rb', line 608

def use_insert_returning?
  if @use_insert_returning.nil?
    @use_insert_returning = false
  end
  @use_insert_returning
end