diff --git a/pom.xml b/pom.xml index 9133818..227991c 100644 --- a/pom.xml +++ b/pom.xml @@ -60,17 +60,17 @@ https://oss.sonatype.org/content/repositories/snapshots/ - 1.7.9 + 1.7.10 1.1.2 2.0-rc1 1.8.4 - 4.1.3.RELEASE + 4.1.4.RELEASE 1.9.1.RELEASE 1.2.0.RELEASE - 3.5.0 - 1.3.4 + 3.5.1 + 1.4.1 4.12 - 6.8.8 + 6.8.13 2.4.0 diff --git a/spring-boot-orientdb-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/orient/OrientAutoConfiguration.java b/spring-boot-orientdb-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/orient/OrientAutoConfiguration.java index ad8b6bf..87e0577 100644 --- a/spring-boot-orientdb-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/orient/OrientAutoConfiguration.java +++ b/spring-boot-orientdb-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/orient/OrientAutoConfiguration.java @@ -1,5 +1,6 @@ package org.springframework.boot.autoconfigure.orient; +import com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx; import com.orientechnologies.orient.object.db.OObjectDatabaseTx; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; @@ -10,8 +11,11 @@ import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.orient.commons.core.OrientDatabaseFactory; +import org.springframework.data.orient.commons.core.OrientOperations; import org.springframework.data.orient.commons.core.OrientTransactionManager; import org.springframework.data.orient.document.OrientDocumentDatabaseFactory; +import org.springframework.data.orient.document.OrientDocumentOperations; +import org.springframework.data.orient.document.OrientDocumentTemplate; import org.springframework.data.orient.object.OrientObjectDatabaseFactory; import org.springframework.data.orient.object.OrientObjectOperations; import org.springframework.data.orient.object.OrientObjectTemplate; @@ -61,6 +65,13 @@ public OrientObjectTemplate objectTemplate(OrientObjectDatabaseFactory factory) return new OrientObjectTemplate(factory); } + @Bean + @ConditionalOnClass(ODatabaseDocumentTx.class) + @ConditionalOnMissingBean(OrientDocumentOperations.class) + public OrientDocumentTemplate documentTemplate(OrientDocumentDatabaseFactory factory) { + return new OrientDocumentTemplate(factory); + } + @Bean @ConditionalOnWebApplication @ConditionalOnClass(OObjectDatabaseTx.class) diff --git a/spring-data-orientdb-commons/pom.xml b/spring-data-orientdb-commons/pom.xml index 2e1e1b0..1cba99b 100644 --- a/spring-data-orientdb-commons/pom.xml +++ b/spring-data-orientdb-commons/pom.xml @@ -59,11 +59,6 @@ com.orientechnologies orientdb-client - - - com.orientechnologies - orientdb-object - diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/AbstractOrientDatabaseFactory.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/AbstractOrientDatabaseFactory.java index bb19012..b0f611d 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/AbstractOrientDatabaseFactory.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/AbstractOrientDatabaseFactory.java @@ -1,29 +1,31 @@ package org.springframework.data.orient.commons.core; +import com.orientechnologies.orient.core.db.ODatabase; import com.orientechnologies.orient.core.db.ODatabaseInternal; import com.orientechnologies.orient.core.db.ODatabaseRecordThreadLocal; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.springframework.util.Assert; import javax.annotation.PostConstruct; +import static org.springframework.util.Assert.notNull; + /** * A base factory for creating {@link com.orientechnologies.orient.core.db.ODatabase} objects. * * @author Dzmitry_Naskou * @param the type of database to handle */ -public abstract class AbstractOrientDatabaseFactory> implements OrientDatabaseFactory { +public abstract class AbstractOrientDatabaseFactory implements OrientDatabaseFactory { /** The logger. */ private static Logger log = LoggerFactory.getLogger(AbstractOrientDatabaseFactory.class); /** The username. */ - protected String username; + protected String username = DEFAULT_USERNAME; /** The password. */ - protected String password; + protected String password = DEFAULT_PASSWORD; /** The min pool size. */ protected int minPoolSize = DEFAULT_MIN_POOL_SIZE; @@ -31,15 +33,21 @@ public abstract class AbstractOrientDatabaseFactory db = newDatabase(); + if(autoCreate==null) { + autoCreate = !getUrl().startsWith("remote:"); + } + + ODatabase db = newDatabase(); createDatabase(db); createPool(); } @@ -51,25 +59,31 @@ public void init() { * * @return the o database complex */ - public abstract ODatabaseInternal openDatabase(); + public abstract ODatabase openDatabase(); protected abstract ODatabaseInternal newDatabase(); - public ODatabaseInternal db() { - ODatabaseInternal db; + public ODatabase db() { + ODatabase db; if(!ODatabaseRecordThreadLocal.INSTANCE.isDefined()) { db = openDatabase(); log.debug("acquire db from pool {}", db.hashCode()); } else { - db = ODatabaseRecordThreadLocal.INSTANCE.get().getDatabaseOwner(); - log.debug("use existing db {}", db.hashCode()); + db = (ODatabase)ODatabaseRecordThreadLocal.INSTANCE.get().getDatabaseOwner(); + + if(db.isClosed()) { + db = openDatabase(); + log.debug("re-opened db {}", db.hashCode()); + } else { + log.debug("use existing db {}", db.hashCode()); + } } return db; } - protected void createDatabase(ODatabaseInternal db) { - if (!getUrl().startsWith("remote:")) { + protected void createDatabase(ODatabase db) { + if (autoCreate) { if (!db.exists()) { db.create(); db.close(); @@ -166,4 +180,12 @@ public int getMaxPoolSize() { public void setMaxPoolSize(int maxPoolSize) { this.maxPoolSize = maxPoolSize; } + + public Boolean getAutoCreate() { + return autoCreate; + } + + public void setAutoCreate(Boolean autoCreate) { + this.autoCreate = autoCreate; + } } diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/AbstractOrientOperations.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/AbstractOrientOperations.java new file mode 100644 index 0000000..d7da32b --- /dev/null +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/AbstractOrientOperations.java @@ -0,0 +1,619 @@ +package org.springframework.data.orient.commons.core; + +import com.orientechnologies.common.exception.OException; +import com.orientechnologies.orient.core.cache.OLocalRecordCache; +import com.orientechnologies.orient.core.command.OCommandOutputListener; +import com.orientechnologies.orient.core.command.OCommandRequest; +import com.orientechnologies.orient.core.db.ODatabase; +import com.orientechnologies.orient.core.db.ODatabaseListener; +import com.orientechnologies.orient.core.db.record.OIdentifiable; +import com.orientechnologies.orient.core.dictionary.ODictionary; +import com.orientechnologies.orient.core.exception.OTransactionException; +import com.orientechnologies.orient.core.hook.ORecordHook; +import com.orientechnologies.orient.core.id.ORID; +import com.orientechnologies.orient.core.id.ORecordId; +import com.orientechnologies.orient.core.intent.OIntent; +import com.orientechnologies.orient.core.metadata.OMetadata; +import com.orientechnologies.orient.core.metadata.schema.OClass; +import com.orientechnologies.orient.core.metadata.security.OSecurityUser; +import com.orientechnologies.orient.core.metadata.security.OUser; +import com.orientechnologies.orient.core.query.OQuery; +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.sql.query.OSQLSynchQuery; +import com.orientechnologies.orient.core.storage.ORecordCallback; +import com.orientechnologies.orient.core.storage.ORecordMetadata; +import com.orientechnologies.orient.core.storage.OStorage; +import com.orientechnologies.orient.core.tx.OTransaction; +import com.orientechnologies.orient.core.version.ORecordVersion; +import org.springframework.data.orient.commons.repository.DetachMode; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.*; +import java.util.concurrent.Callable; + +public abstract class AbstractOrientOperations implements OrientOperations { + //private static final Logger logger = LoggerFactory.getLogger(AbstractOrientOperations.class); + + protected final OrientDatabaseFactory dbf; + + protected Set defaultClusters; + + protected AbstractOrientOperations(OrientDatabaseFactory dbf) { + this.dbf = dbf; + } + + @Override + public String getName() { + return dbf.db().getName(); + } + + @Override + public String getURL() { + return dbf.db().getURL(); + } + + @Override + public ODatabase database() { + return dbf.db(); + } + + @Override + public Object setProperty(String name, Object value) { + return dbf.db().setProperty(name, value); + } + + @Override + public Object getProperty(String name) { + return dbf.db().getProperty(name); + } + + @Override + public Iterator> getProperties() { + return dbf.db().getProperties(); + } + + @Override + public Object get(ODatabase.ATTRIBUTES attribute) { + return dbf.db().get(attribute); + } + + @Override + public > DB set(ODatabase.ATTRIBUTES attribute, Object value) { + return dbf.db().set(attribute, value); + } + + @Override + public void registerListener(ODatabaseListener listener) { + dbf.db().registerListener(listener); + } + + @Override + public void unregisterListener(ODatabaseListener listener) { + dbf.db().unregisterListener(listener); + } + + @Override + public Map getHooks() { + return dbf.db().getHooks(); + } + + @Override + public > DB registerHook(ORecordHook hook) { + return dbf.db().registerHook(hook); + } + + @Override + public > DB registerHook(ORecordHook hook, ORecordHook.HOOK_POSITION position) { + return dbf.db().registerHook(hook, position); + } + + @Override + public > DB unregisterHook(ORecordHook hook) { + return dbf.db().unregisterHook(hook); + } + + @Override + public ORecordHook.RESULT callbackHooks(ORecordHook.TYPE type, OIdentifiable id) { + return dbf.db().callbackHooks(type, id); + } + + @Override + public void backup(OutputStream out, Map options, Callable callable, OCommandOutputListener listener, int compressionLevel, int bufferSize) throws IOException { + dbf.db().backup(out, options, callable, listener, compressionLevel, bufferSize); + } + + @Override + public void restore(InputStream in, Map options, Callable callable, OCommandOutputListener listener) throws IOException { + dbf.db().restore(in, options, callable, listener); + } + + @Override + public String getType() { + return dbf.db().getType(); + } + + @Override + public long getSize() { + return dbf.db().getSize(); + } + + @Override + public void freeze(boolean throwException) { + dbf.db().freeze(throwException); + } + + @Override + public void freeze() { + dbf.db().freeze(); + } + + @Override + public void release() { + dbf.db().release(); + } + + @Override + public OMetadata getMetadata() { + return dbf.db().getMetadata(); + } + + @Override + public ORecordMetadata getRecordMetadata(ORID rid) { + return dbf.db().getRecordMetadata(rid); + } + + + @Override + public ODictionary getDictionary() { + return dbf.db().getDictionary(); + } + + @Override + public boolean declareIntent(OIntent intent) { + return dbf.db().declareIntent(intent); + } + + @Override + public boolean isMVCC() { + return dbf.db().isMVCC(); + } + + @Override + public > DB setMVCC(boolean mvcc) { + return dbf.db().setMVCC(mvcc); + } + + @Override + public boolean isClosed() { + return dbf.db().isClosed(); + } + + @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 : dbf.db().getMetadata().getSchema().getClasses()) { + String defaultCluster = getClusterNameById(oClass.getDefaultClusterId()); + defaultClusters.add(defaultCluster); + } + } + } + } + } + + @Override + public void reload() { + dbf.db().reload(); + } + + @Override + public T reload(T entity, String fetchPlan, boolean ignoreCache) { + return dbf.db().reload(entity, fetchPlan, ignoreCache); + } + + @Override + public ODatabase.STATUS getStatus() { + return dbf.db().getStatus(); + } + + @Override + public > DB setStatus(ODatabase.STATUS status) { + return dbf.db().setStatus(status); + } + + @Override + public OTransaction getTransaction() { + return dbf.db().getTransaction(); + } + + @Override + public ODatabase begin() { + return dbf.db().begin(); + } + + @Override + public ODatabase begin(OTransaction.TXTYPE type) { + return dbf.db().begin(type); + } + + @Override + public ODatabase begin(OTransaction tx) { + return dbf.db().begin(tx); + } + + @Override + public ODatabase commit() { + return dbf.db().commit(); + } + + @Override + public ODatabase commit(boolean force) throws OTransactionException { + return dbf.db().commit(force); + } + + @Override + public ODatabase rollback() { + return dbf.db().rollback(); + } + + @Override + public ODatabase rollback(boolean force) throws OTransactionException { + return dbf.db().rollback(force); + } + + @Override + public OLocalRecordCache getLevel2Cache() { + return dbf.db().getLocalCache(); + } + + @Override + public T newInstance() { + return dbf.db().newInstance(); + } + + @Override + public T load(ORID recordId) { + return dbf.db().load(recordId); + } + + @Override + public T load(String recordId) { + return load(new ORecordId(recordId)); + } + + public T load(T entity) { + return dbf.db().load(entity); + } + + @Override + public T load(T entity, String fetchPlan) { + return dbf.db().load(entity, fetchPlan); + } + + @Override + public T load(T entity, String fetchPlan, boolean ignoreCache) { + return dbf.db().load(entity, fetchPlan, ignoreCache); + } + + @Override + public T load(ORID recordId, String fetchPlan) { + return dbf.db().load(recordId, fetchPlan); + } + + @Override + public T load(ORID recordId, String fetchPlan, boolean ignoreCache) { + return dbf.db().load(recordId, fetchPlan, ignoreCache); + } + + @Override + public T load(T entity, String fetchPlan, boolean ignoreCache, boolean loadTombstone, OStorage.LOCKING_STRATEGY lockingStrategy) { + return dbf.db().load(entity, fetchPlan, ignoreCache, loadTombstone, lockingStrategy); + } + + @Override + public T load(ORID recordId, String fetchPlan, boolean ignoreCache, boolean loadTombstone, OStorage.LOCKING_STRATEGY lockingStrategy) { + return dbf.db().load(recordId, fetchPlan, ignoreCache, loadTombstone, lockingStrategy); + } + + @Override + public S save(S entity) { + return dbf.db().save(entity); + } + + @Override + public S save(S entity, String cluster) { + return dbf.db().save(entity, cluster); + } + + @Override + public S save(S entity, ODatabase.OPERATION_MODE mode, boolean forceCreate, ORecordCallback recordCallback, ORecordCallback recordUpdatedCallback) { + return dbf.db().save(entity, mode, forceCreate, recordCallback, recordUpdatedCallback); + } + + @Override + public long countClass(Class clazz) { + return count(new OSQLSynchQuery("select count(*) from " + clazz.getSimpleName())); + } + + @Override + public long countClass(String className) { + return count(new OSQLSynchQuery("select count(*) from " + className)); + } + + @Override + public long count(OSQLQuery query, Object... args) { + return ((ODocument) dbf.db().query(query, args).get(0)).field("count"); + } + + @Override + public long countClusterElements(String clusterName) { + return dbf.db().countClusterElements(clusterName); + } + + @Override + public long countClusterElements(int clusterId) { + return dbf.db().countClusterElements(clusterId); + } + + @Override + public long countClusterElements(int[] clusterIds) { + return dbf.db().countClusterElements(clusterIds); + } + + @Override + public long countClusterElements(int iClusterId, boolean countTombstones) { + return dbf.db().countClusterElements(iClusterId, countTombstones); + } + + @Override + public long countClusterElements(int[] iClusterIds, boolean countTombstones) { + return dbf.db().countClusterElements(iClusterIds, countTombstones); + } + + @Override + public int getClusters() { + return dbf.db().getClusters(); + } + + @Override + public boolean existsCluster(String clusterName) { + return dbf.db().existsCluster(clusterName); + } + + @Override + public Collection getClusterNames() { + return dbf.db().getClusterNames(); + } + + @Override + public int getClusterIdByName(String clusterName, Class clazz) { + OClass oClass = dbf.db().getMetadata().getSchema().getClass(clazz); + 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 clazz, boolean showDefault) { + int[] clusterIds = dbf.db().getMetadata().getSchema().getClass(clazz).getClusterIds(); + int defaultCluster = getDefaultClusterId(clazz); + + List clusters = new ArrayList<>(clusterIds.length); + for (int clusterId : clusterIds) { + if (showDefault || clusterId != defaultCluster) { + clusters.add(getClusterNameById(clusterId)); + } + } + + return clusters; + } + + @Override + public int getDefaultClusterId(Class domainClass) { + return dbf.db().getMetadata().getSchema().getClass(domainClass).getDefaultClusterId(); + } + + @Override + public long getClusterRecordSizeById(int clusterId) { + return dbf.db().getClusterRecordSizeById(clusterId); + } + + @Override + public long getClusterRecordSizeByName(String clusterName) { + return dbf.db().getClusterRecordSizeByName(clusterName); + } + + @Override + public int addCluster(String type, String clusterName, String location, String dataSegmentName, Object... params) { + return dbf.db().addCluster(type, clusterName, location, dataSegmentName, params); + } + + @Override + public int addCluster(String type, String clusterName, int requestedId, String location, String dataSegmentName, Object... params) { + return dbf.db().addCluster(type, clusterName, requestedId, location, dataSegmentName, params); + } + + @Override + public int addCluster(String clusterName, Object... params) { + return dbf.db().addCluster(clusterName, params); + } + + @Override + public int addCluster(String clusterName) { + return dbf.db().addCluster(clusterName); + } + + @Override + public void freezeCluster(int iClusterId, boolean throwException) { + dbf.db().freezeCluster(iClusterId, throwException); + } + + @Override + public void freezeCluster(int iClusterId) { + dbf.db().freezeCluster(iClusterId); + } + + @Override + public void releaseCluster(int iClusterId) { + dbf.db().releaseCluster(iClusterId); + } + + @Override + public ODatabase delete(ORID recordId) { + return dbf.db().delete(recordId); + } + + @Override + public ODatabase delete(T entity) { + return dbf.db().delete(entity); + } + + @Override + public ODatabase delete(ORID rid, ORecordVersion version) { + return dbf.db().delete(rid, version); + } + + @Override + public int getDefaultClusterId() { + return dbf.db().getDefaultClusterId(); + } + + @Override + public String getClusterNameById(int clusterId) { + return dbf.db().getClusterNameById(clusterId); + } + + @Override + public int getClusterIdByName(String clusterName) { + return dbf.db().getClusterIdByName(clusterName); + } + + @Override + public boolean existsClass(Class clazz) { + return existsClass(clazz.getSimpleName()); + } + + @Override + public boolean existsClass(String className) { + return dbf.db().getMetadata().getSchema().existsClass(className); + } + + @Override + public OSecurityUser getUser() { + return dbf.db().getUser(); + } + + @Override + public void setUser(OUser user) { + dbf.db().setUser(user); + } + + @Override + @SuppressWarnings("unchecked") + public > RET detach(RET entities) { + List result = new ArrayList<>(entities.size()); + + for (Object entity : entities) { + result.add(detach(entity)); + } + + return (RET)result; + } + + @Override + @SuppressWarnings("unchecked") + public > RET detachAll(RET entities) { + List result = new ArrayList<>(entities.size()); + + for (Object entity : entities) { + result.add(detachAll(entity)); + } + + return (RET)result; + } + + @Override + public > RET query(OQuery query, Object... args) { + return dbf.db().query(query, args); + } + + @Override + public > RET query(OQuery query, DetachMode detachMode, Object... args) { + RET result = query(query, args); + + switch (detachMode) { + case ENTITY: + return detach(result); + case ALL: + return detachAll(result); + case NONE: + } + + return result; + } + + @Override + @SuppressWarnings("unchecked") + public RET queryForObject(OSQLQuery query, DetachMode detachMode, Object... args) { + RET result = queryForObject(query, args); + + switch (detachMode) { + case ENTITY: + return detach(result); + case ALL: + return detachAll(result); + case NONE: + } + + return result; + } + + @Override + @SuppressWarnings("unchecked") + public RET queryForObject(OSQLQuery query, Object... args) { + return (RET)query(query, args).get(0); + } + + @Override + public RET command(OCommandRequest command) { + return dbf.db().command(command); + } + + @Override + public RET command(OCommandSQL command, Object... args) { + return dbf.db().command(command).execute(args); + } + + @Override + public RET command(String sql, Object... args) { + return dbf.db().command(new OCommandSQL(sql)).execute(args); + } + + public boolean equals(Object other) { + return dbf.db().equals(other); + } + + public String toString() { + return dbf.db().toString(); + } +} diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientDatabaseFactory.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientDatabaseFactory.java index 7015239..7eebf11 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientDatabaseFactory.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientDatabaseFactory.java @@ -1,16 +1,23 @@ package org.springframework.data.orient.commons.core; import com.orientechnologies.orient.core.db.ODatabase; -import com.orientechnologies.orient.core.db.ODatabaseInternal; -public interface OrientDatabaseFactory> { +public interface OrientDatabaseFactory { + /** Default database username. */ + public static final String DEFAULT_USERNAME = "admin"; + + /** Default database password. */ + public static final String DEFAULT_PASSWORD = "admin"; + /** Default minimum pool size. */ public static final int DEFAULT_MIN_POOL_SIZE = 1; /** Default maximum pool size. */ public static final int DEFAULT_MAX_POOL_SIZE = 20; - ODatabaseInternal openDatabase(); + public ODatabase db(); + + ODatabase openDatabase(); String getUrl(); diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientOperations.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientOperations.java index feeef00..75d1c98 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientOperations.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientOperations.java @@ -1,64 +1,207 @@ package org.springframework.data.orient.commons.core; +import com.orientechnologies.orient.core.cache.OLocalRecordCache; +import com.orientechnologies.orient.core.command.OCommandOutputListener; +import com.orientechnologies.orient.core.command.OCommandRequest; import com.orientechnologies.orient.core.db.ODatabase; -import com.orientechnologies.orient.core.db.object.ODatabaseObject; +import com.orientechnologies.orient.core.db.ODatabaseListener; +import com.orientechnologies.orient.core.db.record.OIdentifiable; +import com.orientechnologies.orient.core.dictionary.ODictionary; +import com.orientechnologies.orient.core.exception.OTransactionException; +import com.orientechnologies.orient.core.hook.ORecordHook; import com.orientechnologies.orient.core.id.ORID; +import com.orientechnologies.orient.core.intent.OIntent; +import com.orientechnologies.orient.core.metadata.OMetadata; +import com.orientechnologies.orient.core.metadata.security.OSecurityUser; +import com.orientechnologies.orient.core.metadata.security.OUser; import com.orientechnologies.orient.core.query.OQuery; -import com.orientechnologies.orient.core.record.ORecordInternal; import com.orientechnologies.orient.core.sql.OCommandSQL; import com.orientechnologies.orient.core.sql.query.OSQLQuery; -import com.orientechnologies.orient.object.iterator.OObjectIteratorClass; +import com.orientechnologies.orient.core.storage.ORecordCallback; +import com.orientechnologies.orient.core.storage.ORecordMetadata; +import com.orientechnologies.orient.core.storage.OStorage; +import com.orientechnologies.orient.core.tx.OTransaction; +import com.orientechnologies.orient.core.version.ORecordVersion; import org.springframework.data.orient.commons.repository.DetachMode; -import java.util.List; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.*; +import java.util.concurrent.Callable; -public interface OrientOperations { +public interface OrientOperations { - RET load(ORID recordId); - - RET load(String recordId); - - RET save(Object entity); - - RET save(Object entity, String cluster); - - Long count(OSQLQuery query, Object... values); - - long countClass(String iClassName); - - long countClass(Class iClass); + String getName(); + + String getURL(); + + ODatabase database(); + + Object setProperty(String name, Object value); + + Object getProperty(String name); + + Iterator> getProperties(); + + Object get(ODatabase.ATTRIBUTES attribute); + + > DB set(ODatabase.ATTRIBUTES attribute, Object value); + + public void registerListener(ODatabaseListener listener); + + public void unregisterListener(ODatabaseListener listener); + + Map getHooks(); + + > DB registerHook(ORecordHook hook); + + > DB registerHook(ORecordHook hook, ORecordHook.HOOK_POSITION position); + + > DB unregisterHook(ORecordHook hook); + + ORecordHook.RESULT callbackHooks(ORecordHook.TYPE type, OIdentifiable id); + + void backup(OutputStream out, Map options, Callable callable, OCommandOutputListener listener, int compressionLevel, int bufferSize) throws IOException; + + void restore(InputStream in, Map options, Callable callable, OCommandOutputListener listener) throws IOException; + + String getType(); + + long getSize(); + + void freeze(boolean throwException); + + void freeze(); + + void release(); + + OMetadata getMetadata(); + + ORecordMetadata getRecordMetadata(ORID rid); + + ODictionary getDictionary(); + + boolean declareIntent(OIntent intent); + + + public boolean isMVCC(); + + public > DB setMVCC(boolean mvcc); + + boolean isClosed(); + + void reload(); + + T reload(T entity, String fetchPlan, boolean ignoreCache); + + ODatabase.STATUS getStatus(); + + > DB setStatus(ODatabase.STATUS status); + + OTransaction getTransaction(); + + ODatabase begin(); + + ODatabase begin(OTransaction.TXTYPE type); + + ODatabase begin(OTransaction tx); + + ODatabase commit(); + + ODatabase commit(boolean force) throws OTransactionException; + + ODatabase rollback(); + + ODatabase rollback(boolean force) throws OTransactionException; + + OLocalRecordCache getLevel2Cache(); + + T newInstance(); - long countClusterElements(String iClusterName); + T load(ORID recordId); - > RET query(OQuery query, Object... values); + T load(String recordId); + + T load(T entity); + + T load(T entity, String fetchPlan); + + T load(T entity, String fetchPlan, boolean ignoreCache); - // TODO: move this to object module - @Deprecated - RET queryForObject(OSQLQuery query, DetachMode detachMode, Object... values); + T load(ORID recordId, String fetchPlan); - // TODO: move this to object module - @Deprecated - > RET query(OQuery query, DetachMode detachMode, Object... values); + T load(ORID recordId, String fetchPlan, boolean ignoreCache); + + T load(T entity, String fetchPlan, boolean ignoreCache, boolean loadTombstone, OStorage.LOCKING_STRATEGY lockingStrategy); + + T load(ORID recordId, String fetchPlan, boolean ignoreCache, boolean loadTombstone, OStorage.LOCKING_STRATEGY lockingStrategy); + + S save(S entity); - ODatabase delete(ORecordInternal iRecord); + S save(S entity, String cluster); + + S save(S entity, ODatabase.OPERATION_MODE mode, boolean forceCreate, ORecordCallback recordCallback, ORecordCallback recordUpdatedCallback); + + long countClass(String className); + + long countClass(Class clazz); - ODatabaseObject delete(ORID iRID); + long count(OSQLQuery query, Object... args); - ODatabaseObject delete(Object iPojo); + long countClusterElements(String clusterName); - // TODO: move this to object module - @Deprecated - OObjectIteratorClass browseClass(Class iClusterClass); + long countClusterElements(int clusterId); + + long countClusterElements(int[] clusterIds); + + long countClusterElements(int iClusterId, boolean countTombstones); + + long countClusterElements(int[] iClusterIds, boolean countTombstones); + + int getClusters(); + + boolean existsCluster(String iClusterName); + + Collection getClusterNames(); + + ODatabase delete(ORID recordId); + + ODatabase delete(T entity); + + ODatabase delete(ORID rid, ORecordVersion version); + + int getDefaultClusterId(); int getDefaultClusterId(Class domainClass); - String getClusterNameById(int iClusterId); + String getClusterNameById(int clusterId); + + int getClusterIdByName(String clusterName); - int getClusterIdByName(String clusterName, Class aClass); + int getClusterIdByName(String clusterName, Class clazz); String getClusterNameByRid(String rid); - List getClusterNamesByClass(Class entityClass, boolean includeDefault); + List getClusterNamesByClass(Class clazz, boolean includeDefault); + + long getClusterRecordSizeById(int clusterId); + + long getClusterRecordSizeByName(String clusterName); + + int addCluster(String type, String clusterName, String location, String dataSegmentName, Object... params); + + int addCluster(String type, String clusterName, int requestedId, String location, String dataSegmentName, Object... params); + + int addCluster(String clusterName, Object... params); + + int addCluster(String clusterName); + + public void freezeCluster(int iClusterId, boolean throwException); + + public void freezeCluster(int iClusterId); + + public void releaseCluster(int iClusterId); boolean isDefault(String clusterName); @@ -85,10 +228,30 @@ public interface OrientOperations { * @param entity Orient Entity * @return orient row ID or null if it is to found */ - String getRid(Object entity); - - void registerEntityClass(Class domainClass); - + String getRid(T entity); + + OSecurityUser getUser(); + + void setUser(OUser user); + + > RET detach(RET entities); + + > RET detachAll(RET list); + + RET detach(RET entity); + + RET detachAll(RET entity); + + > RET query(OQuery query, Object... args); + + > RET query(OQuery query, DetachMode detachMode, Object... args); + + RET queryForObject(OSQLQuery query, Object... args); + + RET queryForObject(OSQLQuery query, DetachMode detachMode, Object... args); + + RET command(OCommandRequest command); + RET command(OCommandSQL command, Object... args); RET command(String sql, Object... args); diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientTransaction.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientTransaction.java index ae43082..89f6253 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientTransaction.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientTransaction.java @@ -1,5 +1,6 @@ package org.springframework.data.orient.commons.core; +import com.orientechnologies.orient.core.db.ODatabase; import com.orientechnologies.orient.core.db.ODatabaseInternal; import com.orientechnologies.orient.core.tx.OTransaction; @@ -14,7 +15,7 @@ public class OrientTransaction { private OTransaction tx; /** The database. */ - private ODatabaseInternal database; + private ODatabase database; public OTransaction getTx() { return tx; @@ -24,11 +25,11 @@ public void setTx(OTransaction tx) { this.tx = tx; } - public ODatabaseInternal getDatabase() { + public ODatabase getDatabase() { return database; } - public void setDatabase(ODatabaseInternal database) { + public void setDatabase(ODatabase database) { this.database = database; } } diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientTransactionManager.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientTransactionManager.java index 7f2c276..d1cae4b 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientTransactionManager.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/core/OrientTransactionManager.java @@ -27,14 +27,14 @@ public class OrientTransactionManager extends AbstractPlatformTransactionManager private static Logger log = LoggerFactory.getLogger(OrientTransactionManager.class); /** The database factory. */ - private OrientDatabaseFactory> dbf; + private OrientDatabaseFactory dbf; /** * Instantiates a new {@link OrientTransactionManager}. * * @param dbf the dbf */ - public OrientTransactionManager(OrientDatabaseFactory> dbf) { + public OrientTransactionManager(OrientDatabaseFactory dbf) { super(); this.dbf = dbf; } @@ -46,7 +46,7 @@ public OrientTransactionManager(OrientDatabaseFactory> db protected Object doGetTransaction() throws TransactionException { OrientTransaction tx = new OrientTransaction(); - ODatabaseInternal db = (ODatabaseInternal) TransactionSynchronizationManager.getResource(getResourceFactory()); + ODatabase db = (ODatabase) TransactionSynchronizationManager.getResource(getResourceFactory()); if (db != null) { tx.setDatabase(db); @@ -73,7 +73,7 @@ protected boolean isExistingTransaction(Object transaction) throws TransactionEx protected void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException { OrientTransaction tx = (OrientTransaction) transaction; - ODatabaseInternal db = tx.getDatabase(); + ODatabase db = tx.getDatabase(); if (db == null || db.isClosed()) { db = dbf.openDatabase(); tx.setDatabase(db); @@ -91,7 +91,7 @@ protected void doBegin(Object transaction, TransactionDefinition definition) thr @Override protected void doCommit(DefaultTransactionStatus status) throws TransactionException { OrientTransaction tx = (OrientTransaction) status.getTransaction(); - ODatabaseInternal db = tx.getDatabase(); + ODatabase db = tx.getDatabase(); log.debug("committing transaction, db.hashCode() = {}", db.hashCode()); @@ -104,7 +104,7 @@ protected void doCommit(DefaultTransactionStatus status) throws TransactionExcep @Override protected void doRollback(DefaultTransactionStatus status) throws TransactionException { OrientTransaction tx = (OrientTransaction) status.getTransaction(); - ODatabaseInternal db = tx.getDatabase(); + ODatabase db = tx.getDatabase(); log.debug("rolling back transaction, db.hashCode() = {}", db.hashCode()); @@ -140,9 +140,8 @@ protected void doCleanupAfterCompletion(Object transaction) { @Override protected Object doSuspend(Object transaction) throws TransactionException { OrientTransaction tx = (OrientTransaction) transaction; - ODatabaseInternal db = tx.getDatabase(); - - return db; + + return tx.getDatabase(); } /* (non-Javadoc) @@ -151,7 +150,7 @@ protected Object doSuspend(Object transaction) throws TransactionException { @Override protected void doResume(Object transaction, Object suspendedResources) throws TransactionException { OrientTransaction tx = (OrientTransaction) transaction; - ODatabaseInternal db = tx.getDatabase(); + ODatabase db = tx.getDatabase(); if (!db.isClosed()) { db.close(); @@ -172,20 +171,19 @@ public Object getResourceFactory() { /** * Gets the database factory for the database managed by this transaction manager. - * + * * @return the database */ - public OrientDatabaseFactory> getDatabaseFactory() { + public OrientDatabaseFactory getDatabaseFactory() { return dbf; } /** * Sets the database factory for the database managed by this transaction manager. - * + * * @param databaseFactory the database to set */ - public void setDatabaseManager(AbstractOrientDatabaseFactory> databaseFactory) { + public void setDatabaseFactory(OrientDatabaseFactory databaseFactory) { this.dbf = databaseFactory; } } - diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/AbstractOrientQuery.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/AbstractOrientQuery.java index 854e422..3208274 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/AbstractOrientQuery.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/AbstractOrientQuery.java @@ -65,7 +65,7 @@ protected Object doExecute(OrientQueryExecution execution, Object[] values) { * @return the OSQL query */ @SuppressWarnings("rawtypes") - protected OSQLQuery createQuery(Object[] values) { + protected OSQLQuery createQuery(Object[] values) { return applyFetchPlan(doCreateQuery(values)); } @@ -76,7 +76,7 @@ protected OSQLQuery createQuery(Object[] values) { * @return the OSQL query */ @SuppressWarnings("rawtypes") - protected OSQLQuery createCountQuery(Object[] values) { + protected OSQLQuery createCountQuery(Object[] values) { return doCreateCountQuery(values); } @@ -87,7 +87,7 @@ protected OSQLQuery createCountQuery(Object[] values) { * @return the OSQL query */ @SuppressWarnings("rawtypes") - protected abstract OSQLQuery doCreateQuery(Object[] values); + protected abstract OSQLQuery doCreateQuery(Object[] values); /** * Do create count query for specific source. @@ -96,7 +96,7 @@ protected OSQLQuery createCountQuery(Object[] values) { * @return the OSQL query */ @SuppressWarnings("rawtypes") - protected abstract OSQLQuery doCreateCountQuery(Object[] values); + protected abstract OSQLQuery doCreateCountQuery(Object[] values); /** * Gets the execution for query. @@ -127,7 +127,7 @@ protected OrientQueryExecution getExecution() { protected abstract boolean isCountQuery(); @SuppressWarnings("rawtypes") - private OSQLQuery applyFetchPlan(OSQLQuery query) { + private OSQLQuery applyFetchPlan(OSQLQuery query) { String fetchPlan = method.getFetchPlan(); if (fetchPlan != null) { diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/OrientQueryExecution.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/OrientQueryExecution.java index 8a6c4d0..34439b8 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/OrientQueryExecution.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/OrientQueryExecution.java @@ -36,8 +36,6 @@ public OrientQueryExecution(OrientOperations template, OrientParameters paramete * @param values the parameters values * @return the result */ - // TODO: move this to object module - @Deprecated public Object execute(AbstractOrientQuery query, DetachMode mode, Object[] values) { return doExecute(query, mode, values); } @@ -49,8 +47,6 @@ public Object execute(AbstractOrientQuery query, DetachMode mode, Object[] value * @param values the parameters values * @return the result */ - // TODO: move this to object module - @Deprecated protected abstract Object doExecute(AbstractOrientQuery query, DetachMode mode, Object[] values); /** @@ -73,8 +69,7 @@ public CollectionExecution(OrientOperations template, OrientParameters parameter * @see org.springframework.data.orient.repository.object.query.OrientQueryExecution#doExecute(org.springframework.data.orient.repository.object.query.AbstractOrientQuery, java.lang.Object[]) */ @Override - // TODO: move this to object module - @Deprecated + @SuppressWarnings("unchecked") protected Object doExecute(AbstractOrientQuery query, DetachMode mode, Object[] values) { return operations.query(query.createQuery(values), mode, prepareParameters(parameters, values)); } @@ -100,8 +95,6 @@ public SingleEntityExecution(OrientOperations template, OrientParameters paramet * @see org.springframework.data.orient.repository.object.query.OrientQueryExecution#doExecute(org.springframework.data.orient.repository.object.query.AbstractOrientQuery, java.lang.Object[]) */ @Override - // TODO: move this to object module - @Deprecated protected Object doExecute(AbstractOrientQuery query, DetachMode mode, Object[] values) { return operations.queryForObject(query.createQuery(values), mode, prepareParameters(parameters, values)); } @@ -127,8 +120,7 @@ public CountExecution(OrientOperations template, OrientParameters parameters) { * @see org.springframework.data.orient.repository.object.query.OrientQueryExecution#doExecute(org.springframework.data.orient.repository.object.query.AbstractOrientQuery, java.lang.Object[]) */ @Override - // TODO: move this to object module - @Deprecated + @SuppressWarnings("unchecked") protected Object doExecute(AbstractOrientQuery query, DetachMode mode, Object[] values) { return operations.count(query.createQuery(values), prepareParameters(parameters, values)); } @@ -155,8 +147,7 @@ public PagedExecution(OrientOperations template, OrientParameters parameters) { * @see org.springframework.data.orient.repository.object.query.OrientQueryExecution#doExecute(org.springframework.data.orient.repository.object.query.AbstractOrientQuery, java.lang.Object[]) */ @Override - // TODO: move this to object module - @Deprecated + @SuppressWarnings("unchecked") protected Object doExecute(AbstractOrientQuery query, DetachMode mode, Object[] values) { OrientParameterAccessor accessor = new OrientParametersParameterAccessor(parameters, values); @@ -174,13 +165,13 @@ protected Object doExecute(AbstractOrientQuery query, DetachMode mode, Object[] content = Collections.emptyList(); } - return new PageImpl(content, pageable, total); + return new PageImpl<>(content, pageable, total); } } - Object[] prepareParameters(OrientParameters parameters, Object[] values) { + protected Object[] prepareParameters(OrientParameters parameters, Object[] values) { int index = 0; - List params = new ArrayList(); + List params = new ArrayList<>(); for (OrientParameter parameter : parameters) { if (parameter.isBindable()) { diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/PartTreeOrientQuery.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/PartTreeOrientQuery.java index 014eba3..3d54db3 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/PartTreeOrientQuery.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/PartTreeOrientQuery.java @@ -43,7 +43,7 @@ public PartTreeOrientQuery(OrientQueryMethod method, OrientOperations operations */ @Override @SuppressWarnings("rawtypes") - protected OSQLQuery doCreateQuery(Object[] values) { + protected OSQLQuery doCreateQuery(Object[] values) { OrientParameterAccessor accessor = new OrientParametersParameterAccessor(parameters, values); OrientQueryCreator creator = new OrientQueryCreator(tree, method, accessor); @@ -56,7 +56,7 @@ protected OSQLQuery doCreateQuery(Object[] values) { */ @Override @SuppressWarnings("rawtypes") - protected OSQLQuery doCreateCountQuery(Object[] values) { + protected OSQLQuery doCreateCountQuery(Object[] values) { OrientParameterAccessor accessor = new OrientParametersParameterAccessor(parameters, values); OrientQueryCreator creator = new OrientCountQueryCreator(tree, method, accessor); diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/StringBasedOrientQuery.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/StringBasedOrientQuery.java index d457115..847bdcf 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/StringBasedOrientQuery.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/query/StringBasedOrientQuery.java @@ -19,7 +19,7 @@ public StringBasedOrientQuery(String query, OrientQueryMethod method, OrientOper @Override @SuppressWarnings("rawtypes") - protected OSQLQuery doCreateQuery(Object[] values) { + protected OSQLQuery doCreateQuery(Object[] values) { OrientParameterAccessor accessor = new OrientParametersParameterAccessor(getQueryMethod().getParameters(), values); String sortedQuery = QueryUtils.applySorting(queryString, accessor.getSort()); @@ -28,7 +28,7 @@ protected OSQLQuery doCreateQuery(Object[] values) { @Override @SuppressWarnings("rawtypes") - protected OSQLQuery doCreateCountQuery(Object[] values) { + protected OSQLQuery doCreateCountQuery(Object[] values) { return new OSQLSynchQuery(queryString); } diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/ClusteredOrientStrategy.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/ClusteredOrientStrategy.java index 3daae51..292dca1 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/ClusteredOrientStrategy.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/ClusteredOrientStrategy.java @@ -5,7 +5,7 @@ public class ClusteredOrientStrategy implements OrientStrategy { - private final OrientOperations operations; + private final OrientOperations operations; private final String cluster; diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/SimpleOrientRepository.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/SimpleOrientRepository.java index 6ad646c..eadb786 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/SimpleOrientRepository.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/SimpleOrientRepository.java @@ -32,7 +32,7 @@ public class SimpleOrientRepository implements OrientRepository { /** The orient operations. */ - protected final OrientOperations operations; + protected final OrientOperations operations; /** The domain class. */ protected final Class domainClass; @@ -255,7 +255,7 @@ public void delete(Iterable entities) { @Transactional(readOnly = false) public void deleteAll() { for (T entity : findAll()) { - operations.delete(entity); + delete(entity); } } @@ -265,7 +265,7 @@ public void deleteAll() { @Override public void deleteAll(String cluster) { for (T entity : findAll(cluster)) { - operations.delete(entity); + delete(entity); } } @@ -275,7 +275,7 @@ public void deleteAll(String cluster) { @Override public void deleteAll(Class domainClass) { for (T entity : findAll(domainClass)) { - operations.delete(entity); + delete(entity); } } @@ -341,7 +341,7 @@ private OSQLQuery getQuery(String source, Sort sort) { /** * Creates the query for the given {@link org.springframework.data.domain.Sort}. * - * @param sort the sort + * @param pageable the pageable * @return the query */ private OSQLQuery getQuery(Pageable pageable) { diff --git a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/SimpleOrientStrategy.java b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/SimpleOrientStrategy.java index ab028ba..e4a2a81 100644 --- a/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/SimpleOrientStrategy.java +++ b/spring-data-orientdb-commons/src/main/java/org/springframework/data/orient/commons/repository/support/SimpleOrientStrategy.java @@ -5,7 +5,7 @@ public class SimpleOrientStrategy implements OrientStrategy { - private final OrientOperations operations; + private final OrientOperations operations; private final Class domainClass; diff --git a/spring-data-orientdb-document/src/main/java/org/springframework/data/orient/document/OrientDocumentDatabaseFactory.java b/spring-data-orientdb-document/src/main/java/org/springframework/data/orient/document/OrientDocumentDatabaseFactory.java index 490eca3..f1a767e 100644 --- a/spring-data-orientdb-document/src/main/java/org/springframework/data/orient/document/OrientDocumentDatabaseFactory.java +++ b/spring-data-orientdb-document/src/main/java/org/springframework/data/orient/document/OrientDocumentDatabaseFactory.java @@ -2,6 +2,8 @@ import com.orientechnologies.orient.core.db.OPartitionedDatabasePool; import com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx; +import com.orientechnologies.orient.core.record.ORecord; +import com.orientechnologies.orient.core.record.impl.ODocument; import org.springframework.data.orient.commons.core.AbstractOrientDatabaseFactory; /** @@ -10,7 +12,7 @@ * @author Dzmitry_Naskou * @see com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx */ -public class OrientDocumentDatabaseFactory extends AbstractOrientDatabaseFactory { +public class OrientDocumentDatabaseFactory extends AbstractOrientDatabaseFactory { private OPartitionedDatabasePool pool; diff --git a/spring-data-orientdb-document/src/main/java/org/springframework/data/orient/document/OrientDocumentOperations.java b/spring-data-orientdb-document/src/main/java/org/springframework/data/orient/document/OrientDocumentOperations.java new file mode 100644 index 0000000..1b3adf7 --- /dev/null +++ b/spring-data-orientdb-document/src/main/java/org/springframework/data/orient/document/OrientDocumentOperations.java @@ -0,0 +1,9 @@ +package org.springframework.data.orient.document; + +import com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx; +import com.orientechnologies.orient.core.record.ORecord; +import org.springframework.data.orient.commons.core.OrientOperations; + +public interface OrientDocumentOperations extends OrientOperations { + ODatabaseDocumentTx getDocumentDatabase(); +} diff --git a/spring-data-orientdb-document/src/main/java/org/springframework/data/orient/document/OrientDocumentTemplate.java b/spring-data-orientdb-document/src/main/java/org/springframework/data/orient/document/OrientDocumentTemplate.java index e36174d..4790669 100644 --- a/spring-data-orientdb-document/src/main/java/org/springframework/data/orient/document/OrientDocumentTemplate.java +++ b/spring-data-orientdb-document/src/main/java/org/springframework/data/orient/document/OrientDocumentTemplate.java @@ -1,156 +1,36 @@ package org.springframework.data.orient.document; -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.query.OQuery; -import com.orientechnologies.orient.core.record.ORecordInternal; -import com.orientechnologies.orient.core.sql.OCommandSQL; -import com.orientechnologies.orient.core.sql.query.OSQLQuery; -import com.orientechnologies.orient.object.iterator.OObjectIteratorClass; -import org.springframework.data.orient.commons.core.OrientOperations; -import org.springframework.data.orient.commons.repository.DetachMode; +import com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx; +import com.orientechnologies.orient.core.record.ORecord; +import org.springframework.data.orient.commons.core.AbstractOrientOperations; import org.springframework.transaction.annotation.Transactional; -import java.util.List; - @Transactional -public class OrientDocumentTemplate implements OrientOperations { - - private OrientDocumentDatabaseFactory dbf; - - @Override - public RET load(ORID recordId) { - return null; - } - - @Override - public RET load(String recordId) { - return null; - } - - @Override - public RET save(Object entity) { - return null; - } - - @Override - public RET save(Object entity, String cluster) { - return null; - } - - @Override - public Long count(OSQLQuery query, Object... values) { - return null; - } - - @Override - public long countClass(String iClassName) { - return 0; - } - - @Override - public long countClass(Class iClass) { - return 0; - } - - @Override - public long countClusterElements(String iClusterName) { - return 0; - } - - @Override - public > RET query(OQuery query, Object... values) { - return null; - } - - @Override - public RET queryForObject(OSQLQuery query, DetachMode detachMode, Object... values) { - return null; - } - - @Override - public > RET query(OQuery query, DetachMode detachMode, Object... values) { - return null; - } +public class OrientDocumentTemplate extends AbstractOrientOperations implements OrientDocumentOperations { - @Override - public ODatabase delete(ORecordInternal iRecord) { - return null; - } - - @Override - public ODatabaseObject delete(ORID iRID) { - return null; - } - - @Override - public ODatabaseObject delete(Object iPojo) { - return null; - } - - @Override - public OObjectIteratorClass browseClass(Class iClusterClass) { - return null; + public OrientDocumentTemplate(OrientDocumentDatabaseFactory dbf) { + super(dbf); } - @Override - public int getDefaultClusterId(Class domainClass) { - return 0; - } - - @Override - public String getClusterNameById(int iClusterId) { - return null; + public ODatabaseDocumentTx getDocumentDatabase() { + return (ODatabaseDocumentTx)dbf.db(); } @Override - public int getClusterIdByName(String clusterName, Class aClass) { - return 0; + public String getRid(ORecord entity) { + return entity.getRecord().getIdentity().toString(); } @Override - public String getClusterNameByRid(String rid) { - return null; - } - - @Override - public List getClusterNamesByClass(Class entityClass, boolean includeDefault) { - return null; - } + public RET detach(RET entity) { + ((ORecord)entity).detach(); - @Override - public boolean isDefault(String clusterName) { - return false; - } - - @Override - public boolean existsClass(Class clazz) { - return false; - } - - @Override - public boolean existsClass(String className) { - return false; - } - - @Override - public String getRid(Object entity) { - return null; - } - - @Override - public void registerEntityClass(Class domainClass) { - - } - - @Override - public RET command(OCommandSQL command, Object... args) { - return null; + return entity; } @Override - public RET command(String sql, Object... args) { - return null; + public RET detachAll(RET entity) { + // TODO: is this enough? + return detach(entity); } } diff --git a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectDatabaseFactory.java b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectDatabaseFactory.java index 0e2601d..7b72498 100644 --- a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectDatabaseFactory.java +++ b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectDatabaseFactory.java @@ -10,7 +10,7 @@ * @author Dzmitry_Naskou * @see com.orientechnologies.orient.object.db.OObjectDatabaseTx */ -public class OrientObjectDatabaseFactory extends AbstractOrientDatabaseFactory { +public class OrientObjectDatabaseFactory extends AbstractOrientDatabaseFactory { private OObjectDatabasePool pool; diff --git a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectOperations.java b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectOperations.java index 45f4e85..cda9cec 100644 --- a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectOperations.java +++ b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectOperations.java @@ -1,8 +1,8 @@ package org.springframework.data.orient.object; +import com.orientechnologies.orient.object.db.OObjectDatabaseTx; import org.springframework.data.orient.commons.core.OrientOperations; -public interface OrientObjectOperations extends OrientOperations { - - RET detachAll(Object iPojo, boolean returnNonProxiedInstance); +public interface OrientObjectOperations extends OrientOperations { + OObjectDatabaseTx getObjectDatabase(); } diff --git a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectTemplate.java b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectTemplate.java index 438c53b..1987609 100644 --- a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectTemplate.java +++ b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/OrientObjectTemplate.java @@ -1,264 +1,101 @@ package org.springframework.data.orient.object; -import com.orientechnologies.common.exception.OException; import com.orientechnologies.orient.core.annotation.OId; -import com.orientechnologies.orient.core.cache.OLocalRecordCache; -import com.orientechnologies.orient.core.command.OCommandOutputListener; -import com.orientechnologies.orient.core.command.OCommandRequest; -import com.orientechnologies.orient.core.db.ODatabase; -import com.orientechnologies.orient.core.db.ODatabase.ATTRIBUTES; -import com.orientechnologies.orient.core.db.ODatabase.OPERATION_MODE; -import com.orientechnologies.orient.core.db.ODatabase.STATUS; -import com.orientechnologies.orient.core.db.ODatabaseInternal; -import com.orientechnologies.orient.core.db.ODatabaseListener; -import com.orientechnologies.orient.core.db.document.ODatabaseDocument; -import com.orientechnologies.orient.core.db.object.ODatabaseObject; -import com.orientechnologies.orient.core.db.record.OIdentifiable; -import com.orientechnologies.orient.core.dictionary.ODictionary; -import com.orientechnologies.orient.core.entity.OEntityManager; -import com.orientechnologies.orient.core.exception.OTransactionException; -import com.orientechnologies.orient.core.hook.ORecordHook; -import com.orientechnologies.orient.core.hook.ORecordHook.HOOK_POSITION; -import com.orientechnologies.orient.core.hook.ORecordHook.RESULT; -import com.orientechnologies.orient.core.hook.ORecordHook.TYPE; -import com.orientechnologies.orient.core.id.ORID; -import com.orientechnologies.orient.core.id.ORecordId; -import com.orientechnologies.orient.core.intent.OIntent; -import com.orientechnologies.orient.core.metadata.schema.OClass; -import com.orientechnologies.orient.core.metadata.security.OSecurityUser; -import com.orientechnologies.orient.core.metadata.security.OUser; -import com.orientechnologies.orient.core.query.OQuery; -import com.orientechnologies.orient.core.record.ORecord; -import com.orientechnologies.orient.core.record.ORecordInternal; -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.storage.ORecordCallback; -import com.orientechnologies.orient.core.storage.ORecordMetadata; -import com.orientechnologies.orient.core.storage.OStorage; -import com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY; -import com.orientechnologies.orient.core.tx.OTransaction; -import com.orientechnologies.orient.core.tx.OTransaction.TXTYPE; -import com.orientechnologies.orient.core.version.ORecordVersion; -import com.orientechnologies.orient.object.db.ODatabasePojoAbstract; import com.orientechnologies.orient.object.db.OObjectDatabaseTx; -import com.orientechnologies.orient.object.enhancement.OObjectMethodFilter; -import com.orientechnologies.orient.object.iterator.OObjectIteratorClass; -import com.orientechnologies.orient.object.iterator.OObjectIteratorCluster; -import com.orientechnologies.orient.object.metadata.OMetadataObject; -import org.springframework.data.orient.commons.repository.DetachMode; +import org.springframework.data.orient.commons.core.AbstractOrientOperations; import org.springframework.transaction.annotation.Transactional; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -import java.util.*; -import java.util.Map.Entry; -import java.util.concurrent.Callable; +import java.util.ArrayList; +import java.util.List; @Transactional -public class OrientObjectTemplate implements OrientObjectOperations { - - private final OrientObjectDatabaseFactory dbf; - - private Set defaultClusters; +public class OrientObjectTemplate extends AbstractOrientOperations implements OrientObjectOperations { public OrientObjectTemplate(OrientObjectDatabaseFactory dbf) { - this.dbf = dbf; - } - - public OObjectDatabaseTx database() { - return dbf.db(); - } - - public void reload() { - dbf.db().reload(); - } - - public STATUS getStatus() { - return dbf.db().getStatus(); - } - - public > THISDB setStatus(STATUS iStatus) { - return dbf.db().setStatus(iStatus); - } - - public String getName() { - return dbf.db().getName(); - } - - public String getURL() { - return dbf.db().getURL(); - } - - public OStorage getStorage() { - return dbf.db().getStorage(); - } - - public OTransaction getTransaction() { - return dbf.db().getTransaction(); - } - - public ODatabase begin() { - return dbf.db().begin(); - } - - public OLocalRecordCache getLevel2Cache() { - return dbf.db().getLocalCache(); - } - - public ODatabase begin(TXTYPE iType) { - return dbf.db().begin(iType); - } - - public boolean isClosed() { - return dbf.db().isClosed(); - } - - public ODatabase begin(OTransaction iTx) { - return dbf.db().begin(iTx); - } - - public long countClusterElements(int iClusterId) { - return dbf.db().countClusterElements(iClusterId); - } - - public long countClusterElements(int[] iClusterIds) { - return dbf.db().countClusterElements(iClusterIds); + super(dbf); } @Override - public long countClusterElements(String iClusterName) { - return dbf.db().countClusterElements(iClusterName); - } - - public T newInstance(Class iType) { - return dbf.db().newInstance(iType); - } - - public long countClusterElements(int iClusterId, boolean countTombstones) { - return dbf.db().countClusterElements(iClusterId, countTombstones); - } - - public T newInstance(Class iType, Object... iArgs) { - return dbf.db().newInstance(iType, iArgs); - } - - public long countClusterElements(int[] iClusterIds, boolean countTombstones) { - return dbf.db().countClusterElements(iClusterIds, countTombstones); - } - - public RET newInstance(String iClassName) { - return dbf.db().newInstance(iClassName); - } - - public void setDirty(Object iPojo) { - dbf.db().setDirty(iPojo); - } - - public int getClusters() { - return dbf.db().getClusters(); - } - - public boolean existsCluster(String iClusterName) { - return dbf.db().existsCluster(iClusterName); - } - - public Collection getClusterNames() { - return dbf.db().getClusterNames(); - } - - public OMetadataObject getMetadata() { - return dbf.db().getMetadata(); - } - - public void unsetDirty(Object iPojo) { - dbf.db().unsetDirty(iPojo); - } - - public RET newInstance(String iClassName, Object iEnclosingClass, - Object... iArgs) { - return dbf.db().newInstance(iClassName, iEnclosingClass, iArgs); - } - - public int getClusterIdByName(String iClusterName) { - return dbf.db().getClusterIdByName(iClusterName); - } - - public void setInternal(ATTRIBUTES attribute, Object iValue) { - dbf.db().setInternal(attribute, iValue); - } - - @Override - public String getClusterNameById(int iClusterId) { - return dbf.db().getClusterNameById(iClusterId); + public OObjectDatabaseTx getObjectDatabase() { + return (OObjectDatabaseTx)dbf.db(); } @Override - public int getClusterIdByName(String clusterName, Class aClass) { - OClass oClass = dbf.db().getMetadata().getSchema().getClass(aClass); - for(int clusterId : oClass.getClusterIds()){ - if(getClusterNameById(clusterId).equals(clusterName)){ - return clusterId; + 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(); } - - throw new OException("Cluster " + clusterName + " not found"); - } - - @Override - public String getClusterNameByRid(String rid) { - return getClusterNameById(new ORecordId(rid).getClusterId()); + return null; } - public long getClusterRecordSizeById(int iClusterId) { - return dbf.db().getClusterRecordSizeById(iClusterId); + private String getterName(String propertyName) { + return "get" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1).toLowerCase(); } - public long getClusterRecordSizeByName(String iClusterName) { - return dbf.db().getClusterRecordSizeByName(iClusterName); - } + @Override + @SuppressWarnings("unchecked") + public > RET detach(RET entities) { + // NOTE: this re-implementation avoids unnecessary calls to getObjectDatabase() + final OObjectDatabaseTx db = getObjectDatabase(); - public int addCluster(String iType, String iClusterName, String iLocation, String iDataSegmentName, Object... iParameters) { - return dbf.db().addCluster(iType, iClusterName, iLocation, iDataSegmentName, iParameters); - } + List result = new ArrayList<>(entities.size()); - public int addCluster(String iType, String iClusterName, int iRequestedId, String iLocation, String iDataSegmentName, Object... iParameters) { - return dbf.db().addCluster(iType, iClusterName, iRequestedId, iLocation, iDataSegmentName, iParameters); - } + for (Object entity : entities) { + result.add(db.detach(entity, true)); + } - public RET newInstance(String iClassName, Object iEnclosingClass, ODocument iDocument, Object... iArgs) { - return dbf.db().newInstance(iClassName, iEnclosingClass, iDocument, iArgs); + return (RET)result; } - public OSecurityUser getUser() { - return dbf.db().getUser(); - } + @Override + @SuppressWarnings("unchecked") + public > RET detachAll(RET entities) { + // NOTE: this re-implementation avoids unnecessary calls to getObjectDatabase() + final OObjectDatabaseTx db = getObjectDatabase(); - public int addCluster(String iClusterName, Object... iParameters) { - return dbf.db().addCluster(iClusterName, iParameters); - } + List result = new ArrayList<>(entities.size()); - public void setUser(OUser user) { - dbf.db().setUser(user); - } + for (Object entity : entities) { + result.add(db.detachAll(entity, true)); + } - public RET command(OCommandRequest iCommand) { - return dbf.db().command(iCommand); + return (RET) result; } - public int addCluster(String iClusterName) { - return dbf.db().addCluster(iClusterName); + @Override + @SuppressWarnings("unchecked") + public RET detach(RET entity) { + return (RET)getObjectDatabase().detach(entity, true); } @Override - public > RET query(OQuery iCommand, Object... iArgs) { - return dbf.db().query(iCommand, iArgs); + @SuppressWarnings("unchecked") + public RET detachAll(RET entity) { + return (RET)getObjectDatabase().detachAll(entity, true); } +/** @Override public > RET query(OQuery query, DetachMode detachMode, Object... args) { RET result = query(query, args); @@ -274,10 +111,12 @@ public > RET query(OQuery query, DetachMode detachMode, O return result; } + @Override @SuppressWarnings("unchecked") public > RET detach(RET list) { - final OObjectDatabaseTx db = dbf.db(); - List pojos = new ArrayList(list.size()); + final OObjectDatabaseTx db = getObjectDatabase(); + + List pojos = new ArrayList<>(list.size()); for (Object object : list) { pojos.add(db.detach(object, true)); @@ -286,10 +125,12 @@ public > RET detach(RET list) { return (RET) pojos; } + @Override @SuppressWarnings("unchecked") public > RET detachAll(RET list) { - final OObjectDatabaseTx db = dbf.db(); - List pojos = new ArrayList(list.size()); + final OObjectDatabaseTx db = getObjectDatabase(); + + List pojos = new ArrayList<>(list.size()); for (Object object : list) { pojos.add(db.detachAll(object, true)); @@ -300,435 +141,205 @@ public > RET detachAll(RET list) { @Override public OObjectIteratorClass browseClass(Class iClusterClass) { - return dbf.db().browseClass(iClusterClass); - } - - public int getDefaultClusterId() { - return dbf.db().getDefaultClusterId(); - } - - public int getDefaultClusterId(Class domainClass) { - return dbf.db().getMetadata().getSchema().getClass(domainClass).getDefaultClusterId(); + return getObjectDatabase().browseClass(iClusterClass); } + @Override public OObjectIteratorClass browseClass(Class iClusterClass, boolean iPolymorphic) { - return dbf.db().browseClass(iClusterClass, iPolymorphic); - } - - public boolean declareIntent(OIntent iIntent) { - return dbf.db().declareIntent(iIntent); + return getObjectDatabase().browseClass(iClusterClass, iPolymorphic); } @Override - public ODatabaseObject delete(ORecordInternal iRecord) { - return dbf.db().delete(iRecord); - } - public OObjectIteratorClass browseClass(String iClassName) { - return dbf.db().browseClass(iClassName); - } - - public ODatabaseInternal getDatabaseOwner() { - return dbf.db().getDatabaseOwner(); + return getObjectDatabase().browseClass(iClassName); } + @Override public OObjectIteratorClass browseClass(String iClassName, boolean iPolymorphic) { - return dbf.db().browseClass(iClassName, iPolymorphic); + return getObjectDatabase().browseClass(iClassName, iPolymorphic); } - public ODatabaseInternal setDatabaseOwner(ODatabaseInternal iOwner) { - return dbf.db().setDatabaseOwner(iOwner); - } - - public boolean equals(Object iOther) { - return dbf.db().equals(iOther); + @Override + public ODatabaseInternal getDatabaseOwner() { + return getObjectDatabase().getDatabaseOwner(); } - public > DBTYPE registerHook(ORecordHook iHookImpl) { - return dbf.db().registerHook(iHookImpl); + @Override + public ODatabaseInternal setDatabaseOwner(ODatabaseInternal iOwner) { + return getObjectDatabase().setDatabaseOwner(iOwner); } + @Override public OObjectIteratorCluster browseCluster(String iClusterName) { - return dbf.db().browseCluster(iClusterName); - } - - public String toString() { - return dbf.db().toString(); - } - - public Object setProperty(String iName, Object iValue) { - return dbf.db().setProperty(iName, iValue); - } - - public > DBTYPE registerHook(ORecordHook iHookImpl, HOOK_POSITION iPosition) { - return dbf.db().registerHook(iHookImpl, iPosition); - } - - public Object getProperty(String iName) { - return dbf.db().getProperty(iName); - } - - public RESULT callbackHooks(TYPE iType, OIdentifiable iObject) { - return dbf.db().callbackHooks(iType, iObject); - } - - public Iterator> getProperties() { - return dbf.db().getProperties(); - } - - public RET load(Object iPojo) { - return dbf.db().load(iPojo); - } - - public RET reload(Object iPojo) { - return dbf.db().reload(iPojo); - } - - public Object get(ATTRIBUTES iAttribute) { - return dbf.db().get(iAttribute); - } - - public Map getHooks() { - return dbf.db().getHooks(); - } - - public RET reload(Object iPojo, boolean iIgnoreCache) { - return dbf.db().reload(iPojo, iIgnoreCache); - } - - public > THISDB set(ATTRIBUTES attribute, Object iValue) { - return dbf.db().set(attribute, iValue); - } - - public > DBTYPE unregisterHook(ORecordHook iHookImpl) { - return dbf.db().unregisterHook(iHookImpl); - } - - public RET reload(Object iPojo, String iFetchPlan, boolean iIgnoreCache) { - return dbf.db().reload(iPojo, iFetchPlan, iIgnoreCache); - } - - public void registerListener(ODatabaseListener iListener) { - dbf.db().registerListener(iListener); - } - - public boolean isMVCC() { - return dbf.db().isMVCC(); - } - - public > DBTYPE setMVCC(boolean iMvcc) { - return dbf.db().setMVCC(iMvcc); - } - - public void unregisterListener(ODatabaseListener iListener) { - dbf.db().unregisterListener(iListener); + return getObjectDatabase().browseCluster(iClusterName); } + @Override public V callInLock(Callable iCallable, boolean iExclusiveLock) { - return dbf.db().callInLock(iCallable, iExclusiveLock); + return getObjectDatabase().callInLock(iCallable, iExclusiveLock); } + @Override public ODatabasePojoAbstract setRetainObjects(boolean iValue) { - return dbf.db().setRetainObjects(iValue); - } - - public RET load(Object iPojo, String iFetchPlan) { - return dbf.db().load(iPojo, iFetchPlan); + return getObjectDatabase().setRetainObjects(iValue); } + @Override public void attach(Object iPojo) { - dbf.db().attach(iPojo); - } - - public ORecordMetadata getRecordMetadata(ORID rid) { - return dbf.db().getRecordMetadata(rid); + getObjectDatabase().attach(iPojo); } + @Override public RET attachAndSave(Object iPojo) { - return dbf.db().attachAndSave(iPojo); + return getObjectDatabase().attachAndSave(iPojo); } + @Override public boolean isRetainObjects() { - return dbf.db().isRetainObjects(); - } - - public long getSize() { - return dbf.db().getSize(); + return getObjectDatabase().isRetainObjects(); } + @Override public RET detach(Object iPojo) { - return dbf.db().detach(iPojo); - } - - public void freeze(boolean throwException) { - dbf.db().freeze(throwException); - } - - public void freeze() { - dbf.db().freeze(); - } - - public void release() { - dbf.db().release(); - } - - public void freezeCluster(int iClusterId, boolean throwException) { - dbf.db().freezeCluster(iClusterId, throwException); + return getObjectDatabase().detach(iPojo); } + @Override public RET detach(Object iPojo, boolean returnNonProxiedInstance) { - return dbf.db().detach(iPojo, returnNonProxiedInstance); - } - - public void freezeCluster(int iClusterId) { - dbf.db().freezeCluster(iClusterId); - } - - public void releaseCluster(int iClusterId) { - dbf.db().releaseCluster(iClusterId); + return getObjectDatabase().detach(iPojo, returnNonProxiedInstance); } + @Override public boolean existsUserObjectByRID(ORID iRID) { - return dbf.db().existsUserObjectByRID(iRID); + return getObjectDatabase().existsUserObjectByRID(iRID); } + @Override public ODocument getRecordById(ORID iRecordId) { - return dbf.db().getRecordById(iRecordId); + return getObjectDatabase().getRecordById(iRecordId); } @Override public RET detachAll(Object iPojo, boolean returnNonProxiedInstance) { - return dbf.db().detachAll(iPojo, returnNonProxiedInstance); + return getObjectDatabase().detachAll(iPojo, returnNonProxiedInstance); } + @Override public boolean isManaged(Object iEntity) { - return dbf.db().isManaged(iEntity); + return getObjectDatabase().isManaged(iEntity); } + @Override public Object getUserObjectByRecord(OIdentifiable iRecord, String iFetchPlan) { return dbf.db().getUserObjectByRecord(iRecord, iFetchPlan); } - public RET load(Object iPojo, String iFetchPlan, boolean iIgnoreCache) { - return dbf.db().load(iPojo, iFetchPlan, iIgnoreCache); - } - @Override - public RET load(ORID recordId) { - return dbf.db().load(recordId); + public long countClass(String className) { + return getObjectDatabase().countClass(className); } @Override - public final RET load(String recordId) { - return load(new ORecordId(recordId)); - } - - public RET load(ORID iRecordId, String iFetchPlan) { - return dbf.db().load(iRecordId, iFetchPlan); + public long countClass(Class clazz) { + return getObjectDatabase().countClass(clazz); } - public RET load(ORID iRecordId, String iFetchPlan, boolean iIgnoreCache) { - return dbf.db().load(iRecordId, iFetchPlan, iIgnoreCache); - } - - @Override - public RET save(Object iContent) { - return dbf.db().save(iContent); - } - - public RET save(Object iContent, OPERATION_MODE iMode, boolean iForceCreate, ORecordCallback iRecordCreatedCallback, ORecordCallback iRecordUpdatedCallback) { - return dbf.db().save(iContent, iMode, iForceCreate, iRecordCreatedCallback, iRecordUpdatedCallback); - } - - /* (non-Javadoc) - * @see org.springframework.data.orient.core.OrientOperations#save(java.lang.Object, java.lang.String) - */ @Override - public RET save(Object iPojo, String iClusterName) { - return dbf.db().save(iPojo, iClusterName); - } - - - public RET save(Object iPojo, String iClusterName, - OPERATION_MODE iMode, boolean iForceCreate, - ORecordCallback iRecordCreatedCallback, - ORecordCallback iRecordUpdatedCallback) { - return dbf.db().save(iPojo, iClusterName, iMode, iForceCreate, iRecordCreatedCallback, iRecordUpdatedCallback); - } - - @Override - public ODatabaseObject delete(Object iPojo) { - return dbf.db().delete(iPojo); - } - - @Override - public ODatabaseObject delete(ORID iRID) { - return dbf.db().delete(iRID); - } - - public ODatabaseObject delete(ORID iRID, ORecordVersion iVersion) { - return dbf.db().delete(iRID, iVersion); - } - - /* (non-Javadoc) - * @see org.springframework.data.orient.core.OrientOperations#countClass(java.lang.String) - */ - @Override - public long countClass(String iClassName) { - return dbf.db().countClass(iClassName); - } - - /* (non-Javadoc) - * @see org.springframework.data.orient.core.OrientOperations#countClass(java.lang.Class) - */ - @Override - public long countClass(Class iClass) { - return dbf.db().countClass(iClass); - } - - public ODictionary getDictionary() { - return dbf.db().getDictionary(); - } - - public ODatabasePojoAbstract commit() { - return dbf.db().commit(); - } - - public ODatabasePojoAbstract rollback() { - return dbf.db().rollback(); - } - public OEntityManager getEntityManager() { - return dbf.db().getEntityManager(); + return getObjectDatabase().getEntityManager(); } + @Override public ODatabaseDocument getUnderlying() { - return dbf.db().getUnderlying(); + return getObjectDatabase().getUnderlying(); } + @Override public ORecordVersion getVersion(Object iPojo) { - return dbf.db().getVersion(iPojo); + return getObjectDatabase().getVersion(iPojo); } + @Override public ORID getIdentity(Object iPojo) { - return dbf.db().getIdentity(iPojo); + return getObjectDatabase().getIdentity(iPojo); } + @Override public boolean isSaveOnlyDirty() { - return dbf.db().isSaveOnlyDirty(); + return getObjectDatabase().isSaveOnlyDirty(); } + @Override public void setSaveOnlyDirty(boolean saveOnlyDirty) { - dbf.db().setSaveOnlyDirty(saveOnlyDirty); + getObjectDatabase().setSaveOnlyDirty(saveOnlyDirty); } + @Override public boolean isAutomaticSchemaGeneration() { - return dbf.db().isAutomaticSchemaGeneration(); + return getObjectDatabase().isAutomaticSchemaGeneration(); } + @Override public void setAutomaticSchemaGeneration(boolean automaticSchemaGeneration) { - dbf.db().setAutomaticSchemaGeneration(automaticSchemaGeneration); - } - - public Object newInstance() { - return dbf.db().newInstance(); + getObjectDatabase().setAutomaticSchemaGeneration(automaticSchemaGeneration); } + @Override public ODocument pojo2Stream(Object iPojo, ODocument iRecord) { - return dbf.db().pojo2Stream(iPojo, iRecord); + return getObjectDatabase().pojo2Stream(iPojo, iRecord); } + @Override public Object stream2pojo(ODocument iRecord, Object iPojo, String iFetchPlan) { - return dbf.db().stream2pojo(iRecord, iPojo, iFetchPlan); + return getObjectDatabase().stream2pojo(iRecord, iPojo, iFetchPlan); } + @Override public Object stream2pojo(ODocument iRecord, Object iPojo, String iFetchPlan, boolean iReload) { - return dbf.db().stream2pojo(iRecord, iPojo, iFetchPlan, iReload); + return getObjectDatabase().stream2pojo(iRecord, iPojo, iFetchPlan, iReload); } + @Override public boolean isLazyLoading() { - return dbf.db().isLazyLoading(); + return getObjectDatabase().isLazyLoading(); } + @Override public void setLazyLoading(boolean lazyLoading) { - dbf.db().setLazyLoading(lazyLoading); - } - - public String getType() { - return dbf.db().getType(); - } - - public ODocument getRecordByUserObject(Object iPojo, boolean iCreateIfNotAvailable) { - return dbf.db().getRecordByUserObject(iPojo, iCreateIfNotAvailable); - } - - public Object getUserObjectByRecord(OIdentifiable iRecord, String iFetchPlan, boolean iCreate) { - return dbf.db().getUserObjectByRecord(iRecord, iFetchPlan, iCreate); - } - - public void registerUserObject(Object iObject, ORecord iRecord) { - dbf.db().registerUserObject(iObject, iRecord); - } - - public void registerUserObjectAfterLinkSave(ORecord iRecord) { - dbf.db().registerUserObjectAfterLinkSave(iRecord); + getObjectDatabase().setLazyLoading(lazyLoading); } + @Override public void unregisterPojo(Object iObject, ODocument iRecord) { - dbf.db().unregisterPojo(iObject, iRecord); + getObjectDatabase().unregisterPojo(iObject, iRecord); } + @Override public void registerClassMethodFilter(Class iClass, OObjectMethodFilter iMethodFilter) { - dbf.db().registerClassMethodFilter(iClass, iMethodFilter); + getObjectDatabase().registerClassMethodFilter(iClass, iMethodFilter); } + @Override public void deregisterClassMethodFilter(Class iClass) { - dbf.db().deregisterClassMethodFilter(iClass); - } - - public void backup(OutputStream out, Map options, Callable callable, OCommandOutputListener iListener, int compressionLevel, int bufferSize) throws IOException { - dbf.db().backup(out, options, callable, iListener, compressionLevel, bufferSize); - } - - public ODatabasePojoAbstract commit(boolean force) throws OTransactionException { - return dbf.db().commit(force); - } - - public RET load(Object iPojo, String iFetchPlan, boolean iIgnoreCache, boolean loadTombstone, LOCKING_STRATEGY iLockingStrategy) { - return dbf.db().load(iPojo, iFetchPlan, iIgnoreCache, loadTombstone, iLockingStrategy); - } - - public RET load(ORID iRecordId, String iFetchPlan, boolean iIgnoreCache, boolean loadTombstone, LOCKING_STRATEGY iLockingStrategy) { - return dbf.db().load(iRecordId, iFetchPlan, iIgnoreCache, loadTombstone, iLockingStrategy); - } - - public > THISDB open(String iUserName, String iUserPassword) { - return dbf.db().open(iUserName, iUserPassword); + getObjectDatabase().deregisterClassMethodFilter(iClass); } - public void restore(InputStream in, Map options, Callable callable, OCommandOutputListener iListener) throws IOException { - dbf.db().restore(in, options, callable, iListener); - } - - public ODatabasePojoAbstract rollback(boolean force) throws OTransactionException { - return dbf.db().rollback(force); - } - - public RET queryForObject(OSQLQuery query, Object... values) { - List list = query(query, values); + @Override + public RET queryForObject(OSQLQuery query, Object... args) { + List list = query(query, args); return list.isEmpty() ? null : list.get(0); } @Override - public RET queryForObject(OSQLQuery query, DetachMode detachMode, Object... values) { - RET result = queryForObject(query, values); + public RET queryForObject(OSQLQuery query, DetachMode detachMode, Object... args) { + RET result = queryForObject(query, args); switch (detachMode) { case ENTITY: - return dbf.db().detach(result, true); + return getObjectDatabase().detach(result, true); case ALL: - return dbf.db().detachAll(result, true); + return getObjectDatabase().detachAll(result, true); case NONE: } @@ -736,97 +347,10 @@ public RET queryForObject(OSQLQuery query, DetachMode detachMode, Objec } @Override - public Long count(OSQLQuery query, Object... values) { - return ((ODocument) dbf.db().query(query, values).get(0)).field("count"); - } - - @Override - public boolean existsClass(Class clazz) { - return existsClass(clazz.getSimpleName()); - } - - @Override - public boolean existsClass(String className) { - return dbf.db().getMetadata().getSchema().existsClass(className); - } - - @Override - public List getClusterNamesByClass(Class entityClass, boolean showDefault) { - int[] clusterIds = dbf.db().getMetadata().getSchema().getClass(entityClass).getClusterIds(); - int defaultCluster = getDefaultClusterId(entityClass); - - List clusters = new ArrayList<>(clusterIds.length); - for (int clusterId : clusterIds) { - if (showDefault || 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 : dbf.db().getMetadata().getSchema().getClasses()) { - String defaultCluster = getClusterNameById(oClass.getDefaultClusterId()); - defaultClusters.add(defaultCluster); - } - } - } - } - } - - @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(); - } - public void registerEntityClass(Class domainClass) { - try (OObjectDatabaseTx db = dbf.openDatabase()) { + try (OObjectDatabaseTx db = getObjectDatabase()) { db.getEntityManager().registerEntityClass(domainClass); } } - - public RET command(OCommandSQL command, Object... args) { - return dbf.db().command(command).execute(args); - } - - public RET command(String sql, Object... args) { - return command(new OCommandSQL(sql), args); - } + */ } diff --git a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/OrientObjectRepositoryFactory.java b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/OrientObjectRepositoryFactory.java index 1a43520..2042f82 100644 --- a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/OrientObjectRepositoryFactory.java +++ b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/OrientObjectRepositoryFactory.java @@ -1,13 +1,13 @@ package org.springframework.data.orient.object.repository.support; import org.springframework.core.annotation.AnnotationUtils; -import org.springframework.data.orient.commons.core.OrientOperations; import org.springframework.data.orient.commons.repository.SourceType; import org.springframework.data.orient.commons.repository.annotation.Cluster; import org.springframework.data.orient.commons.repository.annotation.Source; import org.springframework.data.orient.commons.repository.query.OrientQueryLookupStrategy; import org.springframework.data.orient.commons.repository.support.OrientMetamodelEntityInformation; import org.springframework.data.orient.commons.repository.support.SimpleOrientRepository; +import org.springframework.data.orient.object.OrientObjectOperations; import org.springframework.data.orient.object.repository.OrientObjectRepository; import org.springframework.data.repository.core.EntityInformation; import org.springframework.data.repository.core.RepositoryMetadata; @@ -19,9 +19,9 @@ // TODO: find out why inheriting from OrientRepositoryFactory does not work; would save some code; but this here works public class OrientObjectRepositoryFactory extends RepositoryFactorySupport { - private final OrientOperations operations; + private final OrientObjectOperations operations; - public OrientObjectRepositoryFactory(OrientOperations operations) { + public OrientObjectRepositoryFactory(OrientObjectOperations operations) { super(); this.operations = operations; } diff --git a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/OrientObjectRepositoryFactoryBean.java b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/OrientObjectRepositoryFactoryBean.java index 1aa0688..32e53af 100644 --- a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/OrientObjectRepositoryFactoryBean.java +++ b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/OrientObjectRepositoryFactoryBean.java @@ -2,6 +2,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.orient.commons.core.OrientOperations; +import org.springframework.data.orient.object.OrientObjectOperations; import org.springframework.data.repository.Repository; import org.springframework.data.repository.core.support.RepositoryFactorySupport; import org.springframework.data.repository.core.support.TransactionalRepositoryFactoryBeanSupport; @@ -22,11 +23,8 @@ public class OrientObjectRepositoryFactoryBean, S, I /** The orient operations. */ @Autowired - private OrientOperations operations; + private OrientObjectOperations operations; - /* (non-Javadoc) - * @see org.springframework.data.repository.core.support.TransactionalRepositoryFactoryBeanSupport#doCreateRepositoryFactory() - */ @Override protected RepositoryFactorySupport doCreateRepositoryFactory() { return new OrientObjectRepositoryFactory(operations); diff --git a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/SimpleOrientObjectRepository.java b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/SimpleOrientObjectRepository.java index ef62fec..1141dea 100644 --- a/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/SimpleOrientObjectRepository.java +++ b/spring-data-orientdb-object/src/main/java/org/springframework/data/orient/object/repository/support/SimpleOrientObjectRepository.java @@ -1,6 +1,5 @@ package org.springframework.data.orient.object.repository.support; -import org.springframework.data.orient.commons.core.OrientOperations; import org.springframework.data.orient.commons.repository.support.SimpleOrientRepository; import org.springframework.data.orient.object.OrientObjectOperations; import org.springframework.data.orient.object.repository.OrientObjectRepository; @@ -24,15 +23,17 @@ public class SimpleOrientObjectRepository extends SimpleOrientRepository i * @param domainClass the domain class * @param repositoryInterface the target repository interface */ - public SimpleOrientObjectRepository(OrientOperations operations, Class domainClass, Class repositoryInterface) { + public SimpleOrientObjectRepository(OrientObjectOperations operations, Class domainClass, Class repositoryInterface) { super(operations, domainClass, repositoryInterface); } - public SimpleOrientObjectRepository(OrientOperations operations, Class domainClass, String cluster, Class repositoryInterface) { + public SimpleOrientObjectRepository(OrientObjectOperations operations, Class domainClass, String cluster, Class repositoryInterface) { super(operations, domainClass, cluster, repositoryInterface); } public T detachAll(T entity) { - return ((OrientObjectOperations) super.operations).detachAll(entity, true); + // TODO: solve this issue + //return ((OrientObjectOperations) super.operations).detachAll(entity, true); + return entity; } } diff --git a/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/OrientDbObjectTestConfiguration.java b/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/OrientDbObjectTestConfiguration.java index 5e8b8f9..2f3c802 100644 --- a/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/OrientDbObjectTestConfiguration.java +++ b/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/OrientDbObjectTestConfiguration.java @@ -1,6 +1,7 @@ package org.springframework.data.orient.object; import com.orientechnologies.orient.core.entity.OEntityManager; +import com.orientechnologies.orient.object.db.OObjectDatabaseTx; import org.slf4j.bridge.SLF4JBridgeHandler; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.context.annotation.Bean; @@ -55,18 +56,20 @@ public OrientObjectTemplate objectTemplate() { @PostConstruct public void registerEntities() { - OEntityManager em = factory().db().getEntityManager(); + OObjectDatabaseTx db = factory().db(); + + OEntityManager em = db.getEntityManager(); em.registerEntityClass(Person.class); em.registerEntityClass(Address.class); em.registerEntityClass(Employee.class); - if (!factory().db().existsCluster(EMPLOYEE_TMP_CLUSTER)) { - int id = factory().db().addCluster(EMPLOYEE_TMP_CLUSTER); - factory().db().getMetadata().getSchema().getClass(Employee.class).addClusterId(id); + if (!db.existsCluster(EMPLOYEE_TMP_CLUSTER)) { + int id = db.addCluster(EMPLOYEE_TMP_CLUSTER); + db.getMetadata().getSchema().getClass(Employee.class).addClusterId(id); } - if (!factory().db().existsCluster(EMPLOYEE_HISTORY_CLUSTER)) { - int id = factory().db().addCluster(EMPLOYEE_HISTORY_CLUSTER); - factory().db().getMetadata().getSchema().getClass(Employee.class).addClusterId(id); + if (!db.existsCluster(EMPLOYEE_HISTORY_CLUSTER)) { + int id = db.addCluster(EMPLOYEE_HISTORY_CLUSTER); + db.getMetadata().getSchema().getClass(Employee.class).addClusterId(id); } } } diff --git a/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/repository/PersonRepositoryTest.java b/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/repository/PersonRepositoryTest.java index 10d1d38..b7882ad 100644 --- a/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/repository/PersonRepositoryTest.java +++ b/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/repository/PersonRepositoryTest.java @@ -4,9 +4,9 @@ import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.domain.PageRequest; -import org.springframework.data.orient.commons.core.OrientOperations; import org.springframework.data.orient.object.OrientDbObjectTestConfiguration; import org.springframework.data.orient.object.OrientObjectDatabaseFactory; +import org.springframework.data.orient.object.OrientObjectOperations; import org.springframework.data.orient.object.domain.Address; import org.springframework.data.orient.object.domain.Person; import org.springframework.test.annotation.DirtiesContext; @@ -40,7 +40,7 @@ public class PersonRepositoryTest extends AbstractTestNGSpringContextTests { OrientObjectDatabaseFactory factory; @Autowired - OrientOperations operations; + OrientObjectOperations operations; @BeforeClass public void before() { @@ -71,53 +71,57 @@ public void savePerson() { assertEquals(result.getFirstName(), person.getFirstName()); assertEquals(result.getLastName(), person.getLastName()); } - + @Test public void findAllPersons() { assertFalse(repository.findAll().isEmpty()); } - + @Test public void countPerson() { assertEquals(repository.count(), 5L); } + @Test + public void findByFirstNamePage() { + for (Person person : repository.findByFirstName("Dzmitry", new PageRequest(1, 5)).getContent()) { + assertEquals(person.getFirstName(), "Dzmitry"); + } + } + @Test public void countByFirstName() { assertEquals(repository.countByFirstName("Dzmitry"), Long.valueOf(1)); } - + @Test - public void findByFirstName() { - assertFalse(repository.findByFirstName("Dzmitry").isEmpty()); + public void printFindByLastName() { + List result = repository.findByLastName("Naskou"); + + assertFalse(result.isEmpty()); + + for (Person person : result) { + assertEquals(person.getLastName(), "Naskou"); + } } - + @Test - public void findByFirstNamePage() { - for (Person person : repository.findByFirstName("Dzmitry", new PageRequest(1, 5)).getContent()) { - assertEquals(person.getFirstName(), "Dzmitry"); - } + public void findByFirstName() { + assertFalse(repository.findByFirstName("Dzmitry").isEmpty()); } - + @Test public void findByFirstNameLike() { for (Person person : repository.findByFirstNameLike("Dzm%")) { assertTrue(person.getFirstName().startsWith("Dzm")); } } - + @Test public void findByLastName() { assertFalse(repository.findByLastName("Naskou").isEmpty()); } - - @Test - public void printFindByLastName() { - for (Person person : repository.findByLastName("Naskou")) { - assertEquals(person.getLastName(), "Naskou"); - } - } - + @Test public void findByLastNameLike() { for (Person person : repository.findByLastNameLike("Na%")) { @@ -138,27 +142,27 @@ public void findByFirstNameOrLastName() { assertTrue(person.getFirstName().equals("Dzmitry") || person.getLastName().equals("Eliot")); } } - + @Test public void findByActiveIsTrue() { for (Person person : repository.findByActiveIsTrue()) { assertTrue(person.getActive()); } } - + @Test public void findByActiveIsFalse() { for (Person person : repository.findByActiveIsFalse()) { assertFalse(person.getActive()); } } - + @Test public void findByCityTest() { List persons = repository.findByAddress_City("Minsk"); - + assertFalse(persons.isEmpty()); - + for (Person person : persons) { assertEquals(person.getAddress().getCity(), "Minsk"); } diff --git a/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/repository/cluster/EmployeeClusteredRepositoryTest.java b/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/repository/cluster/EmployeeClusteredRepositoryTest.java index 20b9075..3b982c6 100644 --- a/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/repository/cluster/EmployeeClusteredRepositoryTest.java +++ b/spring-data-orientdb-object/src/test/java/org/springframework/data/orient/object/repository/cluster/EmployeeClusteredRepositoryTest.java @@ -87,11 +87,6 @@ public void findAllByCluster() { logger.debug("Employees: {}", repository.findAll(EMPLOYEE_TMP_CLUSTER)); } - @Test - public void findByLastNameTest() { - logger.debug("Employee: {}", repository.findByLastName("Naskou")); - } - @Test public void checkClasses() { OObjectDatabaseTx db = dbf.openDatabase(); @@ -131,6 +126,10 @@ public void findByFirstNameByCluster() { repository.findByFirstName("Dzmitry", new DefaultCluster(EMPLOYEE_TMP_CLUSTER)); } + @Test + public void findByLastNameTest() { + logger.debug("Employee: {}", repository.findByLastName("Naskou")); + } @Test public void saveEmployeeToTmpCluster() { diff --git a/spring-data-orientdb-object/src/test/resources/logback.xml b/spring-data-orientdb-object/src/test/resources/logback.xml index 7c40e60..41a4d21 100644 --- a/spring-data-orientdb-object/src/test/resources/logback.xml +++ b/spring-data-orientdb-object/src/test/resources/logback.xml @@ -7,20 +7,23 @@ target/orient-test.log %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n - --> + diff --git a/spring-data-orientdb-samples/spring-boot-orientdb-shiro/pom.xml b/spring-data-orientdb-samples/spring-boot-orientdb-shiro/pom.xml index 44b3040..7ae682a 100644 --- a/spring-data-orientdb-samples/spring-boot-orientdb-shiro/pom.xml +++ b/spring-data-orientdb-samples/spring-boot-orientdb-shiro/pom.xml @@ -25,9 +25,7 @@ ${java.version} 1.2.3 - 3.3.3 - 1.8.3 - 6.8.8 + 3.4