From f31d976da9f19bee9339d309c6fdd9a05eab29f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jaros=C5=82aw=20Kaczmarski?= Date: Thu, 18 Dec 2014 13:09:12 +0100 Subject: [PATCH 1/2] Implement OrientOperations for Document (OrientDocumentTemplate).(not finished) --- .../data/orient/core/OrientObjectOperations.java | 6 ++++++ .../data/orient/core/OrientOperations.java | 11 +++++------ 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/src/main/java/org/springframework/data/orient/core/OrientObjectOperations.java b/src/main/java/org/springframework/data/orient/core/OrientObjectOperations.java index d3e32da..d6a1660 100644 --- a/src/main/java/org/springframework/data/orient/core/OrientObjectOperations.java +++ b/src/main/java/org/springframework/data/orient/core/OrientObjectOperations.java @@ -1,6 +1,12 @@ package org.springframework.data.orient.core; +import com.orientechnologies.orient.core.db.ODatabase; +import com.orientechnologies.orient.core.record.ORecordInternal; + public interface OrientObjectOperations extends OrientOperations { RET detachAll(Object iPojo, boolean returnNonProxiedInstance); + + ODatabase delete(ORecordInternal iRecord); + } diff --git a/src/main/java/org/springframework/data/orient/core/OrientOperations.java b/src/main/java/org/springframework/data/orient/core/OrientOperations.java index 24cd13d..730d8de 100644 --- a/src/main/java/org/springframework/data/orient/core/OrientOperations.java +++ b/src/main/java/org/springframework/data/orient/core/OrientOperations.java @@ -7,6 +7,7 @@ import com.orientechnologies.orient.core.db.ODatabase; import com.orientechnologies.orient.core.db.object.ODatabaseObject; import com.orientechnologies.orient.core.id.ORID; +import com.orientechnologies.orient.core.id.ORecordId; import com.orientechnologies.orient.core.query.OQuery; import com.orientechnologies.orient.core.record.ORecordInternal; import com.orientechnologies.orient.core.sql.OCommandSQL; @@ -36,12 +37,6 @@ public interface OrientOperations { RET queryForObject(OSQLQuery query, DetachMode detachMode, Object... values); > RET query(OQuery query, DetachMode detachMode, Object... values); - - ODatabase delete(ORecordInternal iRecord); - - ODatabaseObject delete(ORID iRID); - - ODatabaseObject delete(Object iPojo); OObjectIteratorClass browseClass(Class iClusterClass); @@ -87,4 +82,8 @@ public interface OrientOperations { RET command(OCommandSQL command, Object... args); RET command(String sql, Object... args); + + Object delete(ORID iRID); + + Object delete(Object iObject); } From a8511973e7da351f58cbf1154bb9aa9e268c762e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jaros=C5=82aw=20Kaczmarski?= Date: Thu, 18 Dec 2014 13:09:46 +0100 Subject: [PATCH 2/2] OrientDocumentTemplate --- .../orient/core/OrientDocumentTemplate.java | 241 ++++++++++++++++++ 1 file changed, 241 insertions(+) create mode 100644 src/main/java/org/springframework/data/orient/core/OrientDocumentTemplate.java diff --git a/src/main/java/org/springframework/data/orient/core/OrientDocumentTemplate.java b/src/main/java/org/springframework/data/orient/core/OrientDocumentTemplate.java new file mode 100644 index 0000000..2a7a10f --- /dev/null +++ b/src/main/java/org/springframework/data/orient/core/OrientDocumentTemplate.java @@ -0,0 +1,241 @@ +package org.springframework.data.orient.core; + +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import org.springframework.data.orient.object.repository.DetachMode; +import org.springframework.orm.orient.OrientDocumentDatabaseFactory; + +import com.orientechnologies.common.exception.OException; +import com.orientechnologies.orient.core.annotation.OId; +import com.orientechnologies.orient.core.db.ODatabase; +import com.orientechnologies.orient.core.db.document.ODatabaseDocument; +import com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx; +import com.orientechnologies.orient.core.id.ORID; +import com.orientechnologies.orient.core.id.ORecordId; +import com.orientechnologies.orient.core.metadata.schema.OClass; +import com.orientechnologies.orient.core.query.OQuery; +import com.orientechnologies.orient.core.record.ORecord; +import com.orientechnologies.orient.core.record.ORecordAbstract; +import com.orientechnologies.orient.core.record.impl.ODocument; +import com.orientechnologies.orient.core.sql.OCommandSQL; +import com.orientechnologies.orient.core.sql.query.OSQLQuery; +import com.orientechnologies.orient.core.version.ORecordVersion; +import com.orientechnologies.orient.object.iterator.OObjectIteratorClass; + +public class OrientDocumentTemplate implements OrientOperations { + + private final OrientDocumentDatabaseFactory dbf; + + private Set defaultClusters; + + public OrientDocumentTemplate(OrientDocumentDatabaseFactory dbf) { + this.dbf = dbf; + } + + public ODatabaseDocumentTx database() { + return dbf.db(); + } + + @Override + public RET load(ORID recordId) { + return database().load(recordId); + } + + @Override + public RET load(String recordId) { + return load(new ORecordId(recordId)); + } + + @Override + public RET save(Object entity) { + return database().save((ODocument) entity); + } + + @Override + public RET save(Object entity, String cluster) { + return database().save((ODocument) entity, cluster); + } + + @Override + public Long count(OSQLQuery query, Object... values) { + return ((ODocument) database().query(query, values).get(0)).field("count"); + } + + @Override + public long countClass(String iClassName) { + return database().countClass(iClassName); + } + + @Override + public long countClass(Class iClass) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public long countClusterElements(String iClusterName) { + return database().countClusterElements(iClusterName); + } + + @Override + public > RET query(OQuery query, Object... values) { + return database().query(query, values); + } + + @Override + public RET queryForObject(OSQLQuery query, DetachMode detachMode, Object... values) { + List list = query(query, values); + return list.isEmpty() ? null : list.get(0); + } + + @Override + public > RET query(OQuery query, DetachMode detachMode, Object... values) { + // TODO Auto-generated method stub + return null; + } + + @Override + public OObjectIteratorClass browseClass(Class iClusterClass) { + // TODO Auto-generated method stub + return null; + } + + @Override + public int getDefaultClusterId(Class domainClass) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public String getClusterNameById(int iClusterId) { + return database().getClusterNameById(iClusterId); + } + + @Override + public int getClusterIdByName(String clusterName, Class aClass) { + OClass oClass = database().getMetadata().getSchema().getClass(aClass); + for(int clusterId : oClass.getClusterIds()){ + if(getClusterNameById(clusterId).equals(clusterName)){ + return clusterId; + } + } + + throw new OException("Cluster " + clusterName + " not found"); + } + + @Override + public String getClusterNameByRid(String rid) { + return getClusterNameById(new ORecordId(rid).getClusterId()); + } + + @Override + public List getClusterNamesByClass(Class entityClass, boolean includeDefault) { + int[] clusterIds = database().getMetadata().getSchema().getClass(entityClass).getClusterIds(); + int defaultCluster = getDefaultClusterId(entityClass); + + List clusters = new ArrayList<>(clusterIds.length); + for (int clusterId : clusterIds) { + if (includeDefault || clusterId != defaultCluster) { + clusters.add(getClusterNameById(clusterId)); + } + } + + return clusters; + } + + @Override + public boolean isDefault(String clusterName) { + loadDefaultClusters(); + return defaultClusters.contains(clusterName); + } + + private void loadDefaultClusters() { + if (defaultClusters == null) { + synchronized (this) { + if (defaultClusters == null) { + defaultClusters = new HashSet<>(); + for (OClass oClass : database().getMetadata().getSchema().getClasses()) { + String defaultCluster = getClusterNameById(oClass.getDefaultClusterId()); + defaultClusters.add(defaultCluster); + } + } + } + } + } + + @Override + public boolean existsClass(Class clazz) { + return existsClass(clazz.getSimpleName()); + } + + @Override + public boolean existsClass(String className) { + return database().getMetadata().getSchema().existsClass(className); + } + + @Override + public String getRid(Object entity) { + Class clazz = entity.getClass(); + while(clazz != Object.class){ + for(Field field : clazz.getDeclaredFields()){ + OId ridAnnotation = field.getAnnotation(OId.class); + if(ridAnnotation != null){ + field.setAccessible(true); + try{ + Object rid = field.get(entity); + if(rid == null) { + Method method = clazz.getDeclaredMethod(getterName(field.getName())); + rid = method.invoke(entity); + } + return rid != null ? rid.toString() : null; + } catch (IllegalAccessException | IllegalArgumentException + | NoSuchMethodException | InvocationTargetException ex){ + throw new RuntimeException(ex); + } + } + } + clazz = clazz.getSuperclass(); + } + return null; + } + + private String getterName(String propertyName) { + return "get" + propertyName.substring(0, 1).toUpperCase() + + propertyName.substring(1).toLowerCase(); + } + + @Override + public void registerEntityClass(Class domainClass) { + + } + + @Override + public RET command(OCommandSQL command, Object... args) { + return database().command(command).execute(args); + } + + @Override + public RET command(String sql, Object... args) { + return command(new OCommandSQL(sql), args); + } + + @Override + public ODatabaseDocument delete(ORID iRID) { + return database().delete(iRID); + } + + @Override + public ODatabaseDocument delete(Object iRecord) { + return database().delete((ORecordAbstract) iRecord); + } + + public ODatabase delete(ORID iRID, ORecordVersion iVersion) { + return database().delete(iRID, iVersion); + } +}