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 



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

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


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

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.



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

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 



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

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 



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

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 



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

def charset
  database_parameters['NLS_CHARACTERSET']
end

#collation ⇒ Object 



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

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 ?!



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

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

#columns_for_distinct(columns, orders) ⇒ Object 



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

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 



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

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 



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

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

#current_schema ⇒ Object 



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

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

#current_schema=(schema_owner) ⇒ Object 



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

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

#current_user ⇒ Object 



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

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

#database_parameters ⇒ Object 



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

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 



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

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")



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

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

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



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

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 



573
574
575
576
577
578
579
580
 
# File 'lib/arjdbc/oracle/adapter.rb', line 573

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 



582
583
584
585
586
587
588
589
 
# File 'lib/arjdbc/oracle/adapter.rb', line 582

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 



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

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 



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

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 



559
560
561
562
563
564
565
566
567
568
569
570
 
# File 'lib/arjdbc/oracle/adapter.rb', line 559

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) 



532
533
534
535
536
537
538
539
540
541
542
543
544
545
 
# File 'lib/arjdbc/oracle/adapter.rb', line 532

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 



525
526
527
528
529
 
# File 'lib/arjdbc/oracle/adapter.rb', line 525

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:



518
519
520
521
522
 
# File 'lib/arjdbc/oracle/adapter.rb', line 518

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 



418
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
 
# File 'lib/arjdbc/oracle/adapter.rb', line 418

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 



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

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 



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

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 



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

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.



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

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 



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

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 



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

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

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



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

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 



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

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 



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

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 



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

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

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



549
550
551
552
553
554
555
556
 
# File 'lib/arjdbc/oracle/adapter.rb', line 549

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) 


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

def supports_explain?; true end

#supports_migrations? ⇒ Boolean

Returns:

  • (Boolean) 


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

def supports_migrations?; true end

#supports_primary_key? ⇒ Boolean

Returns:

  • (Boolean) 


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

def supports_primary_key?; true end

#supports_savepoints? ⇒ Boolean

Returns:

  • (Boolean) 


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

def supports_savepoints?; true end

#supports_views? ⇒ Boolean

Returns:

  • (Boolean) 


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

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 



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

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

#tablespace(table_name) ⇒ Object 



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

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) 


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

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

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



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

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 



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

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) 


603
604
605
606
607
608
 
# File 'lib/arjdbc/oracle/adapter.rb', line 603

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