Module Sequel::Oracle
In: lib/sequel/adapters/oracle.rb
lib/sequel/adapters/shared/oracle.rb

Methods

Classes and Modules

Module Sequel::Oracle::DatabaseMethods
Module Sequel::Oracle::DatasetMethods
Class Sequel::Oracle::Database
Class Sequel::Oracle::Dataset

Public Class methods

[Source]

    # File lib/sequel/adapters/shared/oracle.rb, line 9
 9:     def self.mock_adapter_setup(db)
10:       db.instance_exec do
11:         @server_version = 11000000
12:         @primary_key_sequences = {}
13:       end
14:     end

Public Instance methods

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 324
324:       def complex_expression_sql_append(sql, op, args)
325:         case op
326:         when :&
327:           complex_expression_arg_pairs_append(sql, args, &BITAND_PROC)
328:         when :|
329:           complex_expression_arg_pairs_append(sql, args){|a, b| Sequel.lit(["(", " - ", " + ", ")"], a, complex_expression_arg_pairs([a, b], &BITAND_PROC), b)}
330:         when :^
331:           complex_expression_arg_pairs_append(sql, args) do |*x|
332:             s1 = complex_expression_arg_pairs(x){|a, b| Sequel.lit(["(", " - ", " + ", ")"], a, complex_expression_arg_pairs([a, b], &BITAND_PROC), b)}
333:             s2 = complex_expression_arg_pairs(x, &BITAND_PROC)
334:             Sequel.lit(["(", " - ", ")"], s1, s2)
335:           end
336:         when :~, '!~''!~', '~*''~*', '!~*''!~*'
337:           raise InvalidOperation, "Pattern matching via regular expressions is not supported in this Oracle version" unless supports_regexp?
338:           if op == '!~''!~' || op == '!~*''!~*'
339:             sql << 'NOT '
340:           end
341:           sql << 'REGEXP_LIKE('
342:           literal_append(sql, args[0])
343:           sql << ','
344:           literal_append(sql, args[1])
345:           if op == '~*''~*' || op == '!~*''!~*'
346:             sql << ", 'i'"
347:           end
348:           sql << ')'
349:         when :%, :<<, :>>, 'B~''B~'
350:           complex_expression_emulate_append(sql, op, args)
351:         else
352:           super
353:         end
354:       end

Oracle doesn‘t support CURRENT_TIME, as it doesn‘t have a type for storing just time values without a date, so use CURRENT_TIMESTAMP in its place.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 359
359:       def constant_sql_append(sql, c)
360:         if c == :CURRENT_TIME
361:           super(sql, :CURRENT_TIMESTAMP)
362:         else
363:           super
364:         end
365:       end

Use a custom expression with EXISTS to determine whether a dataset is empty.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 375
375:       def empty?
376:         db[:dual].where(@opts[:offset] ? exists : unordered.exists).get(1) == nil
377:       end

Oracle uses MINUS instead of EXCEPT, and doesn‘t support EXCEPT ALL

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 368
368:       def except(dataset, opts=OPTS)
369:         raise(Sequel::Error, "EXCEPT ALL not supported") if opts[:all]
370:         compound_clone(:minus, dataset, opts)
371:       end

Oracle requires recursive CTEs to have column aliases.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 443
443:       def recursive_cte_requires_column_aliases?
444:         true
445:       end

Oracle requires SQL standard datetimes

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 380
380:       def requires_sql_standard_datetimes?
381:         true
382:       end

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 426
426:       def select_limit_sql(sql)
427:         return unless supports_fetch_next_rows?
428: 
429:         if offset = @opts[:offset]
430:           sql << " OFFSET "
431:           literal_append(sql, offset)
432:           sql << " ROWS"
433:         end
434: 
435:         if limit = @opts[:limit]
436:           sql << " FETCH NEXT "
437:           literal_append(sql, limit)
438:           sql << " ROWS ONLY"
439:         end
440:       end

Handle LIMIT by using a unlimited subselect filtered with ROWNUM, unless Oracle 12 is used.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 393
393:       def select_sql
394:         return super if @opts[:sql]
395:         return super if supports_fetch_next_rows?
396: 
397:         o = @opts[:offset]
398:         if o && o != 0
399:           columns = clone(:append_sql=>String.new, :placeholder_literal_null=>true).columns
400:           dsa1 = dataset_alias(1)
401:           rn = row_number_column
402:           limit = @opts[:limit]
403:           ds = unlimited.
404:             from_self(:alias=>dsa1).
405:             select_append(ROW_NUMBER_EXPRESSION.as(rn)).
406:             from_self(:alias=>dsa1).
407:             select(*columns).
408:             where(SQL::Identifier.new(rn) > o)
409:           ds = ds.where(SQL::Identifier.new(rn) <= Sequel.+(o, limit)) if limit
410:           sql = @opts[:append_sql] || String.new
411:           subselect_sql_append(sql, ds)
412:           sql
413:         elsif limit = @opts[:limit]
414:           ds = unlimited
415:           # Lock doesn't work in subselects, so don't use a subselect when locking.
416:           # Don't use a subselect if custom SQL is used, as it breaks somethings.
417:           ds = ds.from_self unless @opts[:lock]
418:           sql = @opts[:append_sql] || String.new
419:           subselect_sql_append(sql, ds.where(SQL::ComplexExpression.new(:<=, ROW_NUMBER_EXPRESSION, limit)))
420:           sql
421:         else
422:           super
423:         end
424:       end

Create a copy of this dataset associated to the given sequence name, which will be used when calling insert to find the most recently inserted value for the sequence.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 387
387:       def sequence(s)
388:         clone(:sequence=>s)
389:       end

The version of the database server

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 523
523:       def server_version
524:         db.server_version(@opts[:server])
525:       end

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 447
447:       def supports_cte?(type=:select)
448:         type == :select
449:       end

Oracle does not support derived column lists

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 452
452:       def supports_derived_column_lists?
453:         false
454:       end

Oracle supports FETCH NEXT ROWS since 12c, but it doesn‘t work when locking or when skipping locked rows.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 458
458:       def supports_fetch_next_rows?
459:         server_version >= 12000000 && !(@opts[:lock] || @opts[:skip_locked])
460:       end

Oracle supports GROUP BY CUBE

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 463
463:       def supports_group_cube?
464:         true
465:       end

Oracle supports GROUP BY ROLLUP

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 468
468:       def supports_group_rollup?
469:         true
470:       end

Oracle supports GROUPING SETS

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 473
473:       def supports_grouping_sets?
474:         true
475:       end

Oracle does not support INTERSECT ALL or EXCEPT ALL

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 478
478:       def supports_intersect_except_all?
479:         false
480:       end

Oracle does not support IS TRUE.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 483
483:       def supports_is_true?
484:         false
485:       end

Oracle does not support limits in correlated subqueries.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 488
488:       def supports_limits_in_correlated_subqueries?
489:         false
490:       end

Oracle does not support offsets in correlated subqueries.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 493
493:       def supports_offsets_in_correlated_subqueries?
494:         false
495:       end

Oracle 10+ supports pattern matching via regular expressions

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 528
528:       def supports_regexp?
529:         server_version >= 10010002
530:       end

Oracle does not support SELECT *, column

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 498
498:       def supports_select_all_and_column?
499:         false
500:       end

Oracle supports SKIP LOCKED.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 503
503:       def supports_skip_locked?
504:         true
505:       end

Oracle supports timezones in literal timestamps.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 508
508:       def supports_timestamp_timezones?
509:         true
510:       end

Oracle does not support WHERE ‘Y’ for WHERE TRUE.

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 513
513:       def supports_where_true?
514:         false
515:       end

Oracle supports window functions

[Source]

     # File lib/sequel/adapters/shared/oracle.rb, line 518
518:       def supports_window_functions?
519:         true
520:       end

[Validate]