Comment modéliser une relation bidirectionnelle One2One en utilisant greendao?

Question

J'ai 2 entités, par exemple voiture et moteur.

Chaque voiture a un moteur (au moins dans ce modèle :)), mais pas tous les moteurs est construit dans une voiture. Donc, je veux le tableau suivant structure: (. Bien sûr, il y a des colonnes beaucoup plus En fait, j'ai deux entités avec environ 15 colonnes chacune Mais nous allons rester simple..)

+------------------------------------+ 
|CAR         | 
+------------------------------------+ 
|id_car  INTEGER,PK,AUTOINCREMENT | 
|id_engine INTEGER,FK    | 
+------------------------------------+ 

+------------------------------------+ 
|ENGINE        | 
+------------------------------------+ 
|id_engine INTEGER,PK,AUTOINCREMENT | 
+------------------------------------+ 

Cela peut modélisable comme ceci:

engine = schema.addEntity("Engine"); 
Property pkEngine = engine.addLongProperty("id_engine").primaryKey().autoincrement().getProperty(); 

car = schema.addEntity("Car"); 
car.addLongProperty("id_car").primaryKey().autoincrement(); 
Property fkEngine = car.addLongProperty("id_engine").getProperty(); 
car.addToOne(engine, fkEngine); 

Mais je veux être en mesure d'interroger la voiture du moteur et de moteur de voiture, avec getters sur les eNTITÉ-objets. avoisinant I ajouté:

engine.addToOneWithoutProperty("Car", car, "id_car"); 

J'ai alors tous les getters que je veux, mais mes tables ressembler à ceci:

+------------------------------------+ 
|CAR         | 
+------------------------------------+ 
|id_car  INTEGER,PK,AUTOINCREMENT | 
|id_engine INTEGER,FK    | 
+------------------------------------+ 

+------------------------------------+ 
|ENGINE        | 
+------------------------------------+ 
|id_engine INTEGER,PK,AUTOINCREMENT | 
|id_car  INTEGER     | 
+------------------------------------+ 

Si j'utilise les pour insérer statments suivant les colonnes fk-sont inconsisent, comme CAR.id_engine is NULL, qui fournit des exceptions en utilisant le getter engine.getCar().

Engine engine = new Engine(); 
mEngineDao.insert(engine); 
Car car = new Car(); 
car.setEngine(engine); 
engine.setCar(car); 
mCarDao.insert(car); 
engine.update(); 

Quelqu'un at-il des suggestions comment construire un One2One-Relation à l'aide greendao, de sorte qu'il n'y a qu'une seule colonne de clé étrangère et getters dans chaque entité?

--- MISE À JOUR ---

Il semble que addToOneWithoutProperty() ne fonctionne pas correctement. Je ne peux pas trouver une section dans le void bindValues(SQLiteStatement stmt, Car entity) généré qui se soucie de la colonne id_engine.

Answer 1

Je propose une table voiture moteur pour maintenir la relation:

+------------------------------------+ 
|CAR         | 
+------------------------------------+ 
|id_car  INTEGER,PK,AUTOINCREMENT | 
+------------------------------------+ 

+------------------------------------+ 
|ENGINE        | 
+------------------------------------+ 
|id_engine INTEGER,PK,AUTOINCREMENT | 
+------------------------------------+ 

+------------------------------------+ 
|CARENGINE       | 
+------------------------------------+ 
|id_car  INTEGER,FK    | 
|id_engine INTEGER,FK    | 
+------------------------------------+ 

CARENGINE utilise une clé composée, aucune expérience de greenDAO donc je ne sais pas s'il prend en charge les clés composites (ajouter un PK à CARENGINE sinon).

Answer 2

Bidirectionnel one-one-à-mappings semblent pas pris en charge pour le moment.

Depuis que je ne veux pas de données redondantes dans ma base de données (pour éviter les incohérences) j'ai décidé de travailler avec un simple à-un pour l'instant. L'autre raison de cette décision est que je ne sais pas s'il y aura des dépendances en anneau qui provoqueront des débordements de pile ou d'autres choses.