Sql Ruby/Rails：一个系统中的复杂条件有很多关联

我有一个

交易

模型。交易有一个

卖方id

列和一个

买方id

。两者都用

用户ID填写

因此：

_

我想做的是在
用户
中添加一个
多个
来关联不完整的交易，无论
用户是卖家还是买家

class User
  has_many :incomplete_transactions, :class_name => 'Transaction', :conditions => ???
end

_

我用纯SQL写了出来，得到了我想要的结果。我的SQL中的联接是：

left outer join transactions t on ((t.seller_id = users.id and t.buyer_id is NULL) or (t.buyer_id = users.id and t.seller_id is NULL))

如何将
join
转换为
有许多关联

编辑：

我希望将未完成的_事务保留为ActiveRecord:：Relation（而不是数组），这样我就可以执行类似user.uncomplete_transactions.limit（15）的操作

谢谢。
假设您使用的是rails 3.2，我建议您创建命名作用域

class Transaction
  belongs_to :seller, :class_name => 'User'
  belongs_to :buyer, :class_name => 'User'

  scope :incomplete_sales, :conditions => { :buyer_id => nil }
  scope :incomplete_purchases, :conditions => { :seller_id => nil }
end

然后你就可以访问不完整的

user.selling_transactions.incomplete_sales
user.buying_transactions.incomplete_purchases

编辑-还更正了上述关联

如果要限制，可以始终对数组执行以下操作

user.selling_transactions.incomplete_sales[0,15]

假设您使用的是rails 3.2，我建议您创建命名作用域

class Transaction
  belongs_to :seller, :class_name => 'User'
  belongs_to :buyer, :class_name => 'User'

  scope :incomplete_sales, :conditions => { :buyer_id => nil }
  scope :incomplete_purchases, :conditions => { :seller_id => nil }
end

然后你就可以访问不完整的

user.selling_transactions.incomplete_sales
user.buying_transactions.incomplete_purchases

编辑-还更正了上述关联

如果要限制，可以始终对数组执行以下操作

user.selling_transactions.incomplete_sales[0,15]

对以下问题的类似回答：
您可以使用类似于此问题的答案：

这基本上会导致：

class User
  has_many :selling_transactions, :class_name => 'Transaction', :foreign_key => 'seller_id'
  has_many :buying_transactions, :class_name => 'Transaction', :foreign_key => 'buyer_id'

  has_many :incomplete_sales, :class_name => 'Transaction', :foreign_key => 'seller_id', :conditions => { :buyer_id => nil }
  has_many :incomplete_purchases, :class_name => 'Transaction', :foreign_key => 'buyer_id', :conditions => { :seller_id => nil }

  def incomplete_transactions
    incomplete_sales + incomplete_purchases
  end
end

编辑：好的，不完全确定如何按照您希望的方式设置它（使用has\u MUN），但以下内容可能适合您：

class User
  has_many :selling_transactions, :class_name => 'Transaction', :foreign_key => 'seller_id'
  has_many :buying_transactions, :class_name => 'Transaction', :foreign_key => 'buyer_id'

  def incomplete_transactions
    Transaction.where("(buyer_id = ? and seller_id = NULL) or (seller_id = ? and buyer_id = NULL)", id, id)
  end
end

where语句将返回一个
ActiveRecord:：Association
，因此在调用它时，您可以使用limit（或其他ActiveRecord函数）来跟踪它。
类似于：
您可以使用类似于此问题的答案：

这基本上会导致：

class User
  has_many :selling_transactions, :class_name => 'Transaction', :foreign_key => 'seller_id'
  has_many :buying_transactions, :class_name => 'Transaction', :foreign_key => 'buyer_id'

  has_many :incomplete_sales, :class_name => 'Transaction', :foreign_key => 'seller_id', :conditions => { :buyer_id => nil }
  has_many :incomplete_purchases, :class_name => 'Transaction', :foreign_key => 'buyer_id', :conditions => { :seller_id => nil }

  def incomplete_transactions
    incomplete_sales + incomplete_purchases
  end
end

编辑：好的，不完全确定如何按照您希望的方式设置它（使用has\u MUN），但以下内容可能适合您：

class User
  has_many :selling_transactions, :class_name => 'Transaction', :foreign_key => 'seller_id'
  has_many :buying_transactions, :class_name => 'Transaction', :foreign_key => 'buyer_id'

  def incomplete_transactions
    Transaction.where("(buyer_id = ? and seller_id = NULL) or (seller_id = ? and buyer_id = NULL)", id, id)
  end
end

where语句将返回一个
ActiveRecord:：Association
，因此您可以在调用它时使用limit（或其他ActiveRecord函数）来跟踪它。
修复了它

这与@DRobinson的解决方案非常相似，但使用proc和a有很多定义
而不是定义一个本地方法

根据3.1发行说明，您现在可以在特定条件下使用proc

在proc中，self是作为关联所有者的对象，除非您急于加载关联，在这种情况下self是关联所在的类

class User < ActiveRecord::Base
  has_many :incomplete_transactions , :class_name => 'Transaction', 
    :conditions => proc { incomplete_sales + incomplete_purchases }

  has_many :incomplete_sales, :class_name => 'Transaction', :foreign_key => 'seller_id', :conditions => { :buyer_id => nil }
  has_many :incomplete_purchases, :class_name => 'Transaction', :foreign_key => 'buyer_id', :conditions => { :seller_id => nil }

  has_many :selling_transactions, :class_name => 'Transaction', :foreign_key => 'seller_id'
  has_many :buying_transactions, :class_name => 'Transaction', :foreign_key => 'buyer_id'
end

class Transaction < ActiveRecord::Base
  belongs_to :seller, :class_name => 'User'
  belongs_to :buyer, :class_name => 'User'

# scope :incomplete_sales , :conditions => {:buyer_id => nil}
# scope :incomplete_purchases , :conditions => {:seller_id => nil}
end

class用户Transaction，
：条件=>proc{未完成的销售+未完成的采购}
有很多：未完成的销售，：类名称=>'Transaction'，：外键=>'seller\u id'，：条件=>{:buyer\u id=>nil}
有很多：未完成的购买，：类名称=>'交易'，：外键=>'买方id'，：条件=>{：卖方id=>无}
有很多：销售交易，：类名称=>'Transaction'，：外键=>'seller\u id'
有很多：购买交易，：类名称=>'Transaction'，：外键=>'buyer\u id'
结束
类事务“用户”
属于：买方，：类别名称=>“用户”
#范围：未完成销售，：条件=>{：买方id=>nil}
#范围：未完成的采购，：条件=>{：卖方id=>nil}
结束

见：



修复了它

这与@DRobinson的解决方案非常相似，但使用proc和a有很多定义
而不是定义一个本地方法

根据3.1发行说明，您现在可以在特定条件下使用proc

在proc中，self是作为关联所有者的对象，除非您急于加载关联，在这种情况下self是关联所在的类

class User < ActiveRecord::Base
  has_many :incomplete_transactions , :class_name => 'Transaction', 
    :conditions => proc { incomplete_sales + incomplete_purchases }

  has_many :incomplete_sales, :class_name => 'Transaction', :foreign_key => 'seller_id', :conditions => { :buyer_id => nil }
  has_many :incomplete_purchases, :class_name => 'Transaction', :foreign_key => 'buyer_id', :conditions => { :seller_id => nil }

  has_many :selling_transactions, :class_name => 'Transaction', :foreign_key => 'seller_id'
  has_many :buying_transactions, :class_name => 'Transaction', :foreign_key => 'buyer_id'
end

class Transaction < ActiveRecord::Base
  belongs_to :seller, :class_name => 'User'
  belongs_to :buyer, :class_name => 'User'

# scope :incomplete_sales , :conditions => {:buyer_id => nil}
# scope :incomplete_purchases , :conditions => {:seller_id => nil}
end

class用户Transaction，
：条件=>proc{未完成的销售+未完成的采购}
有很多：未完成的销售，：类名称=>'Transaction'，：外键=>'seller\u id'，：条件=>{:buyer\u id=>nil}
有很多：未完成的购买，：类名称=>'交易'，：外键=>'买方id'，：条件=>{：卖方id=>无}
有很多：销售交易，：类名称=>'Transaction'，：外键=>'seller\u id'
有很多：购买交易，：类名称=>'Transaction'，：外键=>'buyer\u id'
结束
类事务“用户”
属于：买方，：类别名称=>“用户”
#范围：未完成销售，：条件=>{：买方id=>nil}
#范围：未完成的采购，：条件=>{：卖方id=>nil}
结束

见：



您可以使用如下选项

:conditions = ["(t.seller_id = #{self.id} and t.buyer_id is NULL) or (t.buyer_id = #{self.id} and t.seller_id is NULL)"]

您可以使用如下选项

:conditions = ["(t.seller_id = #{self.id} and t.buyer_id is NULL) or (t.buyer_id = #{self.id} and t.seller_id is NULL)"]

我希望将未完成的_事务保留为ActiveRecord:：Relation（而不是数组），这样我就可以像user.uncomplete_事务那样做。limit（15）你完全正确。不确定如何立即使用has_许多，可以使用上面的定义（在编辑中）。伟大的解决方案，+1！我添加了一个解决方案，它使用了很多，但在其他方面与您的非常相似。不是我问题的确切答案，而是最实用的，并且实现了我想要的。谢谢我希望将未完成的_事务保留为ActiveRecord:：Relation（而不是数组），这样我就可以像user.uncomplete_事务那样做。limit（15）你完全正确。不确定如何立即使用has_许多，可以使用上面的定义（在编辑中）。伟大的解决方案，+1！我添加了一个解决方案，它使用了很多，但在其他方面与您的非常相似。不是我问题的确切答案，而是最实用的，并且实现了我想要的。谢谢这个