MushroomObserver / mushroom-observer / 14145714091

module Query::Modules::Sql

  attr_accessor :last_query

  def sql_select_all_columns(args = {})

    sql(args.merge(select: "DISTINCT #{model.table_name}.*"))

  end

  def sql(args = {})

    initialize_query unless initialized?

    our_select  = args[:select] || selects

    our_join    = join.dup

    our_join += args[:join] if args[:join].is_a?(Array)

    our_join << args[:join] if args[:join].is_a?(Hash)

    our_join << args[:join] if args[:join].is_a?(Symbol)

    our_tables = tables.dup

    our_tables += args[:tables] if args[:tables].is_a?(Array)

    our_tables << args[:tables] if args[:tables].is_a?(Symbol)

    our_from    = calc_from_clause(our_join, our_tables)

    our_where   = where.dup

    our_where += args[:where] if args[:where].is_a?(Array)

    our_where << args[:where] if args[:where].is_a?(String)

    our_where = calc_where_clause(our_where)

    our_group = args[:group] || group

    our_order = args[:order] || order

    our_order = reverse_order(order) if our_order == :reverse

    our_limit = args[:limit]

    if our_order.present? &&

       !our_order.match(/\.id( |$)/)

      our_order += ", #{model.table_name}.id DESC"

    end

    sql = %(

      SELECT #{our_select}

      FROM #{our_from}

    )

    sql += "  WHERE #{our_where}\n"    if our_where.present?

    sql += "  GROUP BY #{our_group}\n" if our_group.present?

    sql += "  ORDER BY #{our_order}\n" if our_order.present?

    sql += "  LIMIT #{our_limit}\n"    if our_limit.present?

    @last_query = sql

    sql

  end

  def calc_where_clause(our_where = where)

    ands = our_where.uniq.map do |x|

      if x.match(/^\(.*\)$/) || !x.match(/ or /i)

        x

      else

        "(#{x})"

      end

    end

    ands.join(" AND ")

  end

  def calc_from_clause(our_join = join, our_tables = tables)

    implicits = [model.table_name] + our_tables

    result = implicits.uniq.map { |x| "`#{x}`" }.join(", ")

    if our_join

      result += " "

      result += calc_join_conditions(model.table_name, our_join).join(" ")

    end

    result

  end

  def table_list(our_join = join, our_tables = tables)

    flatten_joins([model.table_name] + our_join + our_tables, false).uniq

  end

  def flatten_joins(arg = join, keep_qualifiers = true)

    result = []

    case arg

    when Hash

      arg.each do |key, val|

        key = key.to_s.sub(/\..*/, "") unless keep_qualifiers

        result << key.to_s

        result += flatten_joins(val)

      end

    when Array

      result += arg.map { |x| flatten_joins(x) }.flatten

    else

      arg = arg.to_s.sub(/\..*/, "") unless keep_qualifiers

      result << arg.to_s

    end

    result

  end

  def calc_join_conditions(from, to, done = [from.to_s])

    result = []

    from = from.to_s

    case to

    when Hash

      to.each do |key, val|

        result += calc_join_condition(from, key.to_s, done)

        result += calc_join_conditions(key.to_s, val, done)

      end

    when Array

      result += to.map { |x| calc_join_conditions(from, x, done) }.flatten

    else

      result += calc_join_condition(from, to.to_s, done)

    end

    result

  end

end