Top Level Namespace

Defined Under Namespace

Modules: Aggregate Classes: BinaryOperation, Column, Count, CrossJoinUnnest, Expr, From, GroupBy, IfElse, Literal, OrderedByExpr, Query, Row, Sum, Table, UnaryOperation

Instance Method Summary

• #expr(&blk) ⇒ Object
• #fill(query) ⇒ Object
• #generate_sql(query) ⇒ Object
• #ifElse(cond, true_result, false_result) ⇒ Object
• #lit(value) ⇒ Object
• #rewrite(parsed) ⇒ Object

Instance Method Details

#expr(&blk) ⇒ Object

# File 'lib/lilit_sql.rb', line 763

def expr(&blk)
  parsed = blk.to_sexp

  parsed = rewrite(parsed)

  code = $ruby2ruby.process(parsed)
  eval(code, blk.binding)
end

#fill(query) ⇒ Object

# File 'lib/lilit_sql.rb', line 688

def fill(query)
  return [] if query.is_vanilla

  queries = []
  query.froms.each do |from|
    next if from.is_a?(CrossJoinUnnest)
    next unless from.source.is_a?(Query)

    subqueries = fill(from.source)
    subqueries.each do |subquery|
      queries.push(subquery)
    end
  end
  queries.push(query)
  queries.uniq
end

#generate_sql(query) ⇒ Object

# File 'lib/lilit_sql.rb', line 669

def generate_sql(query)
  queries = fill(query)
  last_query = queries.pop

  sql = ''

  sql += 'with ' if queries.size.positive?

  queries.map.with_index do |q, index|
    sql += ', ' if index.positive?
    q.subquery_name = "subquery#{index}"
    sql += "#{q.subquery_name} as (\n#{q.sql}\n)\n"
  end

  sql += last_query.sql

  sql
end

#ifElse(cond, true_result, false_result) ⇒ Object

# File 'lib/lilit_sql.rb', line 665

def ifElse(cond, true_result, false_result)
  IfElse.new(cond, true_result, false_result)
end

#lit(value) ⇒ Object

# File 'lib/lilit_sql.rb', line 371

def lit(value)
  return value if value.is_a?(Literal)

  if value.is_a?(String) || value.is_a?(Integer) || value.is_a?(Float) || value.nil?
    Literal.new(value)
  elsif value.is_a?(Array)
    value.map { |v| lit(v) }
  else
    value
  end
end

#rewrite(parsed) ⇒ Object

# File 'lib/lilit_sql.rb', line 707

def rewrite(parsed)
  parsed = parsed.map do |component|
    if component.is_a?(Sexp)
      rewrite(component)
    else
      component
    end
  end

  if parsed[0] == :call
    if parsed[2] == :==
      parsed[2] = :eq
    elsif parsed[2] == :!=
      parsed[2] = :ne
    elsif parsed[2] == :!
      parsed[2] = :not
    elsif parsed[2] == :-@
      parsed[2] = :minus
    elsif parsed[2] == :+@
      parsed[2] = :plus
    elsif parsed[2] == :nil?
      parsed = Sexp.new(
        :call,
        parsed[1],
        :eq,
        Sexp.new(:nil)
      )
    end
  elsif parsed[0] == :and
    parsed = Sexp.new(
      :call,
      parsed[1],
      :and,
      parsed[2]
    )
  elsif parsed[0] == :case && parsed[2] && parsed[2][0] == :in
    parsed = Sexp.new(
      :call,
      parsed[1],
      :in,
      parsed[2][1]
    )
  elsif parsed[0] == :if
    parsed = Sexp.new(
      :call,
      nil,
      :ifElse,
      parsed[1],
      parsed[2],
      parsed[3]
    )
  end

  parsed
end