Grails consultable: recherche d'un champ spécifique dans un objet membre?

Question

Utiliser le plugin interrogeable Grails, j'ai ces classes:

class Person { 
static searchable = { 
    address component: true 
    } 
} 

et:

class Address { 
static searchable = { 
    root false 
} 
String country 
} 

Je veux faire une recherche spécifique pour les personnes d'un pays spécifique. "Pays: NL" ne fonctionne pas. "address: country: NL" ne fonctionne pas non plus. Je ne trouve rien sur la syntaxe pour cela. Des idées?

Je pense que je vais devoir faire une indexation intelligente ou un autre truc dans la fermeture de recherche, mais je ne peux pas le trouver.

Answer 1

J'ai créé une application de base (Grails 1.3.5, 0.5.5.1 interrogeable) avec vos deux classes et la recherche de 'pays: NL' œuvres pour moi. Avez-vous pensé à appeler index() avant d'essayer de faire une recherche?

grails create-app search 
grains install-plugin searchable 

Personne:

class Person { 
    static searchable = { 
    address component: true 
    } 

    Address address 
} 

Adresse:

class Address { 
    static belongsTo = Person 
    static searchable = { 
    root false 
    } 
    String country 
} 

Bootstrap:

class BootStrap { 

    def init = { servletContext -> 

     def p1 = new Person(address:new Address(country:'NL')).save() 
     def p2 = new Person(address:new Address(country:'DE')).save() 
     def p3 = new Person(address:new Address(country:'NZ')).save() 

     Person.index() 

    } 

    def destroy = { 
    } 
} 

Je navigué à/interrogeable et recherché pour le pays: NL et obtenu personne 1 retourné.

Si vous voulez voir ce que interrogeable fait sous les couvertures en ce qui concerne les champs/index etc - Luc est un outil très pratique (il suffit de télécharger le fichier JAR exécutable): http://code.google.com/p/luke/

Les fichiers d'index sont en

<user.home>/.grails/projects/<project name>/searchable-index/development/index 

acclamations

Lee

Answer 2

La solution laide qui fonctionne: ne comptez pas sur Searchable. Pour le moment, je fais d'abord un Person.search(params.query, [max:99999]).results, puis faire un simple .findAll pour trouver par pays et .sublist() pour que la pagination fonctionne à nouveau.

Dommage qu'il soit si difficile d'obtenir quelque chose d'aussi évident à utiliser avec Searchable.

Une autre solution que je n'ai pas réussi à faire est de rendre une propriété transitoire country sur Person qui retourne address.country. N'a pas fonctionné hors de la boîte, et je n'ai aucune idée sur la façon de le réparer.

Si quelqu'un a des solutions plus jolies pour moi, j'aimerais les entendre.

Answer 3

Je suis novice en matière de grails, mais pourquoi devez-vous utiliser le plugin interrogeable?

Qu'est-ce qui ne va pas avec une simple relation 1: 1 ou 1: n?

package com.test 
class Person { 

     static constraints = { 
      name (nullable:false) 
      address (nullable:true) 
     } 

     String name 
     Address address 

     String toString() { 
      "name[" + name + "]. address[" + address + "]" 
     } 

     static mapping = { 
      address lazy:false 
     } 
    } 


    class Address { 

     static constraints = { 
      country (nullable:false) 
      town (nullable:false) 
     } 
     String country 
     String town 
     //Person person 

     static belongsTo = [person:Person] 
    // static belongsTo = Person 

     String toString(){ 
      "town[" + town + "], country[" + country + "]" 
     } 
    } 

     package com.test 

     import grails.test.* 

     class PersonIntegrationTestTests extends GrailsUnitTestCase { 
      protected void setUp() { 
       super.setUp() 
      } 

      protected void tearDown() { 
       super.tearDown() 
      } 

      void testSomething() { 
       def bill = new Person(name:'bill', address:new Address(town:'york', country:'UK')).save() 
       def fred = new Person(name:'fred', address:new Address(town:'leeds', country:'UK')).save() 
       def bjork = new Person(name:'helen', address:new Address(town:'helsinki', country:'finland')).save() 
       def gustav = new Person(name:'john', address:new Address(town:'helsinki', country:'finland')).save() 

       List ukAddresses = Address.findAllByCountry('UK') // find all by country 

       println "num addresses-" + ukAddresses.size() 

       for (int i in 0..<ukAddresses.size()) 
       { 
       println "found person:" + ukAddresses[i].person 
       } 

       assertNotNull "bill can not ne null", bill 
       assertTrue bill.validate() && !bill.hasErrors() 
       assertTrue fred.validate() && !fred.hasErrors() 
       assertTrue bjork.validate() && !bjork.hasErrors() 
       assertTrue gustav.validate() && !gustav.hasErrors() 

       assertEquals 2, ukAddresses.size() 
      } 
     }