| Module | Sequel::Oracle |
| In: |
lib/sequel/adapters/shared/oracle.rb
lib/sequel/adapters/oracle.rb |
# 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
# File lib/sequel/adapters/shared/oracle.rb, line 325
325: def complex_expression_sql_append(sql, op, args)
326: case op
327: when :&
328: complex_expression_arg_pairs_append(sql, args, &BITAND_PROC)
329: when :|
330: complex_expression_arg_pairs_append(sql, args){|a, b| Sequel.lit(["(", " - ", " + ", ")"], a, complex_expression_arg_pairs([a, b], &BITAND_PROC), b)}
331: when :^
332: complex_expression_arg_pairs_append(sql, args) do |*x|
333: s1 = complex_expression_arg_pairs(x){|a, b| Sequel.lit(["(", " - ", " + ", ")"], a, complex_expression_arg_pairs([a, b], &BITAND_PROC), b)}
334: s2 = complex_expression_arg_pairs(x, &BITAND_PROC)
335: Sequel.lit(["(", " - ", ")"], s1, s2)
336: end
337: when :~, '!~''!~', '~*''~*', '!~*''!~*'
338: raise InvalidOperation, "Pattern matching via regular expressions is not supported in this Oracle version" unless supports_regexp?
339: if op == '!~''!~' || op == '!~*''!~*'
340: sql << 'NOT '
341: end
342: sql << 'REGEXP_LIKE('
343: literal_append(sql, args[0])
344: sql << ','
345: literal_append(sql, args[1])
346: if op == '~*''~*' || op == '!~*''!~*'
347: sql << ", 'i'"
348: end
349: sql << ')'
350: when :%, :<<, :>>, 'B~''B~'
351: complex_expression_emulate_append(sql, op, args)
352: else
353: super
354: end
355: 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.
# File lib/sequel/adapters/shared/oracle.rb, line 360
360: def constant_sql_append(sql, c)
361: if c == :CURRENT_TIME
362: super(sql, :CURRENT_TIMESTAMP)
363: else
364: super
365: end
366: end
Use a custom expression with EXISTS to determine whether a dataset is empty.
# File lib/sequel/adapters/shared/oracle.rb, line 376
376: def empty?
377: db[:dual].where(@opts[:offset] ? exists : unordered.exists).get(1) == nil
378: end
# File lib/sequel/adapters/shared/oracle.rb, line 427
427: def select_limit_sql(sql)
428: return unless supports_fetch_next_rows?
429:
430: if offset = @opts[:offset]
431: sql << " OFFSET "
432: literal_append(sql, offset)
433: sql << " ROWS"
434: end
435:
436: if limit = @opts[:limit]
437: sql << " FETCH NEXT "
438: literal_append(sql, limit)
439: sql << " ROWS ONLY"
440: end
441: end
Handle LIMIT by using a unlimited subselect filtered with ROWNUM, unless Oracle 12 is used.
# File lib/sequel/adapters/shared/oracle.rb, line 394
394: def select_sql
395: return super if @opts[:sql]
396: return super if supports_fetch_next_rows?
397:
398: o = @opts[:offset]
399: if o && o != 0
400: columns = clone(:append_sql=>String.new, :placeholder_literal_null=>true).columns
401: dsa1 = dataset_alias(1)
402: rn = row_number_column
403: limit = @opts[:limit]
404: ds = unlimited.
405: from_self(:alias=>dsa1).
406: select_append(ROW_NUMBER_EXPRESSION.as(rn)).
407: from_self(:alias=>dsa1).
408: select(*columns).
409: where(SQL::Identifier.new(rn) > o)
410: ds = ds.where(SQL::Identifier.new(rn) <= Sequel.+(o, limit)) if limit
411: sql = @opts[:append_sql] || String.new
412: subselect_sql_append(sql, ds)
413: sql
414: elsif limit = @opts[:limit]
415: ds = unlimited
416: # Lock doesn't work in subselects, so don't use a subselect when locking.
417: # Don't use a subselect if custom SQL is used, as it breaks somethings.
418: ds = ds.from_self unless @opts[:lock]
419: sql = @opts[:append_sql] || String.new
420: subselect_sql_append(sql, ds.where(SQL::ComplexExpression.new(:<=, ROW_NUMBER_EXPRESSION, limit)))
421: sql
422: else
423: super
424: end
425: end
The version of the database server
# File lib/sequel/adapters/shared/oracle.rb, line 529
529: def server_version
530: db.server_version(@opts[:server])
531: end
# File lib/sequel/adapters/shared/oracle.rb, line 448
448: def supports_cte?(type=:select)
449: type == :select
450: end