use of com.orientechnologies.orient.object.db.OObjectDatabaseTx in project orientdb by orientechnologies.
the class ObjectDetachingTestSchemaFull method testDetachAllNonProxied.
@Test(dependsOnMethods = "testNonProxiedAttachDetach")
public void testDetachAllNonProxied() {
JavaAttachDetachTestClass attach = database.newInstance(JavaAttachDetachTestClass.class);
attach.text = "test";
attach.numberSimple = 12345;
attach.doubleSimple = 12.34d;
attach.floatSimple = 123.45f;
attach.longSimple = 12345678l;
attach.byteSimple = (byte) 1;
attach.flagSimple = true;
attach.enumeration = EnumTest.ENUM1;
Child c = database.newInstance(Child.class);
c.setName("Jesus");
attach.children = new HashMap<String, Child>();
attach.children.put("first", c);
attach.enumList = new ArrayList<EnumTest>();
attach.enumList.add(EnumTest.ENUM1);
attach.enumList.add(EnumTest.ENUM2);
attach.enumSet = new HashSet<EnumTest>();
attach.enumSet.add(EnumTest.ENUM1);
attach.enumSet.add(EnumTest.ENUM3);
attach.enumMap = new HashMap<String, EnumTest>();
attach.enumMap.put("1", EnumTest.ENUM2);
attach.enumMap.put("2", EnumTest.ENUM3);
database.attach(attach);
ODocument doc = database.getRecordByUserObject(attach, false);
Assert.assertEquals(doc.field("text"), "test");
Assert.assertEquals(doc.field("numberSimple"), 12345);
Assert.assertEquals(doc.field("doubleSimple"), 12.34d);
Assert.assertEquals(doc.field("floatSimple"), 123.45f);
Assert.assertEquals(doc.field("longSimple"), 12345678l);
Assert.assertEquals(doc.field("byteSimple"), (byte) 1);
Assert.assertEquals(doc.field("flagSimple"), true);
Assert.assertEquals(doc.field("enumeration"), EnumTest.ENUM1.toString());
Assert.assertTrue(doc.field("children") instanceof Map<?, ?>);
Assert.assertTrue(((Map<?, ?>) doc.field("children")).get("first") instanceof ODocument);
Assert.assertEquals(((ODocument) ((Map<?, ?>) doc.field("children")).get("first")).field("name"), "Jesus");
Assert.assertEquals(((List<?>) doc.field("enumList")).size(), 2);
Assert.assertEquals(((List<?>) doc.field("enumList")).get(0), EnumTest.ENUM1.toString());
Assert.assertEquals(((List<?>) doc.field("enumList")).get(1), EnumTest.ENUM2.toString());
Assert.assertEquals(((Set<?>) doc.field("enumSet")).size(), 2);
Iterator<?> it = ((Set<?>) doc.field("enumSet")).iterator();
Assert.assertEquals(it.next(), EnumTest.ENUM1.toString());
Assert.assertEquals(it.next(), EnumTest.ENUM3.toString());
Assert.assertEquals(((Map<?, ?>) doc.field("enumMap")).size(), 2);
Assert.assertEquals(((Map<?, ?>) doc.field("enumMap")).get("1"), EnumTest.ENUM2.toString());
Assert.assertEquals(((Map<?, ?>) doc.field("enumMap")).get("2"), EnumTest.ENUM3.toString());
JavaAttachDetachTestClass savedJavaObj = database.save(attach);
ORecordId id = (ORecordId) database.getRecordByUserObject(savedJavaObj, false).getIdentity();
database.close();
database = new OObjectDatabaseTx(url).open("admin", "admin");
JavaAttachDetachTestClass loadedJavaObj = (JavaAttachDetachTestClass) database.load(id);
loadedJavaObj = database.detachAll(loadedJavaObj, true);
Assert.assertTrue(!(loadedJavaObj instanceof Proxy));
Assert.assertEquals(loadedJavaObj.text, "test");
Assert.assertEquals(loadedJavaObj.numberSimple, 12345);
Assert.assertEquals(loadedJavaObj.doubleSimple, 12.34d);
Assert.assertEquals(loadedJavaObj.floatSimple, 123.45f);
Assert.assertEquals(loadedJavaObj.longSimple, 12345678l);
Assert.assertEquals(loadedJavaObj.byteSimple, (byte) 1);
Assert.assertEquals(loadedJavaObj.flagSimple, true);
Assert.assertEquals(loadedJavaObj.enumeration, EnumTest.ENUM1);
Assert.assertEquals(loadedJavaObj.enumList.size(), 2);
Assert.assertEquals(loadedJavaObj.enumList.get(0), EnumTest.ENUM1);
Assert.assertEquals(loadedJavaObj.enumList.get(1), EnumTest.ENUM2);
Assert.assertTrue(loadedJavaObj.children instanceof Map<?, ?>);
Assert.assertTrue(loadedJavaObj.children.get("first") instanceof Child);
Assert.assertTrue(!(loadedJavaObj.children.get("first") instanceof Proxy));
Assert.assertEquals(loadedJavaObj.children.get("first").getName(), "Jesus");
Assert.assertEquals(loadedJavaObj.enumSet.size(), 2);
it = loadedJavaObj.enumSet.iterator();
EnumTest next = (EnumTest) it.next();
Assert.assertTrue(next.equals(EnumTest.ENUM1) || next.equals(EnumTest.ENUM3));
next = (EnumTest) it.next();
Assert.assertTrue(next.equals(EnumTest.ENUM1) || next.equals(EnumTest.ENUM3));
Assert.assertEquals(loadedJavaObj.enumMap.size(), 2);
Assert.assertEquals(loadedJavaObj.enumMap.get("1"), EnumTest.ENUM2);
Assert.assertEquals(loadedJavaObj.enumMap.get("2"), EnumTest.ENUM3);
}
use of com.orientechnologies.orient.object.db.OObjectDatabaseTx in project orientdb by orientechnologies.
the class LocalCreateObjectSpeedTest method init.
@Override
public void init() {
Orient.instance().getProfiler().startRecording();
database = new OObjectDatabaseTx(System.getProperty("url")).open("admin", "admin");
database.getEntityManager().registerEntityClass(Account.class);
database.declareIntent(new OIntentMassiveInsert());
database.begin(TXTYPE.NOTX);
}
use of com.orientechnologies.orient.object.db.OObjectDatabaseTx in project orientdb by orientechnologies.
the class OObjectEntitySerializer method registerClass.
/**
* Registers the class informations that will be used in serialization, deserialization and lazy loading of it. If already
* registered does nothing.
*
* @param iClass
* :- the Class<?> to register
* @param forceReload whether or not to force the reload of the schema before registering
*/
@SuppressWarnings("unchecked")
public static synchronized void registerClass(final Class<?> iClass, boolean forceReload) {
if (!ODatabaseRecordThreadLocal.INSTANCE.isDefined() || ODatabaseRecordThreadLocal.INSTANCE.get().isClosed())
return;
final OObjectEntitySerializedSchema serializedSchema = getCurrentSerializedSchema();
if (serializedSchema == null)
return;
if (Proxy.class.isAssignableFrom(iClass) || iClass.isEnum() || OReflectionHelper.isJavaType(iClass) || iClass.isAnonymousClass() || serializedSchema.classes.contains(iClass)) {
return;
}
boolean reloadSchema = false;
boolean automaticSchemaGeneration = false;
final ODatabaseDocumentInternal db = ODatabaseRecordThreadLocal.INSTANCE.get();
final OSchema oSchema = db.getMetadata().getSchema();
if (forceReload) {
oSchema.reload();
}
if (!oSchema.existsClass(iClass.getSimpleName())) {
if (Modifier.isAbstract(iClass.getModifiers()))
oSchema.createAbstractClass(iClass.getSimpleName());
else
oSchema.createClass(iClass.getSimpleName());
reloadSchema = true;
if (db.getDatabaseOwner() instanceof OObjectDatabaseTx)
automaticSchemaGeneration = ((OObjectDatabaseTx) db.getDatabaseOwner()).isAutomaticSchemaGeneration();
}
for (Class<?> currentClass = iClass; currentClass != Object.class; ) {
if (!serializedSchema.classes.contains(currentClass)) {
serializedSchema.classes.add(currentClass);
Class<?> fieldType;
for (Field f : currentClass.getDeclaredFields()) {
final String fieldName = f.getName();
final int fieldModifier = f.getModifiers();
boolean transientField = false;
if (Modifier.isStatic(fieldModifier) || Modifier.isFinal(fieldModifier) || Modifier.isNative(fieldModifier) || Modifier.isTransient(fieldModifier)) {
List<String> classTransientFields = serializedSchema.transientFields.get(currentClass);
if (classTransientFields == null)
classTransientFields = new ArrayList<String>();
classTransientFields.add(fieldName);
serializedSchema.transientFields.put(currentClass, classTransientFields);
transientField = true;
}
if (fieldName.equals("this$0")) {
List<String> classTransientFields = serializedSchema.transientFields.get(currentClass);
if (classTransientFields == null)
classTransientFields = new ArrayList<String>();
classTransientFields.add(fieldName);
serializedSchema.transientFields.put(currentClass, classTransientFields);
transientField = true;
}
if (OObjectSerializerHelper.jpaTransientClass != null) {
Annotation ann = f.getAnnotation(OObjectSerializerHelper.jpaTransientClass);
if (ann != null) {
// @Transient DEFINED
List<String> classTransientFields = serializedSchema.transientFields.get(currentClass);
if (classTransientFields == null)
classTransientFields = new ArrayList<String>();
classTransientFields.add(fieldName);
serializedSchema.transientFields.put(currentClass, classTransientFields);
transientField = true;
}
}
if (!transientField) {
List<String> allClassFields = serializedSchema.allFields.get(currentClass);
if (allClassFields == null)
allClassFields = new ArrayList<String>();
allClassFields.add(fieldName);
serializedSchema.allFields.put(currentClass, allClassFields);
}
if (OObjectSerializerHelper.jpaOneToOneClass != null) {
Annotation ann = f.getAnnotation(OObjectSerializerHelper.jpaOneToOneClass);
if (ann != null) {
// @OneToOne DEFINED
OneToOne oneToOne = ((OneToOne) ann);
if (checkCascadeDelete(oneToOne)) {
addCascadeDeleteField(currentClass, fieldName);
}
if (checkFetchLazy(oneToOne)) {
addFetchLazyField(currentClass, fieldName);
}
}
}
if (OObjectSerializerHelper.jpaOneToManyClass != null) {
Annotation ann = f.getAnnotation(OObjectSerializerHelper.jpaOneToManyClass);
if (ann != null) {
// @OneToMany DEFINED
OneToMany oneToMany = ((OneToMany) ann);
if (checkCascadeDelete(oneToMany)) {
addCascadeDeleteField(currentClass, fieldName);
}
}
}
if (OObjectSerializerHelper.jpaManyToManyClass != null) {
Annotation ann = f.getAnnotation(OObjectSerializerHelper.jpaManyToManyClass);
if (ann != null) {
// @OneToMany DEFINED
ManyToMany manyToMany = ((ManyToMany) ann);
if (checkCascadeDelete(manyToMany)) {
addCascadeDeleteField(currentClass, fieldName);
}
}
}
fieldType = f.getType();
if (Collection.class.isAssignableFrom(fieldType) || fieldType.isArray() || Map.class.isAssignableFrom(fieldType)) {
fieldType = OReflectionHelper.getGenericMultivalueType(f);
}
if (isToSerialize(fieldType)) {
Map<Field, Class<?>> serializeClass = serializedSchema.serializedFields.get(currentClass);
if (serializeClass == null)
serializeClass = new HashMap<Field, Class<?>>();
serializeClass.put(f, fieldType);
serializedSchema.serializedFields.put(currentClass, serializeClass);
}
// CHECK FOR DIRECT-BINDING
boolean directBinding = true;
if (f.getAnnotation(OAccess.class) == null || f.getAnnotation(OAccess.class).value() == OAccess.OAccessType.PROPERTY)
directBinding = true;
else // JPA 2+ AVAILABLE?
if (OObjectSerializerHelper.jpaAccessClass != null) {
Annotation ann = f.getAnnotation(OObjectSerializerHelper.jpaAccessClass);
if (ann != null) {
directBinding = true;
}
}
if (directBinding) {
List<String> classDirectAccessFields = serializedSchema.directAccessFields.get(currentClass);
if (classDirectAccessFields == null)
classDirectAccessFields = new ArrayList<String>();
classDirectAccessFields.add(fieldName);
serializedSchema.directAccessFields.put(currentClass, classDirectAccessFields);
}
if (f.getAnnotation(ODocumentInstance.class) != null)
// BOUND DOCUMENT ON IT
serializedSchema.boundDocumentFields.put(currentClass, f);
boolean idFound = false;
if (f.getAnnotation(OId.class) != null) {
// RECORD ID
serializedSchema.fieldIds.put(currentClass, f);
idFound = true;
} else // JPA 1+ AVAILABLE?
if (OObjectSerializerHelper.jpaIdClass != null && f.getAnnotation(OObjectSerializerHelper.jpaIdClass) != null) {
// RECORD ID
serializedSchema.fieldIds.put(currentClass, f);
idFound = true;
}
if (idFound) {
// CHECK FOR TYPE
if (fieldType.isPrimitive())
OLogManager.instance().warn(OObjectSerializerHelper.class, "Field '%s' cannot be a literal to manage the Record Id", f.toString());
else if (!ORID.class.isAssignableFrom(fieldType) && fieldType != String.class && fieldType != Object.class && !Number.class.isAssignableFrom(fieldType))
OLogManager.instance().warn(OObjectSerializerHelper.class, "Field '%s' cannot be managed as type: %s", f.toString(), fieldType);
}
boolean vFound = false;
if (f.getAnnotation(OVersion.class) != null) {
// RECORD ID
serializedSchema.fieldVersions.put(currentClass, f);
vFound = true;
} else // JPA 1+ AVAILABLE?
if (OObjectSerializerHelper.jpaVersionClass != null && f.getAnnotation(OObjectSerializerHelper.jpaVersionClass) != null) {
// RECORD ID
serializedSchema.fieldVersions.put(currentClass, f);
vFound = true;
}
if (vFound) {
// CHECK FOR TYPE
if (fieldType.isPrimitive())
OLogManager.instance().warn(OObjectSerializerHelper.class, "Field '%s' cannot be a literal to manage the Version", f.toString());
else if (fieldType != String.class && fieldType != Object.class && !Number.class.isAssignableFrom(fieldType))
OLogManager.instance().warn(OObjectSerializerHelper.class, "Field '%s' cannot be managed as type: %s", f.toString(), fieldType);
}
// JPA 1+ AVAILABLE?
if (OObjectSerializerHelper.jpaEmbeddedClass != null && f.getAnnotation(OObjectSerializerHelper.jpaEmbeddedClass) != null) {
List<String> classEmbeddedFields = serializedSchema.embeddedFields.get(currentClass);
if (classEmbeddedFields == null)
classEmbeddedFields = new ArrayList<String>();
classEmbeddedFields.add(fieldName);
serializedSchema.embeddedFields.put(currentClass, classEmbeddedFields);
}
}
registerCallbacks(currentClass);
}
if (automaticSchemaGeneration && !currentClass.equals(Object.class) && !currentClass.equals(ODocument.class)) {
((OSchemaProxyObject) db.getDatabaseOwner().getMetadata().getSchema()).generateSchema(currentClass, db);
}
String iClassName = currentClass.getSimpleName();
currentClass = currentClass.getSuperclass();
if (currentClass == null || currentClass.equals(ODocument.class))
// POJO EXTENDS ODOCUMENT: SPECIAL CASE: AVOID TO CONSIDER
// ODOCUMENT FIELDS
currentClass = Object.class;
if (!currentClass.equals(Object.class)) {
OClass oSuperClass;
OClass currentOClass = oSchema.getClass(iClassName);
if (!oSchema.existsClass(currentClass.getSimpleName())) {
OSchema schema = oSchema;
if (Modifier.isAbstract(currentClass.getModifiers())) {
oSuperClass = schema.createAbstractClass(currentClass.getSimpleName());
} else {
oSuperClass = schema.createClass(currentClass.getSimpleName());
}
reloadSchema = true;
} else {
oSuperClass = oSchema.getClass(currentClass.getSimpleName());
}
if (!currentOClass.getSuperClasses().contains(oSuperClass)) {
currentOClass.setSuperClasses(Arrays.asList(oSuperClass));
reloadSchema = true;
}
}
}
if (reloadSchema) {
oSchema.save();
oSchema.reload();
}
}
use of com.orientechnologies.orient.object.db.OObjectDatabaseTx in project orientdb by orientechnologies.
the class OSchemaProxyObject method synchronizeSchema.
/**
* Checks if all registered entities has schema generated, if not it generates it
*/
public synchronized void synchronizeSchema() {
OObjectDatabaseTx database = ((OObjectDatabaseTx) ODatabaseRecordThreadLocal.INSTANCE.get().getDatabaseOwner());
Collection<Class<?>> registeredEntities = database.getEntityManager().getRegisteredEntities();
boolean automaticSchemaGeneration = database.isAutomaticSchemaGeneration();
boolean reloadSchema = false;
for (Class<?> iClass : registeredEntities) {
if (Proxy.class.isAssignableFrom(iClass) || iClass.isEnum() || OReflectionHelper.isJavaType(iClass) || iClass.isAnonymousClass())
return;
if (!database.getMetadata().getSchema().existsClass(iClass.getSimpleName())) {
database.getMetadata().getSchema().createClass(iClass.getSimpleName());
reloadSchema = true;
}
for (Class<?> currentClass = iClass; currentClass != Object.class; ) {
if (automaticSchemaGeneration && !currentClass.equals(Object.class) && !currentClass.equals(ODocument.class)) {
((OSchemaProxyObject) database.getMetadata().getSchema()).generateSchema(currentClass, database.getUnderlying());
}
String iClassName = currentClass.getSimpleName();
currentClass = currentClass.getSuperclass();
if (currentClass == null || currentClass.equals(ODocument.class))
// POJO EXTENDS ODOCUMENT: SPECIAL CASE: AVOID TO CONSIDER
// ODOCUMENT FIELDS
currentClass = Object.class;
if (database != null && !database.isClosed() && !currentClass.equals(Object.class)) {
OClass oSuperClass;
OClass currentOClass = database.getMetadata().getSchema().getClass(iClassName);
if (!database.getMetadata().getSchema().existsClass(currentClass.getSimpleName())) {
oSuperClass = database.getMetadata().getSchema().createClass(currentClass.getSimpleName());
reloadSchema = true;
} else {
oSuperClass = database.getMetadata().getSchema().getClass(currentClass.getSimpleName());
reloadSchema = true;
}
if (!currentOClass.getSuperClasses().contains(oSuperClass)) {
currentOClass.setSuperClasses(Arrays.asList(oSuperClass));
reloadSchema = true;
}
}
}
}
if (database != null && !database.isClosed() && reloadSchema) {
database.getMetadata().getSchema().save();
database.getMetadata().getSchema().reload();
}
}
use of com.orientechnologies.orient.object.db.OObjectDatabaseTx in project orientdb by orientechnologies.
the class OObjectProxyMethodHandlerTest method setUp.
@BeforeClass
protected void setUp() throws Exception {
databaseTx = new OObjectDatabaseTx("memory:OObjectEnumLazyListTest");
databaseTx.create();
databaseTx.getEntityManager().registerEntityClass(EntityWithDifferentFieldTypes.class);
databaseTx.getEntityManager().registerEntityClass(EmbeddedType1.class);
databaseTx.getEntityManager().registerEntityClass(EmbeddedType2.class);
databaseTx.getEntityManager().registerEntityClass(EntityWithEmbeddedFields.class);
fieldsAndThereDefaultValue = new HashMap<String, Object>();
fieldsAndThereDefaultValue.put("byteField", Byte.valueOf("0"));
fieldsAndThereDefaultValue.put("shortField", Short.valueOf("0"));
fieldsAndThereDefaultValue.put("intField", 0);
fieldsAndThereDefaultValue.put("longField", 0L);
fieldsAndThereDefaultValue.put("floatField", 0.0f);
fieldsAndThereDefaultValue.put("doubleField", 0.0d);
fieldsAndThereDefaultValue.put("stringField", null);
fieldsAndThereDefaultValue.put("booleanField", false);
fieldsAndThereDefaultValue.put("objectField", null);
}
Aggregations