module Sequel::Model::Associations::DatasetMethods

# File lib/sequel/model/associations.rb, line 2841
def as_hash(key_column=nil, value_column=nil, opts=OPTS)
  if (@opts[:eager_graph] || @opts[:eager]) && !opts.has_key?(:all)
    opts = Hash[opts]
    opts[:all] = true
  end
  super
end

# File lib/sequel/model/associations.rb, line 2683
def association_join(*associations)
  association_inner_join(*associations)
end

# File lib/sequel/model/associations.rb, line 2694
def complex_expression_sql_append(sql, op, args)
  r = args[1]
  if (((op == :'=' || op == :'!=') && r.is_a?(Sequel::Model)) ||
      (multiple = ((op == :IN || op == :'NOT IN') && ((is_ds = r.is_a?(Sequel::Dataset)) || (r.respond_to?(:all?) && r.all?{|x| x.is_a?(Sequel::Model)})))))
    l = args[0]
    if ar = model.association_reflections[l]
      if multiple
        klass = ar.associated_class
        if is_ds
          if r.respond_to?(:model)
            unless r.model <= klass
              # A dataset for a different model class, could be a valid regular query
              return super
            end
          else
            # Not a model dataset, could be a valid regular query
            return super
          end
        else
          unless r.all?{|x| x.is_a?(klass)}
            raise Sequel::Error, "invalid association class for one object for association #{l.inspect} used in dataset filter for model #{model.inspect}, expected class #{klass.inspect}"
          end
        end
      elsif !r.is_a?(ar.associated_class)
        raise Sequel::Error, "invalid association class #{r.class.inspect} for association #{l.inspect} used in dataset filter for model #{model.inspect}, expected class #{ar.associated_class.inspect}"
      end

      if exp = association_filter_expression(op, ar, r)
        literal_append(sql, exp)
      else
        raise Sequel::Error, "invalid association type #{ar[:type].inspect} for association #{l.inspect} used in dataset filter for model #{model.inspect}"
      end
    elsif multiple && (is_ds || r.empty?)
      # Not a query designed for this support, could be a valid regular query
      super
    else
      raise Sequel::Error, "invalid association #{l.inspect} used in dataset filter for model #{model.inspect}"
    end
  else
    super
  end
end

# File lib/sequel/model/associations.rb, line 2762
def eager(*associations)
  opts = @opts[:eager]
  association_opts = eager_options_for_associations(associations)
  opts = opts ? Hash[opts].merge!(association_opts) : association_opts
  clone(:eager=>opts.freeze)
end

# File lib/sequel/model/associations.rb, line 2790
def eager_graph(*associations)
  eager_graph_with_options(associations)
end

# File lib/sequel/model/associations.rb, line 2814
def eager_graph_with_options(associations, opts=OPTS)
  opts = opts.dup unless opts.frozen?
  associations = [associations] unless associations.is_a?(Array)
  ds = if eg = @opts[:eager_graph]
    eg = eg.dup
    [:requirements, :reflections, :reciprocals, :limits].each{|k| eg[k] = eg[k].dup}
    eg[:local] = opts
    ds = clone(:eager_graph=>eg)
    ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations)
  else
    # Each of the following have a symbol key for the table alias, with the following values:
    # :reciprocals :: the reciprocal value to use for this association
    # :reflections :: AssociationReflection instance related to this association
    # :requirements :: array of requirements for this association
    # :limits :: Any limit/offset array slicing that need to be handled in ruby land after loading
    opts = {:requirements=>{}, :master=>alias_symbol(first_source), :reflections=>{}, :reciprocals=>{}, :limits=>{}, :local=>opts, :cartesian_product_number=>0, :row_proc=>row_proc}
    ds = clone(:eager_graph=>opts)
    ds = ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations).naked
  end

  ds.opts[:eager_graph].freeze
  ds.opts[:eager_graph].each_value{|v| v.freeze if v.is_a?(Hash)}
  ds
end

# File lib/sequel/model/associations.rb, line 2851
def to_hash_groups(key_column, value_column=nil, opts=OPTS)
  if (@opts[:eager_graph] || @opts[:eager]) && !opts.has_key?(:all)
    opts = Hash[opts]
    opts[:all] = true
  end
  super
end

# File lib/sequel/model/associations.rb, line 2863
def ungraphed
  ds = super.clone(:eager_graph=>nil)
  if (eg = @opts[:eager_graph]) && (rp = eg[:row_proc])
    ds = ds.with_row_proc(rp)
  end
  ds
end