Carte Groovy vs. Tableau des relations au sein des classes de domaine - Comment décrire et persistent cela?

Question

Grails / Gorm je stocke un site physique qui contient des objets positions définies .

La classe de domaine serait tout simplement:

Exemple A

SITE DC

• sitename
• PositionMap (1: chien, 2: chat, 3: foo, 4: bar, ... jusqu'à une moyenne de 30 éléments)

... mais les objets changent leurs positions et je dois être plus tard en mesure de voir quels postes étaient occupés par ce à un moment donné (quand).

Ainsi, j'ajouté une autre classe de domaine

Exemple B

POSITIONS DC

• validfrom
• validto
• PositionMap (1: chien, 2: chat, 3: foo, 4: bar)
• belongsTo SITE

SITE DC

• sitename

Comme tous les objets auront une description et il y aura des charges de mondIaL en utilisant les mêmes objets, j'ajouté une classe de domaine pour tenir chaque OBJET. Résultat:

Exemple C

OBJET DC

nom
Description

POSITIONS DC

• validfrom
• validto
• PositionMap (1: reference_to_dog, 2: reference_to_cat, 3: reference_to_foo, 4: reference_to_bar)
• belongsTo SITE

SITE DC

• sitename

maintenant la carte, pour moi, ne semble pas plus raisonnable.

Je pense à retirer la carte, en le remplaçant par une autre classe de domaine:

Exemple D

OBJET DC

nom
Description

OBJET-TO-POSITION DC

• positionnumber (1, 2, 3, 4, ...)
• objet (reference_to_cat, reference_to_dog, reference_to_foo, ...)
• belongsTo POSITIONS

POSITIONS DC

• validfrom
• validto
• belongsTo SITE

SITE DC

• sitename

QUESTIONS

1. Est-il généralement une bonne / mauvaise idée de mettre des cartes dans la base de données?
2. Comment cela pourrait être atteint plus facile?
3. Quelle est la façon la plus performante de le faire?

EDIT: UNE NOUVELLE APPROCHE SUR LA BASE RÉPONSE ROBS

Inspiré par votre suggestion, Rob, j'ai rédigé ce modèle de données qui accorde un rôle « avant-ligne » à « SeasonPlan » (modifié « ResidenceHistory »).

class Zoo {
    static hasMany = [seasons: SeasonPlan]
    String name
}

// one way of representing histories
class SeasonPlan = {
    static belongsTo = [zoo: Zoo] // a SeasonPlan belongs to a single particular Zoo
    static hasMany = [cages: Cage]
    DateTime from
    DateTime until
}

class Cage {
    static belongsTo = [seasonPlan: SeasonPlan] // a cage belongs to a single seasonplan
    Species species // a cage has a single Species
    Integer cageNumber
}

class Species {
    // static hasMany = [cages: Cage] // commented out - no reverse-lookup necessary
    String name
}

a un inconvénient: Pour chaque plan de saison, il y a une nouvelle cage - si , en réalité, les cages restent les mêmes ! (Imaginez un « entier squaremeters » dans le « Cage » pour le rendre plus évident pourquoi cela ne le souhaite.)

Pour moi, l'application d'une telle chose à un modèle de données est souvent difficile à comprendre - Comment ajuster les données « pseudo-statiques » comme celui-ci dans l'application tout en conservant corelation monde réel

J'espère que ce que je veux dire est compréhensible -. Désolé si pas

Answer 1

Je suis encore à essayer de comprendre votre domaine; vous pouvez être un peu les choses trop compliquer. Est-ce que ce travail de modèle de base? Sinon, pouvez-vous expliquer pourquoi? Je vais mettre à jour mon exemple, si je peux mieux comprendre vos conditions.

Edition -. Par exemple mis à jour compte tenu des commentaires ci-dessous

class Cage {
    static belongsTo = [zoo: Zoo] // a cage belongs to a single particular Zoo
    Species species // a cage has a single Species
    String name
}

class Zoo {
    static hasMany = [cages: Cage]
    String name
}

class Species {
    static hasMany = [cages: Cage] // a species can be in many different cages
    String name
}

// one way of representing histories
class ResidenceHistory = {
    Species species
    Cage cage
    DateTime from
    DateTime until
}

Voici comment vous pouvez utiliser le domaine, alors:

def sanDiego = new Zoo(name: 'San Diego Zoo').save()
def aviary = new Cage(name: 'Aviary', zoo: sanDiego).save()
def elephantCage = new Cage(name: 'Elephant Area, Cage 5', zoo: sanDiego).save()

def bird = new Species(name: 'Blue-Footed Booby', cage: aviary).save()
def elephant = new Species(name: 'Asian Elephant', cage: elephantCage).save()

new ResidenceHistory(species: bird, cage: aviary, from: new DateTime(), to: new DateTime().plusDays(20)).save()

Pour répondre à vos questions énumérées plus précisément:

1. Cela dépend - en général je préfère utiliser les capacités relationnelles de la base de données au lieu de stocker des cartes dans la base de données. Il est beaucoup plus facile de travailler avec les données brutes si elles ne sont pas des objets Java sérialisés.
2. Voir mon exemple ci-dessus.
3. Cela ne devrait pas d'importance à moins que la performance devient un problème. Utilisez la solution qui fait le plus de sens et est le plus facile à maintenir, et si vous trouvez que cela cause des problèmes de performance, le profil de votre application et résoudre les problèmes individuellement.