[RELEASE] Release v0.25.4

pom.xml

@@ -3,7 +3,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>kangaroo-and-rabbit</groupId>
 	<artifactId>archidata</artifactId>
-	<version>0.25.0</version>
+	<version>0.25.4</version>
 	<repositories>
 		<repository>
 			<id>gitea</id>

src/org/kar/archidata/annotation/AnnotationTools.java

@@ -449,7 +449,7 @@ public class AnnotationTools {
 			if (java.lang.reflect.Modifier.isStatic(field.getModifiers())) {
 				continue;
 			}
-			if (AnnotationTools.getFieldNameRaw(field).equals(name)) {
+			if (field.getName().equals(name)) {
 				return true;
 			}
 		}

src/org/kar/archidata/catcher/RestErrorResponse.java

@@ -6,11 +6,15 @@ import java.util.List;
 import org.bson.types.ObjectId;
 import org.kar.archidata.annotation.apiGenerator.ApiGenerationMode;
 
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import jakarta.annotation.Nullable;
 import jakarta.persistence.Column;
 import jakarta.validation.constraints.NotNull;
 import jakarta.ws.rs.core.Response;
 
 @ApiGenerationMode
+@JsonInclude(JsonInclude.Include.NON_NULL)
 public class RestErrorResponse {
 	public ObjectId oid = new ObjectId();
 	@NotNull
@@ -28,6 +32,7 @@ public class RestErrorResponse {
 	@Column(length = 0)
 	final public String statusMessage;
 
+	@Nullable
 	final public List<RestInputError> inputError;
 
 	public RestErrorResponse(final Response.Status status, final String time, final String error, final String message,

src/org/kar/archidata/catcher/RestInputError.java

@@ -3,10 +3,13 @@ package org.kar.archidata.catcher;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import com.fasterxml.jackson.annotation.JsonInclude;
+
 import jakarta.persistence.Column;
 import jakarta.validation.Path;
 import jakarta.validation.constraints.NotNull;
 
+@JsonInclude(JsonInclude.Include.NON_NULL)
 public class RestInputError {
 	private static Pattern PATTERN = Pattern.compile("^([^.]+)\\.([^.]+)(\\.(.*))?");
 	@Column(length = 0)

src/org/kar/archidata/dataAccess/DBAccessSQL.java

@@ -223,16 +223,35 @@ public class DBAccessSQL extends DBAccess {
 		return out;
 	}
 
+	public byte[][] splitIntoGroupsOf12Bytes(final byte[] input) {
+		final int inputLength = input.length;
+		final int numOfGroups = (inputLength + 11) / 12; // Calculate the number of groups needed
+		final byte[][] groups = new byte[numOfGroups][12];
+
+		for (int i = 0; i < numOfGroups; i++) {
+			final int startIndex = i * 12;
+			final int endIndex = Math.min(startIndex + 12, inputLength);
+			groups[i] = Arrays.copyOfRange(input, startIndex, endIndex);
+		}
+
+		return groups;
+	}
+
 	public List<ObjectId> getListOfRawOIDs(final ResultSet rs, final int iii) throws SQLException, DataAccessException {
 		final byte[] trackString = rs.getBytes(iii);
 		if (rs.wasNull()) {
 			return null;
 		}
-		final byte[][] elements = splitIntoGroupsOf16Bytes(trackString);
+		final byte[][] elements = splitIntoGroupsOf12Bytes(trackString);
 		final List<ObjectId> out = new ArrayList<>();
 		for (final byte[] elem : elements) {
+			try {
 				final ObjectId tmp = new ObjectId(elem);
 				out.add(tmp);
+			} catch (final IllegalArgumentException ex) {
+				ex.printStackTrace();
+				LOGGER.error("Fail to parse the OID element: {}", elem);
+			}
 		}
 		return out;
 	}
@@ -1276,7 +1295,7 @@ public class DBAccessSQL extends DBAccess {
 	) throws Exception {
 		final boolean readAllfields = QueryOptions.readAllColomn(options);
 		final String tableName = AnnotationTools.getTableName(clazz, options);
-		final String primaryKey = AnnotationTools.getPrimaryKeyField(clazz).getName();
+		final String primaryKey = AnnotationTools.getFieldNameRaw(AnnotationTools.getPrimaryKeyField(clazz));
 		boolean firstField = true;
 
 		for (final Field elem : clazz.getFields()) {

src/org/kar/archidata/dataAccess/addOnSQL/AddOnOneToMany.java

@@ -231,6 +231,7 @@ public class AddOnOneToMany implements DataAccessAddOn {
 			final CountInOut count,
 			final QueryOptions options,
 			final List<LazyGetter> lazyCall) throws Exception {
+		try {
 			if (field.getType() != List.class) {
 				LOGGER.error("Can not OneToMany with other than List Model: {}", field.getType().getCanonicalName());
 				return;
@@ -258,32 +259,33 @@ public class AddOnOneToMany implements DataAccessAddOn {
 				return;
 			}
 			if (objectClass == decorators.targetEntity()) {
+				final String destinationField = decorators.mappedBy();
+				final Field typeDestination = AnnotationTools.getFieldNamed(objectClass, destinationField);
+				final Class<?> destinationClass = typeDestination.getType();
+
 				Long parentIdTmp = null;
 				UUID parendUuidTmp = null;
 				ObjectId parendOidTmp = null;
-			try {
+				if (destinationClass == Long.class) {
 					final String modelData = rs.getString(count.value);
 					parentIdTmp = Long.valueOf(modelData);
 					count.inc();
-			} catch (final NumberFormatException ex) {
-				try {
+				} else if (destinationClass == UUID.class) {
 					final List<UUID> idList = ioDb.getListOfRawUUIDs(rs, count.value);
 					parendUuidTmp = idList.get(0);
 					count.inc();
-				} catch (final NumberFormatException ex2) {
-					// TODO : How to manage ObjectId ==> I am not sure it works well...
+				} else if (destinationClass == ObjectId.class) {
 					final List<ObjectId> idList = ioDb.getListOfRawOIDs(rs, count.value);
 					parendOidTmp = idList.get(0);
 					count.inc();
 				}
-			}
 				final Long parentId = parentIdTmp;
 				final UUID parendUuid = parendUuidTmp;
 				final ObjectId parendOid = parendOidTmp;
 				final String mappingKey = decorators.mappedBy();
 				// We get the parent ID ... ==> need to request the list of elements
 				if (objectClass == Long.class) {
-				LOGGER.error("Need to retreive all primary key of all elements");
+					LOGGER.error("Need to retreive all primary key of all elements.");
 					//field.set(data, idList);
 					return;
 				} else if (objectClass == UUID.class) {
@@ -335,6 +337,10 @@ public class AddOnOneToMany implements DataAccessAddOn {
 					}
 				}
 			}
+		} catch (final Exception ex) {
+			ex.printStackTrace();
+			LOGGER.error("Fail to parse remote {}", ex.getMessage());
+		}
 	}
 
 }

src/org/kar/archidata/model/User.java

@@ -20,6 +20,7 @@ import java.util.UUID;
 
 import org.kar.archidata.annotation.DataIfNotExists;
 import org.kar.archidata.annotation.DataJson;
+import org.kar.archidata.annotation.apiGenerator.ApiGenerationMode;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonInclude;
@@ -36,6 +37,7 @@ import jakarta.ws.rs.DefaultValue;
 @Table(name = "user")
 @DataIfNotExists
 @JsonInclude(JsonInclude.Include.NON_NULL)
+@ApiGenerationMode(create = true, update = true)
 public class User extends GenericDataSoftDelete {
 	@NotNull
 	@Column(length = 128)

test/src/test/kar/archidata/ConfigureDb.java

@@ -16,18 +16,18 @@ import test.kar.archidata.dataAccess.model.SerializeAsJson;
 import test.kar.archidata.dataAccess.model.SerializeListAsJson;
 import test.kar.archidata.dataAccess.model.SimpleTable;
 import test.kar.archidata.dataAccess.model.SimpleTableSoftDelete;
-import test.kar.archidata.dataAccess.model.TypeManyToManyRemote;
-import test.kar.archidata.dataAccess.model.TypeManyToManyRoot;
-import test.kar.archidata.dataAccess.model.TypeManyToManyRootExpand;
-import test.kar.archidata.dataAccess.model.TypeManyToOneRemote;
-import test.kar.archidata.dataAccess.model.TypeManyToOneRoot;
-import test.kar.archidata.dataAccess.model.TypeManyToOneRootExpand;
+import test.kar.archidata.dataAccess.model.TypeManyToManyLongRemote;
+import test.kar.archidata.dataAccess.model.TypeManyToManyLongRoot;
+import test.kar.archidata.dataAccess.model.TypeManyToManyLongRootExpand;
+import test.kar.archidata.dataAccess.model.TypeManyToOneLongRemote;
+import test.kar.archidata.dataAccess.model.TypeManyToOneLongRoot;
+import test.kar.archidata.dataAccess.model.TypeManyToOneLongRootExpand;
 import test.kar.archidata.dataAccess.model.TypeManyToOneUUIDRemote;
 import test.kar.archidata.dataAccess.model.TypeManyToOneUUIDRoot;
 import test.kar.archidata.dataAccess.model.TypeManyToOneUUIDRootExpand;
-import test.kar.archidata.dataAccess.model.TypeOneToManyRemote;
-import test.kar.archidata.dataAccess.model.TypeOneToManyRoot;
-import test.kar.archidata.dataAccess.model.TypeOneToManyRootExpand;
+import test.kar.archidata.dataAccess.model.TypeOneToManyLongRemote;
+import test.kar.archidata.dataAccess.model.TypeOneToManyLongRoot;
+import test.kar.archidata.dataAccess.model.TypeOneToManyLongRootExpand;
 import test.kar.archidata.dataAccess.model.TypeOneToManyUUIDRemote;
 import test.kar.archidata.dataAccess.model.TypeOneToManyUUIDRoot;
 import test.kar.archidata.dataAccess.model.TypeOneToManyUUIDRootExpand;
@@ -56,18 +56,18 @@ public class ConfigureDb {
 				SerializeListAsJson.class, //
 				SimpleTable.class, //
 				SimpleTableSoftDelete.class, //
-				TypeManyToManyRemote.class, //
-				TypeManyToManyRoot.class, //
-				TypeManyToManyRootExpand.class, //
-				TypeManyToOneRemote.class, //
-				TypeManyToOneRoot.class, //
-				TypeManyToOneRootExpand.class, //
+				TypeManyToManyLongRemote.class, //
+				TypeManyToManyLongRoot.class, //
+				TypeManyToManyLongRootExpand.class, //
+				TypeManyToOneLongRemote.class, //
+				TypeManyToOneLongRoot.class, //
+				TypeManyToOneLongRootExpand.class, //
 				TypeManyToOneUUIDRemote.class, //
 				TypeManyToOneUUIDRoot.class, //
 				TypeManyToOneUUIDRootExpand.class, //
-				TypeOneToManyRemote.class, //
-				TypeOneToManyRoot.class, //
-				TypeOneToManyRootExpand.class, //
+				TypeOneToManyLongRemote.class, //
+				TypeOneToManyLongRoot.class, //
+				TypeOneToManyLongRootExpand.class, //
 				TypeOneToManyUUIDRemote.class, //
 				TypeOneToManyUUIDRoot.class, //
 				TypeOneToManyUUIDRootExpand.class, //

test/src/test/kar/archidata/dataAccess/TestManyToManyLong.java

@@ -19,14 +19,14 @@ import org.slf4j.LoggerFactory;
 
 import test.kar.archidata.ConfigureDb;
 import test.kar.archidata.StepwiseExtension;
-import test.kar.archidata.dataAccess.model.TypeManyToManyRemote;
-import test.kar.archidata.dataAccess.model.TypeManyToManyRoot;
-import test.kar.archidata.dataAccess.model.TypeManyToManyRootExpand;
+import test.kar.archidata.dataAccess.model.TypeManyToManyLongRemote;
+import test.kar.archidata.dataAccess.model.TypeManyToManyLongRoot;
+import test.kar.archidata.dataAccess.model.TypeManyToManyLongRootExpand;
 
 @ExtendWith(StepwiseExtension.class)
 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
-public class TestManyToMany {
-	final static private Logger LOGGER = LoggerFactory.getLogger(TestManyToMany.class);
+public class TestManyToManyLong {
+	final static private Logger LOGGER = LoggerFactory.getLogger(TestManyToManyLong.class);
 
 	@BeforeAll
 	public static void configureWebServer() throws Exception {
@@ -41,8 +41,8 @@ public class TestManyToMany {
 	@Order(1)
 	@Test
 	public void testCreateTable() throws Exception {
-		final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyRoot.class);
-		final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyRemote.class);
+		final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyLongRoot.class);
+		final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyLongRemote.class);
 		sqlCommand.addAll(sqlCommand2);
 		if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
 			for (final String elem : sqlCommand) {
@@ -55,16 +55,16 @@ public class TestManyToMany {
 	@Order(2)
 	@Test
 	public void testSimpleInsertAndRetieve() throws Exception {
-		final TypeManyToManyRoot test = new TypeManyToManyRoot();
+		final TypeManyToManyLongRoot test = new TypeManyToManyLongRoot();
 		test.otherData = "kjhlkjlkj";
-		final TypeManyToManyRoot insertedData = ConfigureDb.da.insert(test);
+		final TypeManyToManyLongRoot insertedData = ConfigureDb.da.insert(test);
 		Assertions.assertNotNull(insertedData);
 		Assertions.assertNotNull(insertedData.id);
 		Assertions.assertTrue(insertedData.id >= 0);
 		Assertions.assertNull(insertedData.remote);
 
 		// Try to retrieve all the data:
-		final TypeManyToManyRoot retrieve = ConfigureDb.da.get(TypeManyToManyRoot.class, insertedData.id);
+		final TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
 
 		Assertions.assertNotNull(retrieve);
 		Assertions.assertNotNull(retrieve.id);
@@ -73,33 +73,33 @@ public class TestManyToMany {
 		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
 		Assertions.assertNull(retrieve.remote);
 
-		ConfigureDb.da.delete(TypeManyToManyRoot.class, insertedData.id);
+		ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
 	}
 
 	@Order(3)
 	@Test
 	public void testSimpleInsertAndRetieveSubValues() throws Exception {
 
-		TypeManyToManyRemote remote = new TypeManyToManyRemote();
+		TypeManyToManyLongRemote remote = new TypeManyToManyLongRemote();
 		remote.data = "remote1";
-		final TypeManyToManyRemote insertedRemote1 = ConfigureDb.da.insert(remote);
+		final TypeManyToManyLongRemote insertedRemote1 = ConfigureDb.da.insert(remote);
 		Assertions.assertEquals(insertedRemote1.data, remote.data);
 
-		remote = new TypeManyToManyRemote();
+		remote = new TypeManyToManyLongRemote();
 		remote.data = "remote2";
-		final TypeManyToManyRemote insertedRemote2 = ConfigureDb.da.insert(remote);
+		final TypeManyToManyLongRemote insertedRemote2 = ConfigureDb.da.insert(remote);
 		Assertions.assertEquals(insertedRemote2.data, remote.data);
 
-		final TypeManyToManyRoot test = new TypeManyToManyRoot();
+		final TypeManyToManyLongRoot test = new TypeManyToManyLongRoot();
 		test.otherData = "kjhlkjlkj";
-		final TypeManyToManyRoot insertedData = ConfigureDb.da.insert(test);
+		final TypeManyToManyLongRoot insertedData = ConfigureDb.da.insert(test);
 		Assertions.assertNotNull(insertedData);
 		Assertions.assertNotNull(insertedData.id);
 		Assertions.assertTrue(insertedData.id >= 0);
 		Assertions.assertNull(insertedData.remote);
 
 		// Try to retrieve all the data:
-		TypeManyToManyRoot retrieve = ConfigureDb.da.get(TypeManyToManyRoot.class, insertedData.id);
+		TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
 
 		Assertions.assertNotNull(retrieve);
 		Assertions.assertNotNull(retrieve.id);
@@ -109,10 +109,12 @@ public class TestManyToMany {
 		Assertions.assertNull(retrieve.remote);
 
 		// Add remote elements
-		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyRoot.class, retrieve.id, "remote", insertedRemote1.id);
-		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyRoot.class, retrieve.id, "remote", insertedRemote2.id);
+		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+				insertedRemote1.id);
+		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+				insertedRemote2.id);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyRoot.class, insertedData.id);
+		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
 
 		Assertions.assertNotNull(retrieve);
 		Assertions.assertNotNull(retrieve.id);
@@ -124,7 +126,7 @@ public class TestManyToMany {
 		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote1.id);
 		Assertions.assertEquals(retrieve.remote.get(1), insertedRemote2.id);
 
-		final TypeManyToManyRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyRootExpand.class,
+		final TypeManyToManyLongRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyLongRootExpand.class,
 				insertedData.id);
 
 		Assertions.assertNotNull(retrieveExpand);
@@ -138,11 +140,11 @@ public class TestManyToMany {
 		Assertions.assertEquals(retrieveExpand.remote.get(1).id, insertedRemote2.id);
 
 		// Remove an element
-		long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyRoot.class, retrieve.id, "remote",
+		long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
 				insertedRemote1.id);
 		Assertions.assertEquals(1, count);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyRoot.class, insertedData.id);
+		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
 
 		Assertions.assertNotNull(retrieve);
 		Assertions.assertNotNull(retrieve.id);
@@ -154,11 +156,11 @@ public class TestManyToMany {
 		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote2.id);
 
 		// Remove the second element
-		count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyRoot.class, retrieve.id, "remote",
+		count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
 				insertedRemote2.id);
 		Assertions.assertEquals(1, count);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyRoot.class, insertedData.id);
+		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
 
 		Assertions.assertNotNull(retrieve);
 		Assertions.assertNotNull(retrieve.id);
@@ -167,7 +169,7 @@ public class TestManyToMany {
 		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
 		Assertions.assertNull(retrieve.remote);
 
-		ConfigureDb.da.delete(TypeManyToManyRoot.class, insertedData.id);
+		ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
 	}
 
 	/* API TODO: - Replace list (permet de les ordonnées) - remove all links - delete en cascade .... (compliqué...) */

test/src/test/kar/archidata/dataAccess/TestManyToManyOID.java

@@ -0,0 +1,184 @@
+package test.kar.archidata.dataAccess;
+
+import java.io.IOException;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.kar.archidata.dataAccess.DBAccessSQL;
+import org.kar.archidata.dataAccess.DataFactory;
+import org.kar.archidata.dataAccess.addOnSQL.AddOnManyToMany;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import test.kar.archidata.ConfigureDb;
+import test.kar.archidata.StepwiseExtension;
+import test.kar.archidata.dataAccess.model.TypeManyToManyOIDRemote;
+import test.kar.archidata.dataAccess.model.TypeManyToManyOIDRoot;
+import test.kar.archidata.dataAccess.model.TypeManyToManyOIDRootExpand;
+
+@ExtendWith(StepwiseExtension.class)
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class TestManyToManyOID {
+	final static private Logger LOGGER = LoggerFactory.getLogger(TestManyToManyOID.class);
+
+	@BeforeAll
+	public static void configureWebServer() throws Exception {
+		ConfigureDb.configure();
+	}
+
+	@AfterAll
+	public static void removeDataBase() throws IOException {
+		ConfigureDb.clear();
+	}
+
+	@Order(1)
+	@Test
+	public void testCreateTable() throws Exception {
+		final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyOIDRoot.class);
+		final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyOIDRemote.class);
+		sqlCommand.addAll(sqlCommand2);
+		if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+			for (final String elem : sqlCommand) {
+				LOGGER.debug("request: '{}'", elem);
+				daSQL.executeSimpleQuery(elem);
+			}
+		}
+	}
+
+	@Order(2)
+	@Test
+	public void testSimpleInsertAndRetieve() throws Exception {
+		final Calendar calendar = Calendar.getInstance();
+		calendar.add(Calendar.MINUTE, -1);
+		final Date beginTestDate = calendar.getTime();
+		final TypeManyToManyOIDRoot test = new TypeManyToManyOIDRoot();
+		test.otherData = "kjhlkjlkj";
+		final TypeManyToManyOIDRoot insertedData = ConfigureDb.da.insert(test);
+		Assertions.assertNotNull(insertedData);
+		Assertions.assertNotNull(insertedData.oid);
+		Assertions.assertTrue(insertedData.oid.getDate().after(beginTestDate));
+		Assertions.assertNull(insertedData.remote);
+
+		// Try to retrieve all the data:
+		final TypeManyToManyOIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
+
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.oid);
+		Assertions.assertEquals(insertedData.oid, retrieve.oid);
+		Assertions.assertNotNull(retrieve.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertNull(retrieve.remote);
+
+		ConfigureDb.da.delete(TypeManyToManyOIDRoot.class, insertedData.oid);
+	}
+
+	@Order(3)
+	@Test
+	public void testSimpleInsertAndRetieveSubValues() throws Exception {
+		final Calendar calendar = Calendar.getInstance();
+		calendar.add(Calendar.MINUTE, -1);
+		final Date beginTestDate = calendar.getTime();
+		TypeManyToManyOIDRemote remote = new TypeManyToManyOIDRemote();
+		remote.data = "remote1";
+		final TypeManyToManyOIDRemote insertedRemote1 = ConfigureDb.da.insert(remote);
+		Assertions.assertEquals(insertedRemote1.data, remote.data);
+
+		remote = new TypeManyToManyOIDRemote();
+		remote.data = "remote2";
+		final TypeManyToManyOIDRemote insertedRemote2 = ConfigureDb.da.insert(remote);
+		Assertions.assertEquals(insertedRemote2.data, remote.data);
+
+		final TypeManyToManyOIDRoot test = new TypeManyToManyOIDRoot();
+		test.otherData = "kjhlkjlkj";
+		final TypeManyToManyOIDRoot insertedData = ConfigureDb.da.insert(test);
+		Assertions.assertNotNull(insertedData);
+		Assertions.assertNotNull(insertedData.oid);
+		Assertions.assertTrue(insertedData.oid.getDate().after(beginTestDate));
+		Assertions.assertNull(insertedData.remote);
+
+		// Try to retrieve all the data:
+		TypeManyToManyOIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
+
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.oid);
+		Assertions.assertEquals(insertedData.oid, retrieve.oid);
+		Assertions.assertNotNull(retrieve.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertNull(retrieve.remote);
+
+		// Add remote elements
+		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
+				insertedRemote1.oid);
+		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
+				insertedRemote2.oid);
+
+		retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
+
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.oid);
+		Assertions.assertEquals(insertedData.oid, retrieve.oid);
+		Assertions.assertNotNull(retrieve.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertNotNull(retrieve.remote);
+		Assertions.assertEquals(2, retrieve.remote.size());
+		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote1.oid);
+		Assertions.assertEquals(retrieve.remote.get(1), insertedRemote2.oid);
+
+		final TypeManyToManyOIDRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyOIDRootExpand.class,
+				insertedData.oid);
+
+		Assertions.assertNotNull(retrieveExpand);
+		Assertions.assertNotNull(retrieveExpand.oid);
+		Assertions.assertEquals(insertedData.oid, retrieveExpand.oid);
+		Assertions.assertNotNull(retrieveExpand.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieveExpand.otherData);
+		Assertions.assertNotNull(retrieveExpand.remote);
+		Assertions.assertEquals(2, retrieveExpand.remote.size());
+		Assertions.assertEquals(retrieveExpand.remote.get(0).oid, insertedRemote1.oid);
+		Assertions.assertEquals(retrieveExpand.remote.get(1).oid, insertedRemote2.oid);
+
+		// Remove an element
+		long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
+				insertedRemote1.oid);
+		Assertions.assertEquals(1, count);
+
+		retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
+
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.oid);
+		Assertions.assertEquals(insertedData.oid, retrieve.oid);
+		Assertions.assertNotNull(retrieve.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertNotNull(retrieve.remote);
+		Assertions.assertEquals(retrieve.remote.size(), 1);
+		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote2.oid);
+
+		// Remove the second element
+		count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
+				insertedRemote2.oid);
+		Assertions.assertEquals(1, count);
+
+		retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
+
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.oid);
+		Assertions.assertEquals(insertedData.oid, retrieve.oid);
+		Assertions.assertNotNull(retrieve.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertNull(retrieve.remote);
+
+		ConfigureDb.da.delete(TypeManyToManyOIDRoot.class, insertedData.oid);
+	}
+
+	/* API TODO: - Replace list (permet de les ordonnées) - remove all links - delete en cascade .... (compliqué...) */
+
+}

test/src/test/kar/archidata/dataAccess/TestManyToManyUUID.java

@@ -0,0 +1,177 @@
+package test.kar.archidata.dataAccess;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.kar.archidata.dataAccess.DBAccessSQL;
+import org.kar.archidata.dataAccess.DataFactory;
+import org.kar.archidata.dataAccess.addOnSQL.AddOnManyToMany;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import test.kar.archidata.ConfigureDb;
+import test.kar.archidata.StepwiseExtension;
+import test.kar.archidata.dataAccess.model.TypeManyToManyLongRemote;
+import test.kar.archidata.dataAccess.model.TypeManyToManyLongRoot;
+import test.kar.archidata.dataAccess.model.TypeManyToManyLongRootExpand;
+
+@ExtendWith(StepwiseExtension.class)
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class TestManyToManyUUID {
+	final static private Logger LOGGER = LoggerFactory.getLogger(TestManyToManyLong.class);
+
+	@BeforeAll
+	public static void configureWebServer() throws Exception {
+		ConfigureDb.configure();
+	}
+
+	@AfterAll
+	public static void removeDataBase() throws IOException {
+		ConfigureDb.clear();
+	}
+
+	@Order(1)
+	@Test
+	public void testCreateTable() throws Exception {
+		final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyLongRoot.class);
+		final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyLongRemote.class);
+		sqlCommand.addAll(sqlCommand2);
+		if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+			for (final String elem : sqlCommand) {
+				LOGGER.debug("request: '{}'", elem);
+				daSQL.executeSimpleQuery(elem);
+			}
+		}
+	}
+
+	@Order(2)
+	@Test
+	public void testSimpleInsertAndRetieve() throws Exception {
+		final TypeManyToManyLongRoot test = new TypeManyToManyLongRoot();
+		test.otherData = "kjhlkjlkj";
+		final TypeManyToManyLongRoot insertedData = ConfigureDb.da.insert(test);
+		Assertions.assertNotNull(insertedData);
+		Assertions.assertNotNull(insertedData.id);
+		Assertions.assertTrue(insertedData.id >= 0);
+		Assertions.assertNull(insertedData.remote);
+
+		// Try to retrieve all the data:
+		final TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.id);
+		Assertions.assertEquals(insertedData.id, retrieve.id);
+		Assertions.assertNotNull(retrieve.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertNull(retrieve.remote);
+
+		ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
+	}
+
+	@Order(3)
+	@Test
+	public void testSimpleInsertAndRetieveSubValues() throws Exception {
+
+		TypeManyToManyLongRemote remote = new TypeManyToManyLongRemote();
+		remote.data = "remote1";
+		final TypeManyToManyLongRemote insertedRemote1 = ConfigureDb.da.insert(remote);
+		Assertions.assertEquals(insertedRemote1.data, remote.data);
+
+		remote = new TypeManyToManyLongRemote();
+		remote.data = "remote2";
+		final TypeManyToManyLongRemote insertedRemote2 = ConfigureDb.da.insert(remote);
+		Assertions.assertEquals(insertedRemote2.data, remote.data);
+
+		final TypeManyToManyLongRoot test = new TypeManyToManyLongRoot();
+		test.otherData = "kjhlkjlkj";
+		final TypeManyToManyLongRoot insertedData = ConfigureDb.da.insert(test);
+		Assertions.assertNotNull(insertedData);
+		Assertions.assertNotNull(insertedData.id);
+		Assertions.assertTrue(insertedData.id >= 0);
+		Assertions.assertNull(insertedData.remote);
+
+		// Try to retrieve all the data:
+		TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.id);
+		Assertions.assertEquals(insertedData.id, retrieve.id);
+		Assertions.assertNotNull(retrieve.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertNull(retrieve.remote);
+
+		// Add remote elements
+		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+				insertedRemote1.id);
+		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+				insertedRemote2.id);
+
+		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.id);
+		Assertions.assertEquals(insertedData.id, retrieve.id);
+		Assertions.assertNotNull(retrieve.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertNotNull(retrieve.remote);
+		Assertions.assertEquals(2, retrieve.remote.size());
+		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote1.id);
+		Assertions.assertEquals(retrieve.remote.get(1), insertedRemote2.id);
+
+		final TypeManyToManyLongRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyLongRootExpand.class,
+				insertedData.id);
+
+		Assertions.assertNotNull(retrieveExpand);
+		Assertions.assertNotNull(retrieveExpand.id);
+		Assertions.assertEquals(insertedData.id, retrieveExpand.id);
+		Assertions.assertNotNull(retrieveExpand.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieveExpand.otherData);
+		Assertions.assertNotNull(retrieveExpand.remote);
+		Assertions.assertEquals(2, retrieveExpand.remote.size());
+		Assertions.assertEquals(retrieveExpand.remote.get(0).id, insertedRemote1.id);
+		Assertions.assertEquals(retrieveExpand.remote.get(1).id, insertedRemote2.id);
+
+		// Remove an element
+		long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+				insertedRemote1.id);
+		Assertions.assertEquals(1, count);
+
+		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.id);
+		Assertions.assertEquals(insertedData.id, retrieve.id);
+		Assertions.assertNotNull(retrieve.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertNotNull(retrieve.remote);
+		Assertions.assertEquals(retrieve.remote.size(), 1);
+		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote2.id);
+
+		// Remove the second element
+		count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+				insertedRemote2.id);
+		Assertions.assertEquals(1, count);
+
+		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.id);
+		Assertions.assertEquals(insertedData.id, retrieve.id);
+		Assertions.assertNotNull(retrieve.otherData);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertNull(retrieve.remote);
+
+		ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
+	}
+
+	/* API TODO: - Replace list (permet de les ordonnées) - remove all links - delete en cascade .... (compliqué...) */
+
+}

test/src/test/kar/archidata/dataAccess/TestManyToOneLong.java

@@ -18,17 +18,17 @@ import org.slf4j.LoggerFactory;
 
 import test.kar.archidata.ConfigureDb;
 import test.kar.archidata.StepwiseExtension;
-import test.kar.archidata.dataAccess.model.TypeManyToOneRemote;
-import test.kar.archidata.dataAccess.model.TypeManyToOneRoot;
-import test.kar.archidata.dataAccess.model.TypeManyToOneRootExpand;
+import test.kar.archidata.dataAccess.model.TypeManyToOneLongRemote;
+import test.kar.archidata.dataAccess.model.TypeManyToOneLongRoot;
+import test.kar.archidata.dataAccess.model.TypeManyToOneLongRootExpand;
 import test.kar.archidata.dataAccess.model.TypeManyToOneUUIDRemote;
 import test.kar.archidata.dataAccess.model.TypeManyToOneUUIDRoot;
 import test.kar.archidata.dataAccess.model.TypeManyToOneUUIDRootExpand;
 
 @ExtendWith(StepwiseExtension.class)
 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
-public class TestManyToOne {
-	final static private Logger LOGGER = LoggerFactory.getLogger(TestManyToOne.class);
+public class TestManyToOneLong {
+	final static private Logger LOGGER = LoggerFactory.getLogger(TestManyToOneLong.class);
 
 	@BeforeAll
 	public static void configureWebServer() throws Exception {
@@ -43,8 +43,8 @@ public class TestManyToOne {
 	@Order(1)
 	@Test
 	public void testCreateTable() throws Exception {
-		final List<String> sqlCommand = DataFactory.createTable(TypeManyToOneRemote.class);
-		sqlCommand.addAll(DataFactory.createTable(TypeManyToOneRoot.class));
+		final List<String> sqlCommand = DataFactory.createTable(TypeManyToOneLongRemote.class);
+		sqlCommand.addAll(DataFactory.createTable(TypeManyToOneLongRoot.class));
 		sqlCommand.addAll(DataFactory.createTable(TypeManyToOneUUIDRoot.class));
 		sqlCommand.addAll(DataFactory.createTable(TypeManyToOneUUIDRemote.class));
 		if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
@@ -58,34 +58,34 @@ public class TestManyToOne {
 	@Order(2)
 	@Test
 	public void testRemoteLong() throws Exception {
-		TypeManyToOneRemote remote = new TypeManyToOneRemote();
+		TypeManyToOneLongRemote remote = new TypeManyToOneLongRemote();
 		remote.data = "remote1";
-		final TypeManyToOneRemote insertedRemote1 = ConfigureDb.da.insert(remote);
+		final TypeManyToOneLongRemote insertedRemote1 = ConfigureDb.da.insert(remote);
 		Assertions.assertEquals(insertedRemote1.data, remote.data);
 
-		remote = new TypeManyToOneRemote();
+		remote = new TypeManyToOneLongRemote();
 		remote.data = "remote2";
-		final TypeManyToOneRemote insertedRemote2 = ConfigureDb.da.insert(remote);
+		final TypeManyToOneLongRemote insertedRemote2 = ConfigureDb.da.insert(remote);
 		Assertions.assertEquals(insertedRemote2.data, remote.data);
 
-		final TypeManyToOneRoot test = new TypeManyToOneRoot();
+		final TypeManyToOneLongRoot test = new TypeManyToOneLongRoot();
 		test.otherData = "kjhlkjlkj";
 		test.remoteId = insertedRemote2.id;
-		final TypeManyToOneRoot insertedData = ConfigureDb.da.insert(test);
+		final TypeManyToOneLongRoot insertedData = ConfigureDb.da.insert(test);
 		Assertions.assertNotNull(insertedData);
 		Assertions.assertNotNull(insertedData.id);
 		Assertions.assertTrue(insertedData.id >= 0);
 		Assertions.assertEquals(test.otherData, insertedData.otherData);
 		Assertions.assertEquals(insertedRemote2.id, insertedData.remoteId);
 
-		TypeManyToOneRoot retrieve = ConfigureDb.da.get(TypeManyToOneRoot.class, insertedData.id);
+		TypeManyToOneLongRoot retrieve = ConfigureDb.da.get(TypeManyToOneLongRoot.class, insertedData.id);
 		Assertions.assertNotNull(retrieve);
 		Assertions.assertNotNull(retrieve.id);
 		Assertions.assertEquals(insertedData.id, retrieve.id);
 		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
 		Assertions.assertEquals(insertedRemote2.id, retrieve.remoteId);
 
-		TypeManyToOneRootExpand retrieve2 = ConfigureDb.da.get(TypeManyToOneRootExpand.class, insertedData.id);
+		TypeManyToOneLongRootExpand retrieve2 = ConfigureDb.da.get(TypeManyToOneLongRootExpand.class, insertedData.id);
 		Assertions.assertNotNull(retrieve2);
 		Assertions.assertNotNull(retrieve2.id);
 		Assertions.assertEquals(insertedData.id, retrieve2.id);
@@ -96,21 +96,21 @@ public class TestManyToOne {
 
 		// remove values:
 		try {
-			final long count = ConfigureDb.da.delete(TypeManyToOneRemote.class, insertedRemote2.id);
+			final long count = ConfigureDb.da.delete(TypeManyToOneLongRemote.class, insertedRemote2.id);
 			Assertions.assertEquals(1L, count);
 		} catch (final Exception ex) {
 			ex.printStackTrace();
 		}
 		// check fail:
 
-		retrieve = ConfigureDb.da.get(TypeManyToOneRoot.class, insertedData.id);
+		retrieve = ConfigureDb.da.get(TypeManyToOneLongRoot.class, insertedData.id);
 		Assertions.assertNotNull(retrieve);
 		Assertions.assertNotNull(retrieve.id);
 		Assertions.assertEquals(insertedData.id, retrieve.id);
 		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
 		Assertions.assertEquals(insertedRemote2.id, retrieve.remoteId);
 
-		retrieve2 = ConfigureDb.da.get(TypeManyToOneRootExpand.class, insertedData.id);
+		retrieve2 = ConfigureDb.da.get(TypeManyToOneLongRootExpand.class, insertedData.id);
 		Assertions.assertNotNull(retrieve2);
 		Assertions.assertNotNull(retrieve2.id);
 		Assertions.assertEquals(insertedData.id, retrieve2.id);

test/src/test/kar/archidata/dataAccess/TestManyToOneOID.java

@@ -0,0 +1,111 @@
+package test.kar.archidata.dataAccess;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.kar.archidata.dataAccess.DBAccessSQL;
+import org.kar.archidata.dataAccess.DataFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import test.kar.archidata.ConfigureDb;
+import test.kar.archidata.StepwiseExtension;
+import test.kar.archidata.dataAccess.model.TypeManyToOneOIDRemote;
+import test.kar.archidata.dataAccess.model.TypeManyToOneOIDRoot;
+import test.kar.archidata.dataAccess.model.TypeManyToOneOIDRootExpand;
+
+@ExtendWith(StepwiseExtension.class)
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class TestManyToOneOID {
+	final static private Logger LOGGER = LoggerFactory.getLogger(TestManyToOneOID.class);
+
+	@BeforeAll
+	public static void configureWebServer() throws Exception {
+		ConfigureDb.configure();
+	}
+
+	@AfterAll
+	public static void removeDataBase() throws IOException {
+		ConfigureDb.clear();
+	}
+
+	@Order(1)
+	@Test
+	public void testCreateTable() throws Exception {
+		final List<String> sqlCommand = DataFactory.createTable(TypeManyToOneOIDRemote.class);
+		sqlCommand.addAll(DataFactory.createTable(TypeManyToOneOIDRoot.class));
+		if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+			for (final String elem : sqlCommand) {
+				LOGGER.debug("request: '{}'", elem);
+				daSQL.executeSimpleQuery(elem);
+			}
+		}
+	}
+
+	@Order(3)
+	@Test
+	public void testRemoteOID() throws Exception {
+		TypeManyToOneOIDRemote remote = new TypeManyToOneOIDRemote();
+		remote.data = "remote1";
+		final TypeManyToOneOIDRemote insertedRemote1 = ConfigureDb.da.insert(remote);
+		Assertions.assertEquals(insertedRemote1.data, remote.data);
+
+		remote = new TypeManyToOneOIDRemote();
+		remote.data = "remote2";
+		final TypeManyToOneOIDRemote insertedRemote2 = ConfigureDb.da.insert(remote);
+		Assertions.assertEquals(insertedRemote2.data, remote.data);
+
+		final TypeManyToOneOIDRoot test = new TypeManyToOneOIDRoot();
+		test.otherData = "kjhlkjlkj";
+		test.remoteOid = insertedRemote2.oid;
+		final TypeManyToOneOIDRoot insertedData = ConfigureDb.da.insert(test);
+		Assertions.assertNotNull(insertedData);
+		Assertions.assertNotNull(insertedData.oid);
+		Assertions.assertEquals(test.otherData, insertedData.otherData);
+		Assertions.assertEquals(insertedRemote2.oid, insertedData.remoteOid);
+
+		TypeManyToOneOIDRoot retrieve = ConfigureDb.da.get(TypeManyToOneOIDRoot.class, insertedData.oid);
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.oid);
+		Assertions.assertEquals(insertedData.oid, retrieve.oid);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertEquals(insertedRemote2.oid, retrieve.remoteOid);
+
+		TypeManyToOneOIDRootExpand retrieve2 = ConfigureDb.da.get(TypeManyToOneOIDRootExpand.class, insertedData.oid);
+		Assertions.assertNotNull(retrieve2);
+		Assertions.assertNotNull(retrieve2.oid);
+		Assertions.assertEquals(insertedData.oid, retrieve2.oid);
+		Assertions.assertEquals(insertedData.otherData, retrieve2.otherData);
+		Assertions.assertNotNull(retrieve2.remote);
+		Assertions.assertEquals(insertedRemote2.oid, retrieve2.remote.oid);
+		Assertions.assertEquals(insertedRemote2.data, retrieve2.remote.data);
+
+		// remove values:
+		final long count = ConfigureDb.da.delete(TypeManyToOneOIDRemote.class, insertedRemote2.oid);
+		Assertions.assertEquals(1, count);
+
+		// check fail:
+
+		retrieve = ConfigureDb.da.get(TypeManyToOneOIDRoot.class, insertedData.oid);
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.oid);
+		Assertions.assertEquals(insertedData.oid, retrieve.oid);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertEquals(insertedRemote2.oid, retrieve.remoteOid);
+
+		retrieve2 = ConfigureDb.da.get(TypeManyToOneOIDRootExpand.class, insertedData.oid);
+		Assertions.assertNotNull(retrieve2);
+		Assertions.assertNotNull(retrieve2.oid);
+		Assertions.assertEquals(insertedData.oid, retrieve2.oid);
+		Assertions.assertEquals(insertedData.otherData, retrieve2.otherData);
+		Assertions.assertNull(retrieve2.remote);
+	}
+}

test/src/test/kar/archidata/dataAccess/TestManyToOneUUID.java

@@ -0,0 +1,114 @@
+package test.kar.archidata.dataAccess;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.kar.archidata.dataAccess.DBAccessSQL;
+import org.kar.archidata.dataAccess.DataFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import test.kar.archidata.ConfigureDb;
+import test.kar.archidata.StepwiseExtension;
+import test.kar.archidata.dataAccess.model.TypeManyToOneLongRemote;
+import test.kar.archidata.dataAccess.model.TypeManyToOneUUIDRemote;
+import test.kar.archidata.dataAccess.model.TypeManyToOneUUIDRoot;
+import test.kar.archidata.dataAccess.model.TypeManyToOneUUIDRootExpand;
+
+@ExtendWith(StepwiseExtension.class)
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class TestManyToOneUUID {
+	final static private Logger LOGGER = LoggerFactory.getLogger(TestManyToOneLong.class);
+
+	@BeforeAll
+	public static void configureWebServer() throws Exception {
+		ConfigureDb.configure();
+	}
+
+	@AfterAll
+	public static void removeDataBase() throws IOException {
+		ConfigureDb.clear();
+	}
+
+	@Order(1)
+	@Test
+	public void testCreateTable() throws Exception {
+		final List<String> sqlCommand = DataFactory.createTable(TypeManyToOneLongRemote.class);
+		sqlCommand.addAll(DataFactory.createTable(TypeManyToOneUUIDRoot.class));
+		sqlCommand.addAll(DataFactory.createTable(TypeManyToOneUUIDRemote.class));
+		if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+			for (final String elem : sqlCommand) {
+				LOGGER.debug("request: '{}'", elem);
+				daSQL.executeSimpleQuery(elem);
+			}
+		}
+	}
+
+	@Order(3)
+	@Test
+	public void testRemoteUUID() throws Exception {
+		TypeManyToOneUUIDRemote remote = new TypeManyToOneUUIDRemote();
+		remote.data = "remote1";
+		final TypeManyToOneUUIDRemote insertedRemote1 = ConfigureDb.da.insert(remote);
+		Assertions.assertEquals(insertedRemote1.data, remote.data);
+
+		remote = new TypeManyToOneUUIDRemote();
+		remote.data = "remote2";
+		final TypeManyToOneUUIDRemote insertedRemote2 = ConfigureDb.da.insert(remote);
+		Assertions.assertEquals(insertedRemote2.data, remote.data);
+
+		final TypeManyToOneUUIDRoot test = new TypeManyToOneUUIDRoot();
+		test.otherData = "kjhlkjlkj";
+		test.remoteUuid = insertedRemote2.uuid;
+		final TypeManyToOneUUIDRoot insertedData = ConfigureDb.da.insert(test);
+		Assertions.assertNotNull(insertedData);
+		Assertions.assertNotNull(insertedData.uuid);
+		Assertions.assertEquals(test.otherData, insertedData.otherData);
+		Assertions.assertEquals(insertedRemote2.uuid, insertedData.remoteUuid);
+
+		TypeManyToOneUUIDRoot retrieve = ConfigureDb.da.get(TypeManyToOneUUIDRoot.class, insertedData.uuid);
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.uuid);
+		Assertions.assertEquals(insertedData.uuid, retrieve.uuid);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertEquals(insertedRemote2.uuid, retrieve.remoteUuid);
+
+		TypeManyToOneUUIDRootExpand retrieve2 = ConfigureDb.da.get(TypeManyToOneUUIDRootExpand.class,
+				insertedData.uuid);
+		Assertions.assertNotNull(retrieve2);
+		Assertions.assertNotNull(retrieve2.uuid);
+		Assertions.assertEquals(insertedData.uuid, retrieve2.uuid);
+		Assertions.assertEquals(insertedData.otherData, retrieve2.otherData);
+		Assertions.assertNotNull(retrieve2.remote);
+		Assertions.assertEquals(insertedRemote2.uuid, retrieve2.remote.uuid);
+		Assertions.assertEquals(insertedRemote2.data, retrieve2.remote.data);
+
+		// remove values:
+		final long count = ConfigureDb.da.delete(TypeManyToOneUUIDRemote.class, insertedRemote2.uuid);
+		Assertions.assertEquals(1, count);
+
+		// check fail:
+
+		retrieve = ConfigureDb.da.get(TypeManyToOneUUIDRoot.class, insertedData.uuid);
+		Assertions.assertNotNull(retrieve);
+		Assertions.assertNotNull(retrieve.uuid);
+		Assertions.assertEquals(insertedData.uuid, retrieve.uuid);
+		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+		Assertions.assertEquals(insertedRemote2.uuid, retrieve.remoteUuid);
+
+		retrieve2 = ConfigureDb.da.get(TypeManyToOneUUIDRootExpand.class, insertedData.uuid);
+		Assertions.assertNotNull(retrieve2);
+		Assertions.assertNotNull(retrieve2.uuid);
+		Assertions.assertEquals(insertedData.uuid, retrieve2.uuid);
+		Assertions.assertEquals(insertedData.otherData, retrieve2.otherData);
+		Assertions.assertNull(retrieve2.remote);
+	}
+}

test/src/test/kar/archidata/dataAccess/TestOneToManyLong.java

@@ -0,0 +1,131 @@
+package test.kar.archidata.dataAccess;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.kar.archidata.dataAccess.DBAccessSQL;
+import org.kar.archidata.dataAccess.DataFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import test.kar.archidata.ConfigureDb;
+import test.kar.archidata.StepwiseExtension;
+import test.kar.archidata.dataAccess.model.TypeOneToManyLongRemote;
+import test.kar.archidata.dataAccess.model.TypeOneToManyLongRoot;
+import test.kar.archidata.dataAccess.model.TypeOneToManyLongRootExpand;
+
+@ExtendWith(StepwiseExtension.class)
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class TestOneToManyLong {
+	final static private Logger LOGGER = LoggerFactory.getLogger(TestOneToManyLong.class);
+
+	@BeforeAll
+	public static void configureWebServer() throws Exception {
+		ConfigureDb.configure();
+	}
+
+	@AfterAll
+	public static void removeDataBase() throws IOException {
+		ConfigureDb.clear();
+	}
+
+	@Order(1)
+	@Test
+	public void testCreateTable() throws Exception {
+		final List<String> sqlCommand = DataFactory.createTable(TypeOneToManyLongRemote.class);
+		sqlCommand.addAll(DataFactory.createTable(TypeOneToManyLongRoot.class));
+		if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+			for (final String elem : sqlCommand) {
+				LOGGER.debug("request: '{}'", elem);
+				daSQL.executeSimpleQuery(elem);
+			}
+		}
+	}
+
+	@Order(2)
+	@Test
+	public void testParentLong() throws Exception {
+		// create parent:
+
+		final TypeOneToManyLongRoot root = new TypeOneToManyLongRoot();
+		root.otherData = "plouf";
+		final TypeOneToManyLongRoot insertedRoot = ConfigureDb.da.insert(root);
+		Assertions.assertEquals(insertedRoot.otherData, root.otherData);
+		Assertions.assertNull(insertedRoot.remoteIds);
+
+		final TypeOneToManyLongRoot root2 = new TypeOneToManyLongRoot();
+		root2.otherData = "plouf 2";
+		final TypeOneToManyLongRoot insertedRoot2 = ConfigureDb.da.insert(root2);
+		Assertions.assertEquals(insertedRoot2.otherData, root2.otherData);
+		Assertions.assertNull(insertedRoot2.remoteIds);
+
+		// Create Some Remotes
+
+		final TypeOneToManyLongRemote remote10 = new TypeOneToManyLongRemote();
+		remote10.data = "remote10";
+		remote10.rootId = insertedRoot.id;
+		final TypeOneToManyLongRemote insertedRemote10 = ConfigureDb.da.insert(remote10);
+		Assertions.assertEquals(insertedRemote10.data, remote10.data);
+		Assertions.assertEquals(insertedRemote10.rootId, remote10.rootId);
+
+		final TypeOneToManyLongRemote remote11 = new TypeOneToManyLongRemote();
+		remote11.data = "remote11";
+		remote11.rootId = insertedRoot.id;
+		final TypeOneToManyLongRemote insertedRemote11 = ConfigureDb.da.insert(remote11);
+		Assertions.assertEquals(insertedRemote11.data, remote11.data);
+		Assertions.assertEquals(insertedRemote11.rootId, remote11.rootId);
+
+		final TypeOneToManyLongRemote remote20 = new TypeOneToManyLongRemote();
+		remote20.data = "remote20";
+		remote20.rootId = insertedRoot2.id;
+		final TypeOneToManyLongRemote insertedRemote20 = ConfigureDb.da.insert(remote20);
+		Assertions.assertEquals(insertedRemote20.data, remote20.data);
+		Assertions.assertEquals(insertedRemote20.rootId, remote20.rootId);
+
+		// Check remote are inserted
+
+		final TypeOneToManyLongRoot retreiveRoot1 = ConfigureDb.da.get(TypeOneToManyLongRoot.class, insertedRoot.id);
+		Assertions.assertEquals(retreiveRoot1.otherData, insertedRoot.otherData);
+		Assertions.assertNotNull(retreiveRoot1.remoteIds);
+		Assertions.assertEquals(2, retreiveRoot1.remoteIds.size());
+		Assertions.assertEquals(insertedRemote10.id, retreiveRoot1.remoteIds.get(0));
+		Assertions.assertEquals(insertedRemote11.id, retreiveRoot1.remoteIds.get(1));
+
+		final TypeOneToManyLongRoot retreiveRoot2 = ConfigureDb.da.get(TypeOneToManyLongRoot.class, insertedRoot2.id);
+		Assertions.assertEquals(retreiveRoot2.otherData, insertedRoot2.otherData);
+		Assertions.assertNotNull(retreiveRoot2.remoteIds);
+		Assertions.assertEquals(1, retreiveRoot2.remoteIds.size());
+		Assertions.assertEquals(insertedRemote20.id, retreiveRoot2.remoteIds.get(0));
+
+		// Check remote are inserted and expandable
+		final TypeOneToManyLongRootExpand retreiveRootExpand1 = ConfigureDb.da.get(TypeOneToManyLongRootExpand.class,
+				insertedRoot.id);
+		Assertions.assertEquals(retreiveRootExpand1.otherData, insertedRoot.otherData);
+		Assertions.assertNotNull(retreiveRootExpand1.remotes);
+		Assertions.assertEquals(2, retreiveRootExpand1.remotes.size());
+		Assertions.assertEquals(insertedRemote10.id, retreiveRootExpand1.remotes.get(0).id);
+		Assertions.assertEquals(insertedRemote10.rootId, retreiveRootExpand1.remotes.get(0).rootId);
+		Assertions.assertEquals(insertedRemote10.data, retreiveRootExpand1.remotes.get(0).data);
+		Assertions.assertEquals(insertedRemote11.id, retreiveRootExpand1.remotes.get(1).id);
+		Assertions.assertEquals(insertedRemote11.rootId, retreiveRootExpand1.remotes.get(1).rootId);
+		Assertions.assertEquals(insertedRemote11.data, retreiveRootExpand1.remotes.get(1).data);
+
+		final TypeOneToManyLongRootExpand retreiveRootExpand2 = ConfigureDb.da.get(TypeOneToManyLongRootExpand.class,
+				insertedRoot2.id);
+		Assertions.assertEquals(retreiveRootExpand2.otherData, insertedRoot2.otherData);
+		Assertions.assertNotNull(retreiveRootExpand2.remotes);
+		Assertions.assertEquals(1, retreiveRootExpand2.remotes.size());
+		Assertions.assertEquals(insertedRemote20.id, retreiveRootExpand2.remotes.get(0).id);
+		Assertions.assertEquals(insertedRemote20.rootId, retreiveRootExpand2.remotes.get(0).rootId);
+		Assertions.assertEquals(insertedRemote20.data, retreiveRootExpand2.remotes.get(0).data);
+
+	}
+}

test/src/test/kar/archidata/dataAccess/TestOneToManyOID.java

@@ -0,0 +1,130 @@
+package test.kar.archidata.dataAccess;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.kar.archidata.dataAccess.DBAccessSQL;
+import org.kar.archidata.dataAccess.DataFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import test.kar.archidata.ConfigureDb;
+import test.kar.archidata.StepwiseExtension;
+import test.kar.archidata.dataAccess.model.TypeOneToManyOIDRemote;
+import test.kar.archidata.dataAccess.model.TypeOneToManyOIDRoot;
+import test.kar.archidata.dataAccess.model.TypeOneToManyOIDRootExpand;
+
+@ExtendWith(StepwiseExtension.class)
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class TestOneToManyOID {
+	final static private Logger LOGGER = LoggerFactory.getLogger(TestOneToManyOID.class);
+
+	@BeforeAll
+	public static void configureWebServer() throws Exception {
+		ConfigureDb.configure();
+	}
+
+	@AfterAll
+	public static void removeDataBase() throws IOException {
+		ConfigureDb.clear();
+	}
+
+	@Order(1)
+	@Test
+	public void testCreateTable() throws Exception {
+		final List<String> sqlCommand = DataFactory.createTable(TypeOneToManyOIDRemote.class);
+		sqlCommand.addAll(DataFactory.createTable(TypeOneToManyOIDRoot.class));
+		if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+			for (final String elem : sqlCommand) {
+				LOGGER.debug("request: '{}'", elem);
+				daSQL.executeSimpleQuery(elem);
+			}
+		}
+	}
+
+	@Order(2)
+	@Test
+	public void testParent() throws Exception {
+		// create parent:
+
+		final TypeOneToManyOIDRoot root = new TypeOneToManyOIDRoot();
+		root.otherData = "plouf";
+		final TypeOneToManyOIDRoot insertedRoot = ConfigureDb.da.insert(root);
+		Assertions.assertEquals(insertedRoot.otherData, root.otherData);
+		Assertions.assertNull(insertedRoot.remoteIds);
+
+		final TypeOneToManyOIDRoot root2 = new TypeOneToManyOIDRoot();
+		root2.otherData = "plouf 2";
+		final TypeOneToManyOIDRoot insertedRoot2 = ConfigureDb.da.insert(root2);
+		Assertions.assertEquals(insertedRoot2.otherData, root2.otherData);
+		Assertions.assertNull(insertedRoot2.remoteIds);
+
+		// Create Some Remotes
+		final TypeOneToManyOIDRemote remote10 = new TypeOneToManyOIDRemote();
+		remote10.data = "remote10";
+		remote10.rootOid = insertedRoot.oid;
+		final TypeOneToManyOIDRemote insertedRemote10 = ConfigureDb.da.insert(remote10);
+		Assertions.assertEquals(insertedRemote10.data, remote10.data);
+		Assertions.assertEquals(insertedRemote10.rootOid, remote10.rootOid);
+
+		final TypeOneToManyOIDRemote remote11 = new TypeOneToManyOIDRemote();
+		remote11.data = "remote11";
+		remote11.rootOid = insertedRoot.oid;
+		final TypeOneToManyOIDRemote insertedRemote11 = ConfigureDb.da.insert(remote11);
+		Assertions.assertEquals(insertedRemote11.data, remote11.data);
+		Assertions.assertEquals(insertedRemote11.rootOid, remote11.rootOid);
+
+		final TypeOneToManyOIDRemote remote20 = new TypeOneToManyOIDRemote();
+		remote20.data = "remote20";
+		remote20.rootOid = insertedRoot2.oid;
+		final TypeOneToManyOIDRemote insertedRemote20 = ConfigureDb.da.insert(remote20);
+		Assertions.assertEquals(insertedRemote20.data, remote20.data);
+		Assertions.assertEquals(insertedRemote20.rootOid, remote20.rootOid);
+
+		// Check remote are inserted
+		final TypeOneToManyOIDRoot retreiveRoot1 = ConfigureDb.da.get(TypeOneToManyOIDRoot.class, insertedRoot.oid);
+		Assertions.assertEquals(retreiveRoot1.otherData, insertedRoot.otherData);
+		Assertions.assertNotNull(retreiveRoot1.remoteIds);
+		Assertions.assertEquals(2, retreiveRoot1.remoteIds.size());
+		Assertions.assertEquals(insertedRemote10.oid, retreiveRoot1.remoteIds.get(0));
+		Assertions.assertEquals(insertedRemote11.oid, retreiveRoot1.remoteIds.get(1));
+
+		final TypeOneToManyOIDRoot retreiveRoot2 = ConfigureDb.da.get(TypeOneToManyOIDRoot.class, insertedRoot2.oid);
+		Assertions.assertEquals(retreiveRoot2.otherData, insertedRoot2.otherData);
+		Assertions.assertNotNull(retreiveRoot2.remoteIds);
+		Assertions.assertEquals(1, retreiveRoot2.remoteIds.size());
+		Assertions.assertEquals(insertedRemote20.oid, retreiveRoot2.remoteIds.get(0));
+
+		// Check remote are inserted and expandable
+		final TypeOneToManyOIDRootExpand retreiveRootExpand1 = ConfigureDb.da.get(TypeOneToManyOIDRootExpand.class,
+				insertedRoot.oid);
+		Assertions.assertEquals(retreiveRootExpand1.otherData, insertedRoot.otherData);
+		Assertions.assertNotNull(retreiveRootExpand1.remotes);
+		Assertions.assertEquals(2, retreiveRootExpand1.remotes.size());
+		Assertions.assertEquals(insertedRemote10.oid, retreiveRootExpand1.remotes.get(0).oid);
+		Assertions.assertEquals(insertedRemote10.rootOid, retreiveRootExpand1.remotes.get(0).rootOid);
+		Assertions.assertEquals(insertedRemote10.data, retreiveRootExpand1.remotes.get(0).data);
+		Assertions.assertEquals(insertedRemote11.oid, retreiveRootExpand1.remotes.get(1).oid);
+		Assertions.assertEquals(insertedRemote11.rootOid, retreiveRootExpand1.remotes.get(1).rootOid);
+		Assertions.assertEquals(insertedRemote11.data, retreiveRootExpand1.remotes.get(1).data);
+
+		final TypeOneToManyOIDRootExpand retreiveRootExpand2 = ConfigureDb.da.get(TypeOneToManyOIDRootExpand.class,
+				insertedRoot2.oid);
+		Assertions.assertEquals(retreiveRootExpand2.otherData, insertedRoot2.otherData);
+		Assertions.assertNotNull(retreiveRootExpand2.remotes);
+		Assertions.assertEquals(1, retreiveRootExpand2.remotes.size());
+		Assertions.assertEquals(insertedRemote20.oid, retreiveRootExpand2.remotes.get(0).oid);
+		Assertions.assertEquals(insertedRemote20.rootOid, retreiveRootExpand2.remotes.get(0).rootOid);
+		Assertions.assertEquals(insertedRemote20.data, retreiveRootExpand2.remotes.get(0).data);
+
+	}
+
+}

test/src/test/kar/archidata/dataAccess/TestOneToManyUUID.java

@@ -18,17 +18,15 @@ import org.slf4j.LoggerFactory;
 
 import test.kar.archidata.ConfigureDb;
 import test.kar.archidata.StepwiseExtension;
-import test.kar.archidata.dataAccess.model.TypeOneToManyRemote;
-import test.kar.archidata.dataAccess.model.TypeOneToManyRoot;
-import test.kar.archidata.dataAccess.model.TypeOneToManyRootExpand;
+import test.kar.archidata.dataAccess.model.TypeOneToManyLongRemote;
 import test.kar.archidata.dataAccess.model.TypeOneToManyUUIDRemote;
 import test.kar.archidata.dataAccess.model.TypeOneToManyUUIDRoot;
 import test.kar.archidata.dataAccess.model.TypeOneToManyUUIDRootExpand;
 
 @ExtendWith(StepwiseExtension.class)
 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
-public class TestOneToMany {
-	final static private Logger LOGGER = LoggerFactory.getLogger(TestOneToMany.class);
+public class TestOneToManyUUID {
+	final static private Logger LOGGER = LoggerFactory.getLogger(TestOneToManyLong.class);
 
 	@BeforeAll
 	public static void configureWebServer() throws Exception {
@@ -43,10 +41,9 @@ public class TestOneToMany {
 	@Order(1)
 	@Test
 	public void testCreateTable() throws Exception {
-		final List<String> sqlCommand = DataFactory.createTable(TypeOneToManyRemote.class);
-		sqlCommand.addAll(DataFactory.createTable(TypeOneToManyRoot.class));
-		sqlCommand.addAll(DataFactory.createTable(TypeOneToManyUUIDRemote.class));
+		final List<String> sqlCommand = DataFactory.createTable(TypeOneToManyLongRemote.class);
 		sqlCommand.addAll(DataFactory.createTable(TypeOneToManyUUIDRoot.class));
+		sqlCommand.addAll(DataFactory.createTable(TypeOneToManyUUIDRemote.class));
 		if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
 			for (final String elem : sqlCommand) {
 				LOGGER.debug("request: '{}'", elem);
@@ -55,86 +52,6 @@ public class TestOneToMany {
 		}
 	}
 
-	@Order(2)
-	@Test
-	public void testParentLong() throws Exception {
-		// create parent:
-
-		final TypeOneToManyRoot root = new TypeOneToManyRoot();
-		root.otherData = "plouf";
-		final TypeOneToManyRoot insertedRoot = ConfigureDb.da.insert(root);
-		Assertions.assertEquals(insertedRoot.otherData, root.otherData);
-		Assertions.assertNull(insertedRoot.remoteIds);
-
-		final TypeOneToManyRoot root2 = new TypeOneToManyRoot();
-		root2.otherData = "plouf 2";
-		final TypeOneToManyRoot insertedRoot2 = ConfigureDb.da.insert(root2);
-		Assertions.assertEquals(insertedRoot2.otherData, root2.otherData);
-		Assertions.assertNull(insertedRoot2.remoteIds);
-
-		// Create Some Remotes
-
-		final TypeOneToManyRemote remote10 = new TypeOneToManyRemote();
-		remote10.data = "remote10";
-		remote10.rootId = insertedRoot.id;
-		final TypeOneToManyRemote insertedRemote10 = ConfigureDb.da.insert(remote10);
-		Assertions.assertEquals(insertedRemote10.data, remote10.data);
-		Assertions.assertEquals(insertedRemote10.rootId, remote10.rootId);
-
-		final TypeOneToManyRemote remote11 = new TypeOneToManyRemote();
-		remote11.data = "remote11";
-		remote11.rootId = insertedRoot.id;
-		final TypeOneToManyRemote insertedRemote11 = ConfigureDb.da.insert(remote11);
-		Assertions.assertEquals(insertedRemote11.data, remote11.data);
-		Assertions.assertEquals(insertedRemote11.rootId, remote11.rootId);
-
-		final TypeOneToManyRemote remote20 = new TypeOneToManyRemote();
-		remote20.data = "remote20";
-		remote20.rootId = insertedRoot2.id;
-		final TypeOneToManyRemote insertedRemote20 = ConfigureDb.da.insert(remote20);
-		Assertions.assertEquals(insertedRemote20.data, remote20.data);
-		Assertions.assertEquals(insertedRemote20.rootId, remote20.rootId);
-
-		// Check remote are inserted
-
-		final TypeOneToManyRoot retreiveRoot1 = ConfigureDb.da.get(TypeOneToManyRoot.class, insertedRoot.id);
-		Assertions.assertEquals(retreiveRoot1.otherData, insertedRoot.otherData);
-		Assertions.assertNotNull(retreiveRoot1.remoteIds);
-		Assertions.assertEquals(2, retreiveRoot1.remoteIds.size());
-		Assertions.assertEquals(insertedRemote10.id, retreiveRoot1.remoteIds.get(0));
-		Assertions.assertEquals(insertedRemote11.id, retreiveRoot1.remoteIds.get(1));
-
-		final TypeOneToManyRoot retreiveRoot2 = ConfigureDb.da.get(TypeOneToManyRoot.class, insertedRoot2.id);
-		Assertions.assertEquals(retreiveRoot2.otherData, insertedRoot2.otherData);
-		Assertions.assertNotNull(retreiveRoot2.remoteIds);
-		Assertions.assertEquals(1, retreiveRoot2.remoteIds.size());
-		Assertions.assertEquals(insertedRemote20.id, retreiveRoot2.remoteIds.get(0));
-
-		// Check remote are inserted and expandable
-
-		final TypeOneToManyRootExpand retreiveRootExpand1 = ConfigureDb.da.get(TypeOneToManyRootExpand.class,
-				insertedRoot.id);
-		Assertions.assertEquals(retreiveRootExpand1.otherData, insertedRoot.otherData);
-		Assertions.assertNotNull(retreiveRootExpand1.remotes);
-		Assertions.assertEquals(2, retreiveRootExpand1.remotes.size());
-		Assertions.assertEquals(insertedRemote10.id, retreiveRootExpand1.remotes.get(0).id);
-		Assertions.assertEquals(insertedRemote10.rootId, retreiveRootExpand1.remotes.get(0).rootId);
-		Assertions.assertEquals(insertedRemote10.data, retreiveRootExpand1.remotes.get(0).data);
-		Assertions.assertEquals(insertedRemote11.id, retreiveRootExpand1.remotes.get(1).id);
-		Assertions.assertEquals(insertedRemote11.rootId, retreiveRootExpand1.remotes.get(1).rootId);
-		Assertions.assertEquals(insertedRemote11.data, retreiveRootExpand1.remotes.get(1).data);
-
-		final TypeOneToManyRootExpand retreiveRootExpand2 = ConfigureDb.da.get(TypeOneToManyRootExpand.class,
-				insertedRoot2.id);
-		Assertions.assertEquals(retreiveRootExpand2.otherData, insertedRoot2.otherData);
-		Assertions.assertNotNull(retreiveRootExpand2.remotes);
-		Assertions.assertEquals(1, retreiveRootExpand2.remotes.size());
-		Assertions.assertEquals(insertedRemote20.id, retreiveRootExpand2.remotes.get(0).id);
-		Assertions.assertEquals(insertedRemote20.rootId, retreiveRootExpand2.remotes.get(0).rootId);
-		Assertions.assertEquals(insertedRemote20.data, retreiveRootExpand2.remotes.get(0).data);
-
-	}
-
 	@Order(2)
 	@Test
 	public void testParentUUID() throws Exception {

test/src/test/kar/archidata/dataAccess/model/TypeManyToManyLongRemote.java

@@ -9,8 +9,8 @@ import jakarta.persistence.FetchType;
 import jakarta.persistence.ManyToMany;
 
 @Entity
-public class TypeManyToManyRemote extends GenericData {
-	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyRoot.class, mappedBy = "remote")
+public class TypeManyToManyLongRemote extends GenericData {
+	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyLongRoot.class, mappedBy = "remote")
 	public List<Long> remoteToParent;
 	public String data;
 

test/src/test/kar/archidata/dataAccess/model/TypeManyToManyLongRoot.java

@@ -9,10 +9,10 @@ import jakarta.persistence.FetchType;
 import jakarta.persistence.ManyToMany;
 
 @Entity
-public class TypeManyToManyRoot extends GenericData {
+public class TypeManyToManyLongRoot extends GenericData {
 
 	public String otherData;
 
-	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyRemote.class)
+	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyLongRemote.class)
 	public List<Long> remote;
 }

test/src/test/kar/archidata/dataAccess/model/TypeManyToManyLongRootExpand.java

@@ -9,13 +9,13 @@ import jakarta.persistence.FetchType;
 import jakarta.persistence.ManyToMany;
 import jakarta.persistence.Table;
 
-@Table(name = "TypeManyToManyRoot")
+@Table(name = "TypeManyToManyLongRoot")
 // for Mongo
-@Entity(value = "TypeManyToManyRoot")
-public class TypeManyToManyRootExpand extends GenericData {
+@Entity(value = "TypeManyToManyLongRoot")
+public class TypeManyToManyLongRootExpand extends GenericData {
 
 	public String otherData;
 
-	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyRemote.class)
-	public List<TypeManyToManyRemote> remote;
+	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyLongRemote.class)
+	public List<TypeManyToManyLongRemote> remote;
 }

test/src/test/kar/archidata/dataAccess/model/TypeManyToManyOIDRemote.java

@@ -0,0 +1,18 @@
+package test.kar.archidata.dataAccess.model;
+
+import java.util.List;
+
+import org.bson.types.ObjectId;
+import org.kar.archidata.model.OIDGenericData;
+
+import dev.morphia.annotations.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToMany;
+
+@Entity
+public class TypeManyToManyOIDRemote extends OIDGenericData {
+	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyOIDRoot.class, mappedBy = "remote")
+	public List<ObjectId> remoteToParent;
+	public String data;
+
+}

test/src/test/kar/archidata/dataAccess/model/TypeManyToManyOIDRoot.java

@@ -0,0 +1,19 @@
+package test.kar.archidata.dataAccess.model;
+
+import java.util.List;
+
+import org.bson.types.ObjectId;
+import org.kar.archidata.model.OIDGenericData;
+
+import dev.morphia.annotations.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToMany;
+
+@Entity
+public class TypeManyToManyOIDRoot extends OIDGenericData {
+
+	public String otherData;
+
+	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyOIDRemote.class)
+	public List<ObjectId> remote;
+}

test/src/test/kar/archidata/dataAccess/model/TypeManyToManyOIDRootExpand.java

@@ -0,0 +1,21 @@
+package test.kar.archidata.dataAccess.model;
+
+import java.util.List;
+
+import org.kar.archidata.model.OIDGenericData;
+
+import dev.morphia.annotations.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToMany;
+import jakarta.persistence.Table;
+
+@Table(name = "TypeManyToManyOIDRoot")
+// for Mongo
+@Entity(value = "TypeManyToManyOIDRoot")
+public class TypeManyToManyOIDRootExpand extends OIDGenericData {
+
+	public String otherData;
+
+	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyOIDRemote.class)
+	public List<TypeManyToManyOIDRemote> remote;
+}

test/src/test/kar/archidata/dataAccess/model/TypeManyToOneLongRemote.java

@@ -5,7 +5,7 @@ import org.kar.archidata.model.GenericData;
 import dev.morphia.annotations.Entity;
 
 @Entity
-public class TypeManyToOneRemote extends GenericData {
+public class TypeManyToOneLongRemote extends GenericData {
 
 	public String data;
 

test/src/test/kar/archidata/dataAccess/model/TypeManyToOneLongRoot.java

@@ -7,11 +7,11 @@ import jakarta.persistence.Column;
 import jakarta.persistence.ManyToOne;
 
 @Entity
-public class TypeManyToOneRoot extends GenericData {
+public class TypeManyToOneLongRoot extends GenericData {
 
 	public String otherData;
 
-	@ManyToOne(targetEntity = TypeManyToOneRemote.class)
+	@ManyToOne(targetEntity = TypeManyToOneLongRemote.class)
 	@Column(nullable = false)
 	public Long remoteId;
 

test/src/test/kar/archidata/dataAccess/model/TypeManyToOneLongRootExpand.java

@@ -8,16 +8,16 @@ import jakarta.persistence.FetchType;
 import jakarta.persistence.ManyToOne;
 import jakarta.persistence.Table;
 
-@Table(name = "TypeManyToOneRoot")
+@Table(name = "TypeManyToOneLongRoot")
 //for Mongo
-@Entity(value = "TypeManyToOneRoot")
-public class TypeManyToOneRootExpand extends GenericData {
+@Entity(value = "TypeManyToOneLongRoot")
+public class TypeManyToOneLongRootExpand extends GenericData {
 
 	public String otherData;
 
-	@ManyToOne(fetch = FetchType.LAZY, targetEntity = TypeManyToOneRemote.class)
+	@ManyToOne(fetch = FetchType.LAZY, targetEntity = TypeManyToOneLongRemote.class)
 	@Column(name = "remoteId", nullable = false)
-	public TypeManyToOneRemote remote;
+	public TypeManyToOneLongRemote remote;
 
 	@Override
 	public String toString() {

test/src/test/kar/archidata/dataAccess/model/TypeManyToOneOIDRemote.java

@@ -0,0 +1,12 @@
+package test.kar.archidata.dataAccess.model;
+
+import org.kar.archidata.model.OIDGenericData;
+
+import dev.morphia.annotations.Entity;
+
+@Entity
+public class TypeManyToOneOIDRemote extends OIDGenericData {
+
+	public String data;
+
+}

test/src/test/kar/archidata/dataAccess/model/TypeManyToOneOIDRoot.java

@@ -0,0 +1,18 @@
+package test.kar.archidata.dataAccess.model;
+
+import org.bson.types.ObjectId;
+import org.kar.archidata.model.OIDGenericData;
+
+import dev.morphia.annotations.Entity;
+import jakarta.persistence.Column;
+import jakarta.persistence.ManyToOne;
+
+@Entity
+public class TypeManyToOneOIDRoot extends OIDGenericData {
+
+	public String otherData;
+
+	@ManyToOne(targetEntity = TypeManyToOneOIDRemote.class)
+	@Column(nullable = false)
+	public ObjectId remoteOid;
+}

test/src/test/kar/archidata/dataAccess/model/TypeManyToOneOIDRootExpand.java

@@ -0,0 +1,21 @@
+package test.kar.archidata.dataAccess.model;
+
+import org.kar.archidata.model.OIDGenericData;
+
+import dev.morphia.annotations.Entity;
+import jakarta.persistence.Column;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+@Table(name = "TypeManyToOneOIDRoot")
+//for Mongo
+@Entity(value = "TypeManyToOneOIDRoot")
+public class TypeManyToOneOIDRootExpand extends OIDGenericData {
+
+	public String otherData;
+
+	@ManyToOne(fetch = FetchType.LAZY, targetEntity = TypeManyToOneOIDRemote.class)
+	@Column(name = "remoteOid", nullable = false)
+	public TypeManyToOneOIDRemote remote;
+}

test/src/test/kar/archidata/dataAccess/model/TypeOneToManyLongRemote.java

@@ -7,9 +7,9 @@ import jakarta.persistence.FetchType;
 import jakarta.persistence.ManyToOne;
 
 @Entity
-public class TypeOneToManyRemote extends GenericData {
+public class TypeOneToManyLongRemote extends GenericData {
 
-	@ManyToOne(fetch = FetchType.LAZY, targetEntity = TypeOneToManyRoot.class)
+	@ManyToOne(fetch = FetchType.LAZY, targetEntity = TypeOneToManyLongRoot.class)
 	public Long rootId;
 
 	public String data;

test/src/test/kar/archidata/dataAccess/model/TypeOneToManyLongRoot.java

@@ -8,10 +8,10 @@ import dev.morphia.annotations.Entity;
 import jakarta.persistence.OneToMany;
 
 @Entity
-public class TypeOneToManyRoot extends GenericData {
+public class TypeOneToManyLongRoot extends GenericData {
 
 	public String otherData;
 
-	@OneToMany(targetEntity = TypeOneToManyRemote.class, mappedBy = "rootId")
+	@OneToMany(targetEntity = TypeOneToManyLongRemote.class, mappedBy = "rootId")
 	public List<Long> remoteIds;
 }

test/src/test/kar/archidata/dataAccess/model/TypeOneToManyLongRootExpand.java

@@ -10,10 +10,10 @@ import jakarta.persistence.Id;
 import jakarta.persistence.OneToMany;
 import jakarta.persistence.Table;
 
-@Table(name = "TypeOneToManyRoot")
+@Table(name = "TypeOneToManyLongRoot")
 //for Mongo
-@Entity(value = "TypeOneToManyRoot")
-public class TypeOneToManyRootExpand {
+@Entity(value = "TypeOneToManyLongRoot")
+public class TypeOneToManyLongRootExpand {
 
 	@Id
 	@GeneratedValue(strategy = GenerationType.IDENTITY)
@@ -22,7 +22,7 @@ public class TypeOneToManyRootExpand {
 
 	public String otherData;
 
-	@OneToMany(targetEntity = TypeOneToManyRemote.class, mappedBy = "rootId")
+	@OneToMany(targetEntity = TypeOneToManyLongRemote.class, mappedBy = "rootId")
 	@Column(nullable = false)
-	public List<TypeOneToManyRemote> remotes;
+	public List<TypeOneToManyLongRemote> remotes;
 }

test/src/test/kar/archidata/dataAccess/model/TypeOneToManyOIDRemote.java

@@ -0,0 +1,18 @@
+package test.kar.archidata.dataAccess.model;
+
+import org.bson.types.ObjectId;
+import org.kar.archidata.model.OIDGenericData;
+
+import dev.morphia.annotations.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToOne;
+
+@Entity
+public class TypeOneToManyOIDRemote extends OIDGenericData {
+
+	@ManyToOne(fetch = FetchType.LAZY, targetEntity = TypeOneToManyOIDRoot.class)
+	public ObjectId rootOid;
+
+	public String data;
+
+}

test/src/test/kar/archidata/dataAccess/model/TypeOneToManyOIDRoot.java

@@ -0,0 +1,20 @@
+package test.kar.archidata.dataAccess.model;
+
+import java.util.List;
+
+import org.bson.types.ObjectId;
+import org.kar.archidata.model.OIDGenericData;
+
+import dev.morphia.annotations.Entity;
+import jakarta.persistence.Column;
+import jakarta.persistence.OneToMany;
+
+@Entity
+public class TypeOneToManyOIDRoot extends OIDGenericData {
+
+	public String otherData;
+
+	@OneToMany(targetEntity = TypeOneToManyOIDRemote.class, mappedBy = "rootOid")
+	@Column(nullable = false)
+	public List<ObjectId> remoteIds;
+}

test/src/test/kar/archidata/dataAccess/model/TypeOneToManyOIDRootExpand.java

@@ -0,0 +1,22 @@
+package test.kar.archidata.dataAccess.model;
+
+import java.util.List;
+
+import org.kar.archidata.model.OIDGenericData;
+
+import dev.morphia.annotations.Entity;
+import jakarta.persistence.Column;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+
+@Table(name = "TypeOneToManyOIDRoot")
+//for Mongo
+@Entity(value = "TypeOneToManyOIDRoot")
+public class TypeOneToManyOIDRootExpand extends OIDGenericData {
+
+	public String otherData;
+
+	@OneToMany(targetEntity = TypeOneToManyOIDRemote.class, mappedBy = "rootOid")
+	@Column(nullable = false)
+	public List<TypeOneToManyOIDRemote> remotes;
+}

version.txt

@@ -1 +1 @@
-0.25.0
+0.25.4