module Sequel::Access::DatasetMethods

  1. lib/sequel/adapters/shared/access.rb
Parent: Access

Constants

BOOL_FALSE = '0'.freeze  
BOOL_TRUE = '-1'.freeze  
BRACKET_CLOSE = Dataset::BRACKET_CLOSE  
BRACKET_OPEN = Dataset::BRACKET_OPEN  
CAST_TYPES = {String=>:CStr, Integer=>:CLng, Date=>:CDate, Time=>:CDate, DateTime=>:CDate, Numeric=>:CDec, BigDecimal=>:CDec, File=>:CStr, Float=>:CDbl, TrueClass=>:CBool, FalseClass=>:CBool}  
COMMA = Dataset::COMMA  
DATEPART_OPEN = "datepart(".freeze  
DATE_FORMAT = '#%Y-%m-%d#'.freeze  
DATE_FUNCTION = 'Date()'.freeze  
EXTRACT_MAP = {:year=>"'yyyy'", :month=>"'m'", :day=>"'d'", :hour=>"'h'", :minute=>"'n'", :second=>"'s'"}  
FROM = Dataset::FROM  
INTO = Dataset::INTO  
NOT_EQUAL = ' <> '.freeze  
NOW_FUNCTION = 'Now()'.freeze  
OPS = {:'%'=>' Mod '.freeze, :'||'=>' & '.freeze}  
PAREN_CLOSE = Dataset::PAREN_CLOSE  
PAREN_OPEN = Dataset::PAREN_OPEN  
SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct limit columns into from join where group order having compounds')  
SPACE = Dataset::SPACE  
TIMESTAMP_FORMAT = '#%Y-%m-%d %H:%M:%S#'.freeze  
TIME_FUNCTION = 'Time()'.freeze  
TOP = " TOP ".freeze  

Public Instance methods

case_expression_sql_append (sql, ce)

Access doesn't support CASE, but it can be emulated with nested IIF function calls.

[show source] 
# File lib/sequel/adapters/shared/access.rb, line 119
def case_expression_sql_append(sql, ce)
  literal_append(sql, ce.with_merged_expression.conditions.reverse.inject(ce.default){|exp,(cond,val)| Sequel::SQL::Function.new(:IIF, cond, val, exp)})
end
cast_sql_append (sql, expr, type)

Access doesn't support CAST, it uses separate functions for type conversion

[show source] 
# File lib/sequel/adapters/shared/access.rb, line 125
def cast_sql_append(sql, expr, type)
  sql << CAST_TYPES.fetch(type, type).to_s
  sql << PAREN_OPEN
  literal_append(sql, expr)
  sql << PAREN_CLOSE
end
complex_expression_sql_append (sql, op, args)
[show source] 
# File lib/sequel/adapters/shared/access.rb, line 132
def complex_expression_sql_append(sql, op, args)
  case op
  when :ILIKE
    complex_expression_sql_append(sql, :LIKE, args)
  when :'NOT ILIKE'
    complex_expression_sql_append(sql, :'NOT LIKE', args)
  when :LIKE, :'NOT LIKE'
    sql << PAREN_OPEN
    literal_append(sql, args.at(0))
    sql << SPACE << op.to_s << SPACE
    literal_append(sql, args.at(1))
    sql << PAREN_CLOSE
  when :'!='
    sql << PAREN_OPEN
    literal_append(sql, args.at(0))
    sql << NOT_EQUAL
    literal_append(sql, args.at(1))
    sql << PAREN_CLOSE
  when :'%', :'||'
    sql << PAREN_OPEN
    c = false
    op_str = OPS[op]
    args.each do |a|
      sql << op_str if c
      literal_append(sql, a)
      c ||= true
    end
    sql << PAREN_CLOSE
  when :extract
    part = args.at(0)
    raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
    sql << DATEPART_OPEN << format.to_s << COMMA
    literal_append(sql, args.at(1))
    sql << PAREN_CLOSE
  else
    super
  end
end
constant_sql_append (sql, constant)

Use Date() and Now() for CURRENT_DATE and CURRENT_TIMESTAMP

[show source] 
# File lib/sequel/adapters/shared/access.rb, line 172
def constant_sql_append(sql, constant)
  case constant
  when :CURRENT_DATE
    sql << DATE_FUNCTION
  when :CURRENT_TIMESTAMP
    sql << NOW_FUNCTION
  when :CURRENT_TIME
    sql << TIME_FUNCTION
  else
    super
  end
end
cross_join (table)

Emulate cross join by using multiple tables in the FROM clause.

[show source] 
# File lib/sequel/adapters/shared/access.rb, line 186
def cross_join(table)
  clone(:from=>@opts[:from] + [table])
end
emulated_function_sql_append (sql, f)
[show source] 
# File lib/sequel/adapters/shared/access.rb, line 190
def emulated_function_sql_append(sql, f)
  case f.f
  when :char_length
    literal_append(sql, SQL::Function.new(:len, f.args.first))
  else
    super
  end
end
escape_like (string)

Access uses [] to escape metacharacters, instead of backslashes.

[show source] 
# File lib/sequel/adapters/shared/access.rb, line 200
def escape_like(string)
  string.gsub(/[\*#?\[]/){|m| "[#{m}]"}
end
into (table)

Specify a table for a SELECT … INTO query.

[show source] 
# File lib/sequel/adapters/shared/access.rb, line 205
def into(table)
  clone(:into => table)
end
supports_intersect_except? ()

Access doesn't support INTERSECT or EXCEPT

[show source] 
# File lib/sequel/adapters/shared/access.rb, line 210
def supports_intersect_except?
  false
end
supports_is_true? ()

Access does not support IS TRUE

[show source] 
# File lib/sequel/adapters/shared/access.rb, line 215
def supports_is_true?
  false
end
supports_join_using? ()

Access doesn't support JOIN USING

[show source] 
# File lib/sequel/adapters/shared/access.rb, line 220
def supports_join_using?
  false
end
supports_multiple_column_in? ()

Access does not support multiple columns for the IN/NOT IN operators

[show source] 
# File lib/sequel/adapters/shared/access.rb, line 225
def supports_multiple_column_in?
  false
end
truncate ()

Access doesn't support truncate, so do a delete instead.

[show source] 
# File lib/sequel/adapters/shared/access.rb, line 230
def truncate
  delete
  nil
end