Class: ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation

Inherits:

JoinBase

• Object
• JoinBase
• ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation

Defined in:

lib/active_record/connection_adapters/ibm_db_pstmt.rb

Instance Method Summary

• #association_join ⇒ Object

Instance Method Details

#association_join ⇒ Object

# File 'lib/active_record/connection_adapters/ibm_db_pstmt.rb', line 1579

def association_join
  return_hash = {} # A Hash to conatin the parameterised sql and the parameters
  parameter_array = []

  connection = reflection.active_record.connection
  join = case reflection.macro
    when :has_and_belongs_to_many
      " #{join_type} %s ON %s.%s = %s.%s " % [
         table_alias_for(options[:join_table], aliased_join_table_name),
         connection.quote_table_name(aliased_join_table_name),
         options[:foreign_key] || reflection.active_record.to_s.foreign_key,
         connection.quote_table_name(parent.aliased_table_name),
         reflection.active_record.primary_key] +
      " #{join_type} %s ON %s.%s = %s.%s " % [
         table_name_and_alias,
         connection.quote_table_name(aliased_table_name),
         klass.primary_key,
         connection.quote_table_name(aliased_join_table_name),
         options[:association_foreign_key] || klass.to_s.foreign_key
         ]
    when :has_many, :has_one
      case
        when reflection.options[:through]
          through_conditions = through_reflection.options[:conditions] ? "AND #{interpolate_sql(sanitize_sql(through_reflection.options[:conditions]))}" : ''

          jt_foreign_key = jt_as_extra = jt_source_extra = jt_sti_extra = nil
          first_key = second_key = as_extra = nil

          if through_reflection.options[:as] # has_many :through against a polymorphic join
            jt_foreign_key = through_reflection.options[:as].to_s + '_id'
            jt_as_extra = " AND %s.%s = ?" % [
              connection.quote_table_name(aliased_join_table_name),
              connection.quote_column_name(through_reflection.options[:as].to_s + '_type')
            ]
            parameter_array = parameter_array + [klass.quote_value(parent.active_record.base_class.name)]
          else
            jt_foreign_key = through_reflection.primary_key_name
          end

          case source_reflection.macro
          when :has_many
            if source_reflection.options[:as]
              first_key   = "#{source_reflection.options[:as]}_id"
              second_key  = options[:foreign_key] || primary_key
              parameter_array = parameter_array + [klass.quote_value(source_reflection.active_record.base_class.name)]
              as_extra    = " AND %s.%s = ?" % [
                connection.quote_table_name(aliased_table_name),
                connection.quote_column_name("#{source_reflection.options[:as]}_type")
              ]
            else
              first_key   = through_reflection.klass.base_class.to_s.foreign_key
              second_key  = options[:foreign_key] || primary_key
            end

            unless through_reflection.klass.descends_from_active_record?
              parameter_array = parameter_array + [through_reflection.klass.quote_value(through_reflection.klass.sti_name)]
              jt_sti_extra = " AND %s.%s = ?" % [
                connection.quote_table_name(aliased_join_table_name),
                connection.quote_column_name(through_reflection.active_record.inheritance_column)
              ]
            end
          when :belongs_to
            first_key = primary_key
            if reflection.options[:source_type]
              second_key = source_reflection.association_foreign_key
              parameter_array = parameter_array + [klass.quote_value(reflection.options[:source_type])]
              jt_source_extra = " AND %s.%s = ?" % [
                connection.quote_table_name(aliased_join_table_name),
                connection.quote_column_name(reflection.source_reflection.options[:foreign_type])
              ]
            else
              second_key = source_reflection.primary_key_name
            end
          end

          " #{join_type} %s ON (%s.%s = %s.%s%s%s%s) " % [
            table_alias_for(through_reflection.klass.table_name, aliased_join_table_name),
            connection.quote_table_name(parent.aliased_table_name),
            connection.quote_column_name(parent.primary_key),
            connection.quote_table_name(aliased_join_table_name),
            connection.quote_column_name(jt_foreign_key),
            jt_as_extra, jt_source_extra, jt_sti_extra
          ] +
          " #{join_type} %s ON (%s.%s = %s.%s%s) " % [
            table_name_and_alias,
            connection.quote_table_name(aliased_table_name),
            connection.quote_column_name(first_key),
            connection.quote_table_name(aliased_join_table_name),
            connection.quote_column_name(second_key),
            as_extra
          ]

        when reflection.options[:as] && [:has_many, :has_one].include?(reflection.macro)
          parameter_array = parameter_array + [klass.quote_value(parent.active_record.base_class.name)]
          " #{join_type} %s ON %s.%s = %s.%s AND %s.%s = ?" % [
            table_name_and_alias,
            connection.quote_table_name(aliased_table_name),
            "#{reflection.options[:as]}_id",
            connection.quote_table_name(parent.aliased_table_name),
            parent.primary_key,
            connection.quote_table_name(aliased_table_name),
            "#{reflection.options[:as]}_type"
          ]
        else
          foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
          " #{join_type} %s ON %s.%s = %s.%s " % [
            table_name_and_alias,
            aliased_table_name,
            foreign_key,
            parent.aliased_table_name,
            reflection.options[:primary_key] || parent.primary_key
          ]
      end
    when :belongs_to
      " #{join_type} %s ON %s.%s = %s.%s " % [
         table_name_and_alias,
         connection.quote_table_name(aliased_table_name),
         reflection.klass.primary_key,
         connection.quote_table_name(parent.aliased_table_name),
         options[:foreign_key] || reflection.primary_key_name
        ]
    else
      ""
  end || ''

  unless klass.descends_from_active_record?
    sql_segment, *param_array = klass.send(:type_condition, aliased_table_name)
    join << %(AND %s) % [sql_segment]
    parameter_array = parameter_array + param_array unless param_array.nil?
  end

  [through_reflection, reflection].each do |ref|
    if ref && ref.options[:conditions]
      sql_param_hash = sanitize_sql(ref.options[:conditions], aliased_table_name)
      parameter_array = parameter_array + sql_param_hash["paramArray"] unless sql_param_hash["paramArray"].nil?
      join << "AND #{interpolate_sql(sql_param_hash["sqlSegment"])} "
    end
  end

  return_hash["sqlSegment"] = join
  return_hash["paramArray"] = parameter_array
  return_hash
end