introduction

Ravi de vous rencontrer, tout le monde. Je m'appelle Wu et je suis en charge de cette série.

Il existe trois outils de cartographie O / R typiques (iBATIS, Torque, Hibernate), Cette fois, je voudrais présenter DBFlute comme un mappage O / R.

Le mappage O / R consiste à mapper (associer) "objet" et "base de données relationnelle".

Pourquoi voulez-vous éviter autant que possible d'utiliser DBFlute hors de SQL? Les deux raisons suivantes: (1) Si des instructions SQL sont écrites à différents endroits du code source, vous devez toujours être conscient des problèmes tels que les omissions et les erreurs de développement. (2) Le mappage O / R réduit le travail compliqué lié aux opérations de la base de données au moment de la mise en œuvre et résout le «décalage».

Contexte du défi

Il y avait une page d'accueil DBFlute, mais les connaissances sont dispersées et afin d'utiliser le travail sur le terrain, il est nécessaire d'organiser le fichier de configuration (additionalforeignkey.dfprop) et comment écrire la source Java.

Explication de la méthode de jointure de table

Cet article utilise DBFlute-1.0.5N et JAVA7.

Mécanisme de base de DBFlute

Mécanisme approximatif du mappage O / R de DBFlute (1) Génération automatique dans DBFlute DBFlute est un mappage O / R qui ne fonctionne qu'avec des classes générées automatiquement. (2) Implémentation JAVA Behavior Contrôle le traitement de tous les accès DB Conditions de recherche ConditionBean Build Pour plus de détails, reportez-vous au Manuel de mise en œuvre.

S'il n'y a pas de clé externe liée entre deux ou plusieurs tables et que vous souhaitez les joindre en entreprise, utilisez la méthode suivante.

Exemple:

Tableau d'utilisation

TableA	TableB	TableC
A_column_1	B_column_1	C_column_1
A_column_2	B_column_1	C_column_1

Ce qui précède suppose que les tableaux A, B et C ne sont pas tous associés à des clés externes. Le fichier de configuration suivant pointe vers dbflute / XXX / dfprop / additionalforeignkey.dfprop.

1, résultat d'exécution attendu SQL (jointure TableA et TableB): SELECT * FROM TableA A LEFT JOIN TableB B ON A.A_column_1 = B.B_column_1

fichier de configuration: ; FK_TableA_TO_TableB_BY_ID = map:{ ; localTableName = TableA ; foreignTableName = TableB ; localColumnName = A_column_1 ; foreignColumnName = B_column_1 ; fixedSuffix = ByID }

JAVA: //TableA情報の取得

`TableACB cb = tableABhv.newMyConditionBean();`


cb.setupSelect_TableBById();```  

---------------------------------------

 2. Résultat d'exécution attendu SQL (Join TableA / TableB et TableB / TableC):
SELECT * 
FROM TableA A
INNER JOIN TableB B
ON A.A_column_1 = B.B_column_1
INNER JOIN TableC C
ON B.B_column_1 = C.C_column_1

 fichier de configuration:
 ; FK_TableB_TO_TableC_BY_ID = map:{
   ; localTableName  = TableB  ; foreignTableName  = TableC
   ; localColumnName = B_column_1 ; foreignColumnName = C_column_1
   ; fixedSuffix = ById
 }

 ; FK_TableA_TO_TableB_BY_ID = map:{
   ; localTableName  = TableA  ; foreignTableName  = TableB
   ; localColumnName = A_column_1 ; foreignColumnName = B_column_1
   ; fixedSuffix = ById
 }

JAVA:
 //TableA情報の取得

#### **`TableACB cb = tableABhv.newMyConditionBean();`**
```newMyConditionBean();

cb.setupSelect_TableBById();
cb.setupSelect_TableBById().join();
cb.setupSelect_TableBById().withTableCBId();
cb.setupSelect_TableBById().withTableCBId().join();```

---------------------------------------
 3, résultat d'exécution attendu SQL (jointure TableA / TableB et TableB / TableC et TableA / TableC):

SELECT * 
FROM TableA A
LEFT JOIN TableB B
ON A.A_column_1 = B.B_column_1
LEFT JOIN TableC C
ON B.B_column_1 = C.C_column_1
AND A.A_column_2 = C.C_column_2

 fichier de configuration:
 ; FK_TableA_TO_TableB_BY_ID = map:{
   ; localTableName  = TableA  ; foreignTableName  = TableB
   ; localColumnName = A_column_1 ; foreignColumnName = B_column_1
   ; fixedSuffix = ById
 }

 ; FK_TableA_TO_TableC_BY_ID = map:{
   ; localTableName  = TableA  ; foreignTableName  = TableC
   ; localColumnName = A_column_2 ; foreignColumnName = C_column_2
   ; fixedCondition = `$$foreignAlias$$.C_column_1 = $$over($localTable.tableBById)$$.B_column_1`
   ; fixedSuffix = ById
 }

JAVA：
 //TableA情報の取得

#### **`TableACB cb = tableABhv.newMyConditionBean();`**
```newMyConditionBean();

cb.setupSelect_TableBById();
cb.setupSelect_TableCById();```

---------------------------------------
 4, résultat d'exécution SQL (sous-requête corrélée dans fixedCondition):

SELECT * 
FROM TableA A
INNER JOIN TableB B
ON A.A_column_1 = B.B_column_1
INNER JOIN TableC C
ON B.B_column_1 = C.C_column_1
AND A.A_column_2 = C.C_column_2
INNER JOIN 
	(SELECT TC.C_column_1 
	  		,MAX(CAST(TC.C_column_2 AS INT)) AS VER 
 			FROM TableC TC
			GROUP BY
			TC.C_column_1
			TC.C_column_2
		) C_0 
ON C_0.C_column_1 = C.C_column_1


 fichier de configuration:

 ; FK_TableA_TO_TableB_BY_ID = map:{
   ; localTableName  = TableA  ; foreignTableName  = TableB
   ; localColumnName = A_column_1 ; foreignColumnName = B_column_1
   ; fixedSuffix = ById
 }

 ; FK_TableA_TO_TableC_BY_ID = map:{
   ; localTableName  = TableA  ; foreignTableName  = TableC
   ; localColumnName = A_column_2 ; foreignColumnName = C_column_2
   ; fixedCondition = `$$foreignAlias$$.C_column_1 = $$over($localTable.tableBById)$$.B_column_1`
	INNER JOIN 
		(SELECT TC.C_column_1 
	  		,MAX(CAST(TC.C_column_2 AS INT)) AS VER 
 			FROM TableC TC
			GROUP BY
			TC.C_column_1
			TC.C_column_2
		) C_0 
	ON C_0.C_column_1 = `$$foreignAlias$$.C_column_1`
   ; fixedSuffix = ById
 }


JAVA：

 //TableA情報の取得

#### **`TableACB cb = tableABhv.newMyConditionBean();`**
```newMyConditionBean();

cb.setupSelect_TableBById();
cb.setupSelect_TableBById().join();
cb.setupSelect_TableCById();
cb.setupSelect_TableCById().join();```

---------------------------------------
#### Glossaire du fichier de paramètres

 Je pense que les Mac montrés ci-dessus ont les significations suivantes et seront utilisés après les avoir compris.

 `$$ ForeignAlias $$`: Elias de la table référencée
 `$$ localAlias $$`: Elias de la table référente
 `$$ over ([nom de la table]. [Nom de la relation]) $$`: Elias de la table d'une autre relation
 `$$ over ($ localTable. [Nom de la relation]) $$`: Table étrangère de la table locale
 `$$ over ($ ForeignTable. [Relation name]) $$`: Table étrangère de la table étrangère

---------------------------------------
# Résumé
 En combinant le fichier de configuration BDflute et la source JAVA par paires, toutes les tables peuvent être jointes sans utiliser SQL externe.
 Cette explication est une méthode pour faire face au cas de la jonction de plusieurs tables souvent utilisées sur le terrain, mais en réalité je pense que c'est beaucoup de savoir-faire détaillé, mais la prochaine fois j'expliquerai le savoir-faire à mettre en œuvre côté JAVA.

---------------------------------------
# Matériel de référence
 ~ Mappeur O / R orienté site ~
http://dbflute.seasar.org/

 Qu'est-ce que additionalForeignKeyMap?
http://dbflute.seasar.org/ja/manual/reference/dfprop/additionalforeignkey/

[JAVA] Comment joindre une table sans utiliser DBFlute et SQL