Question

我希望有一个用于构建查询的工具，这样我就可以为常见查询添加特异性，而不是一遍又一遍地对类似查询进行硬编码。例如：

DetachedCriteria query = DeviceConfiguration.where { ... }
while(query.list(max: 2).size() > 1) QueryUtil.addConstraint(query, newConstraint)

但我遇到涉及多对多关系的查询时遇到问题。

如果我的域类是：

class StringDescriptor {
    String name
    String stringValue
    static hasMany = [ deviceConfigurations: DeviceConfiguration ]
    static belongsTo = DeviceConfiguration
}

class DeviceConfiguration {
    Integer setting1
    Integer setting2
    static hasMany = [ stringDescriptors: StringDescriptor ]
}

我的设备配置如下所示：

DeviceConfiguration hondaAccord = new DeviceConfiguration(setting1: 1, setting2: 1)
DeviceConfiguration hondaCivic = new DeviceConfiguration(setting1: 2, setting2: 2)
DeviceConfiguration accord = new DeviceConfiguration(setting1: 3, setting2: 3)
StringDescriptor hondaDescriptor = new StringDescriptor(name: "make", stringValue: "honda")
StringDescriptor civicDescriptor = new StringDescriptor(name: "model", stringValue: "civic")
StringDescriptor accordDescriptor = new StringDescriptor(name: "model", stringValue: "accord")
hondaAccord.addToStringDescriptors(hondaDescriptor)
hondaAccord.addToStringDescriptors(accordDescriptor)
hondaCivic.addToStringDescriptors(hondaDescriptor)
hondaCivic.addToStringDescriptors(civicDescriptor)
accord.addToStringDescriptors(accordDescriptor)
hondaAccord.save(failOnError: true)
hondaCivic.save(failOnError: true)
accord.save(failOnError: true, flush: true)

我希望能够做到这一点：

def query = DeviceCollector.where{ stringDescriptors {name =~ "make" & stringValue =~ "honda"} }
if(query.list(max: 2)?.size() > 1)
    def query2 = query.where { stringDescriptors {name =~ "model" & stringValue =~ "civic"} }
if(query2.list(max: 2)?.size() > 1) 
    //...

但是这不起作用 - query2给出与第一个查询相同的结果。然而，当我这样做时，它完美地运作：

def query = DeviceCollector.where{ stringDescriptors {name =~ "make" & stringValue =~ "honda"} }
if(query.list(max: 2)?.size() > 1)
    def query2 = query.where { eq('setting1', 1) }
if(query.list(max: 2)?.size() > 1)
    def query3 = query.build { eq('setting2', 1) }

请告知：（

编辑感谢injecteer

现在我的域名包括：

class DeviceConfiguration {
    //...
    static namedQueries = {
        byStringDescriptor { String name, String value ->
            stringDescriptors {
                ilike 'name', name
                ilike 'stringValue', value
            }
        }
    }
}

我尝试将查询串在一起看起来像这样：

//Lists hondaAccord and hondaCivic
DeviceConfiguration.byStringDescriptor("make", "honda").list()
//Lists hondaAccord and accord
DeviceConfiguration.byStringDescriptor("model", "accord").list()
// LISTS NOTHING... BUT WHYYYYY?
DeviceConfiguration.byStringDescriptor("make", "honda").byStringDescriptor("model", "accord").list()

我很困惑。又一次。

编辑感谢injecteer的更新回复

是的，这是对我有用的命名查询：

class DeviceConfiguration {
    //...
    static namedQueries = {
        byStringDescriptor { List<StringDescriptor> descriptors ->
            sizeEq('stringDescriptors', descriptors.size())
            stringDescriptors {
                or {
                    for(descriptor in descriptors) {
                        and {
                            ilike 'name', descriptor.name
                            ilike 'stringValue', descriptor.stringValue
                        }
                    }
                }
            }

        }
    }
}

结果（YAYYY）:) ...

StringDescriptor hondaDescriptor = new StringDescriptor(name: "make", stringValue: "honda")
StringDescriptor accordDescriptor = new StringDescriptor(name: "model", stringValue: "accord")

//returns nothing - **check**
def hondaQuery = DeviceConfiguration.byStringDescriptor([hondaDescriptor]).list()

//returns accord configuration - **check**
def accordQuery = DeviceConfiguration.byStringDescriptor([accordDescriptor]).list()

//returns just the hondaAccord configuration - **YESSSSSS**
def hondaAccordQuery = DeviceConfiguration.byStringDescriptorUsingOr([hondaDescriptor, accordDescriptor]).listDistinct()

injecteer是我最喜欢的人。

Answer 1

使用criteria query或named queries。他们都允许更好的链接

class DeviceConfiguration {

  static namedQueries = {

    byDescriptors { List vals -> 
      stringDescriptors { 
        or{
          for( def tuple in vals ){
            and{
              ilike 'name', "%${tuple[ 0 ]}%"
              ilike 'stringValue', "%${tuple[ 1 ]}%"
            }
          }
        }
      }
    }

  }       
}

所以你可以打电话：

DeviceConfiguration.byDescriptors( [ [ 'make', 'honda' ], [ 'model', 'accord' ] ] ).findAllBySetting1( 10 )

您应该知道，哪种联结适合and或or

更新2

有这么多and你没找到任何东西......

如果您启动blah( honda, accord ).list()之类的查询，它会尝试找到name='honda' AND name='accord'的{（1}}不可能的字符串描述符，因此它不返回任何结果！

这就是为什么我倾向于认为你的域模型根本不允许这样的查询 - 即使是在SQL级别。

您的属性应该清晰可辨，以便您可以通过本田找到（类型＆＃39;制作＆＃39;）并符合（类型＆＃39;型号＆＃39;）它不应该寻找＆＃34;本田＆＃34; in＆＃34; model＆＃34;。

单个DeviceConfiguration个实例是否可以包含多个StringDescriptor的{{1}}个？

grails动态地将gorm子查询添加到现有查询

1 个答案: