Estou com o seguinte problema:

Tenho três tabelas:

Tabela 1) Regra [id_regra, codigoRegra]
Tabela 2) Modo [id_modo, codigoModo]
Tabela 3) RegraModo [id_regra, id_modo] <- Chave estrangeira e primaria em ambas. [NxN]

O que não estou conseguindo fazer seria obter por exemplo, através de uma regra, todos os modos associadas a elas.

Meus mapeamentos:
-----------------------------------------------------------------------------------
public class RegraTradu implements Serializable{

String cdRegraTradu

SortedSet mdComando

static hasMany = [mdComando:RegraTraduModoComando]

static constraints = {
cdRegraTradu(blank:false, unique:true)
}

static mapping = {
table '###########'
//id(generator:'increment')
id(generator:'sequence',params:[sequence:'#########'])

mdComando cascade:"all,delete-orphan"
mdComando lazy:true
servicRede lazy:true

columns{
id(column:'########')
cdRegraTradu(column:'######')
version(column:'#########')
}
}

String toString(){
return cdRegraTradu
}

public boolean equals(Object obj) {
RegraTradu regraTradu = (RegraTradu) obj;

return (this.cdRegraTradu.equals(regraTradu.cdRegraTradu))
}

public int hashCode() {
return this.cdRegraTradu.hashCode();
}
}
-----------------------------------------------------------------------------------
public class ModoComando implements Serializable{

String dsMdComando

static belongsTo = RegraTraduModoComando

static hasMany = [regraTrad:RegraTraduModoComando]

static constraints = {
dsMdComando(nullable:false, blank:false)
}

static mapping ={
table '#####################'

regraTrad lazy:true

//id(generator:'increment')
id(generator:'sequence',params:[sequence:'##################'])

columns{
id(column:'id_modo_comando')
dsMdComando(column:'ds_modo_comando')
version(column:'nu_versao_obj')
}
}

String toString(){
return dsMdComando
}

public boolean equals(Object obj) {
ModoComando modoComando = (ModoComando) obj;

return (this.dsMdComando.equals(modoComando.dsMdComando))
}
}
-----------------------------------------------------------------------------------
public class RegraTraduModoComando implements Serializable, Comparable {

RegraTradu regraTrad;
ModoComando mdComando;

static belongsTo = RegraTradu, ModoComando;

static mapping = {
table '#######################'
id composite:['regraTrad', 'mdComando']
columns {
id composite:['regraTrad', 'mdComando']
regraTrad(column:'id_regra_tradu')
mdComando(column:'id_modo_comando')
}
}

int compareTo(obj) {
if(regraTrad != null && obj.regraTrad != null && mdComando != null && obj.mdComando != null) {
return (regraTrad.compareTo(obj.regraTrad) && mdComando.compareTo(obj.mdComando))
}
return 1;
}
}

-----------------------------------------------------------------
Desculpem pela duvida simples, estou começando a trabalhar com o Grails por agora.