Class clazz = persistenceDelegator.getClient(m).getQueryImplementor();
EntityMetadata entityMetadata = getMetadata(entityClass); MainCache mainCache = (MainCache) getPersistenceCache().getMainCache(); Node node = mainCache.getNodeFromCache(nodeId, this); node = new Node(nodeId, entityClass, new ManagedState(), getPersistenceCache(), primaryKey, this); node.setClient(getClient(entityMetadata)); E e = (E) ObjectUtils.deepCopy(nodeData, getKunderaMetadata()); onSetProxyOwners(entityMetadata, e); return e;
/** * Instantiates a new entity manager impl. * * @param factory * the factory */ EntityManagerImpl(final EntityManagerFactory factory, final PersistenceUnitTransactionType transactionType, final PersistenceContextType persistenceContextType) { this.factory = factory; if (logger.isDebugEnabled()) { logger.debug("Creating EntityManager for persistence unit : " + getPersistenceUnit()); } this.persistenceContextType = persistenceContextType; this.persistenceCache = new PersistenceCache((Cache) factory.getCache()); this.persistenceCache.setPersistenceContextType(this.persistenceContextType); this.transactionType = transactionType; this.persistenceDelegator = new PersistenceDelegator( ((EntityManagerFactoryImpl) this.factory).getKunderaMetadataInstance(), this.persistenceCache); for (String pu : ((EntityManagerFactoryImpl) this.factory).getPersistenceUnits()) { this.persistenceDelegator.loadClient(pu, discoverClient(pu)); } if (logger.isDebugEnabled()) { logger.debug("Created EntityManager for persistence unit : " + getPersistenceUnit()); } }
/** * Retrieves {@link List} of entities for a given {@link Map} of embedded * column values. Purpose of this method is to provide functionality of * search based on columns inside embedded objects. * * @param entityClass * Entity Class * @param embeddedColumnMap * Embedded column map values * @return List of found entities. */ public <E> List<E> find(Class<E> entityClass, Map<String, String> embeddedColumnMap) { EntityMetadata entityMetadata = getMetadata(entityClass); // TODO Why returning entities are not added into cache we should not // iterate here but client should i think. List<E> entities = new ArrayList<E>(); entities = getClient(entityMetadata).find(entityClass, embeddedColumnMap); return entities; }
@Test public void testClose() { PersistenceDelegator pd = ((EntityManagerImpl) em).getPersistenceDelegator(); Assert.assertTrue(pd.isOpen()); pd.close(); Assert.assertFalse(pd.isOpen()); Assert.assertTrue(pd.getDelegate().isEmpty()); }
Object relObject, Map<String, Object> relationsMap) EntityMetadata childMetadata = KunderaMetadataManager.getEntityMetadata(delegator.getKunderaMetadata(), relation.getTargetEntity()); Client targetEntityClient = delegator.getClient(childMetadata);
Node node = event.getNode(); Class clazz = node.getDataClass(); EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(delegator.getKunderaMetadata(), clazz); Client client = delegator.getClient(metadata); && (!delegator.isTransactionInProgress() || MetadataUtils .defaultTransactionSupported(metadata.getPersistenceUnit(), delegator.getKunderaMetadata())))
EntityMetadata m = KunderaMetadataManager.getEntityMetadata(getPersistenceDelegator().getKunderaMetadata(), getOwner().getClass()); if (!getPersistenceDelegator().isOpen()) getPersistenceDelegator().getClient(m).getReader() .recursivelyFindEntities(getOwner(), relationsMap, m, getPersistenceDelegator(), true,relationStack);
Client pClient = delegator.getClient(entityMetadata); EntityMetadata owningEntityMetadata = KunderaMetadataManager.getEntityMetadata(delegator.getKunderaMetadata(), relation.getTargetEntity()); Class columnJavaType = owningEntityMetadata.getIdAttribute().getJavaType(); Relation owningEntityMetadataRelation = owningEntityMetadata.getRelation(relation.getMappedBy()); jtMetadata = owningEntityMetadataRelation.getJoinTableMetadata(); pClient = delegator.getClient(owningEntityMetadata); schema = owningEntityMetadata.getSchema(); EntityMetadata childMetadata = KunderaMetadataManager.getEntityMetadata(delegator.getKunderaMetadata(), relation.getTargetEntity()); Object child = delegator.find(relation.getTargetEntity(), foreignKey); Object obj = child instanceof EnhanceEntity && child != null ? ((EnhanceEntity) child).getEntity() : child; Object[] pKeys = pClient.findIdsByColumn(entityMetadata.getSchema(), joinTableName, joinColumnName, inverseJoinColumnName, columnValue, entityMetadata.getEntityClazz()); List parents = delegator.find(entity.getClass(), pKeys); PropertyAccessorHelper.set(obj, biDirectionalField, ObjectUtils.getFieldInstance(parents, biDirectionalField));
EntityMetadata metadata = getMetadata(node.getDataClass()); node.setClient(getClient(metadata)); .defaultTransactionSupported(metadata.getPersistenceUnit(), kunderaMetadata)) onSynchronization(node, metadata); flushJoinTableData();
@Override public List<?> getResultList() { if (log.isDebugEnabled()) log.debug("JPA Query: " + getJPAQuery()); // get luence query String q = luceneQuery; if (null == q) { q = KunderaCoreUtils.getLuceneQueryFromJPAQuery(kunderaQuery, kunderaMetadata); } if (log.isDebugEnabled()) log.debug("Lucene Query: " + q); EntityMetadata m = kunderaQuery.getEntityMetadata(); Client client = persistenceDelegeator.getClient(m); handlePostEvent(); Map<String, Object> searchFilter = client.getIndexManager().search(m.getEntityClazz(), q, -1, maxResult); if (kunderaQuery.isAliasOnly()) { String[] primaryKeys = searchFilter.values().toArray(new String[] {}); return persistenceDelegeator.find(m.getEntityClazz(), primaryKeys); } else { return persistenceDelegeator.find(m.getEntityClazz(), searchFilter); } }
if (applyFlush()) Client client = getClient(m); if (OPERATION.INSERT.equals(jtData.getOperation()))
private KunderaProxy getLazyEntity(String entityName, Class<?> persistentClass, Method getIdentifierMethod, Method setIdentifierMethod, Object id, PersistenceDelegator pd) { return pd.getKunderaMetadata().getCoreMetadata().getLazyInitializerFactory() .getProxy(entityName, persistentClass, getIdentifierMethod, setIdentifierMethod, id, pd); }
Node nodeInPersistenceCache = pd.getPersistenceCache().getMainCache().getNodeFromCache(nodeId, pd); EntityMetadata entityMetadata = KunderaMetadataManager.getEntityMetadata(pd.getKunderaMetadata(), entity.getClass()); entity, ((Field) entityMetadata.getIdAttribute().getJavaMember()).isAnnotationPresent(EmbeddedId.class) ? new ManagedState() : this.state, pd.getPersistenceCache(), entityId, pd); node.setPersistenceCache(pd.getPersistenceCache()); node.setTraversed(false);
/** * @throws java.lang.Exception */ @Before public void setUp() throws Exception { EntityManagerFactoryImpl emfImpl = getEntityManagerFactory(); new PersistenceUnitConfiguration(null, emfImpl.getKunderaMetadataInstance(), "kunderatest").configure(); PersistenceCache persistenceCache = new PersistenceCache(); graphBuilder = new ObjectGraphBuilder(persistenceCache, new PersistenceDelegator( emfImpl.getKunderaMetadataInstance(), persistenceCache)); }
@Override public final void close() { clear(); getPersistenceDelegator().close(); this.closed = true; }
@Override public final void clear() { checkClosed(); // TODO Do we need a client and persistenceDelegator close here? if (!PersistenceUnitTransactionType.JTA.equals(this.transactionType)) { getPersistenceDelegator().clear(); } }
private void rollbackJoinTableData(PersistenceDelegator delegator) { // on deleting join table data. for (JoinTableData jtData : joinTableDataCollection) { if (jtData.isProcessed()) { EntityMetadata m = KunderaMetadataManager.getEntityMetadata(delegator.getKunderaMetadata(), jtData.getEntityClass()); Client client = delegator.getClient(m); if (OPERATION.INSERT.equals(jtData.getOperation())) { for (Object pk : jtData.getJoinTableRecords().keySet()) { client.deleteByColumn(jtData.getSchemaName(), jtData.getJoinTableName(), m.getIdAttribute() .getName(), pk); } } else if (OPERATION.DELETE.equals(jtData.getOperation())) { client.persistJoinTable(jtData); } } } joinTableDataCollection.clear(); joinTableDataCollection = null; joinTableDataCollection = new ArrayList<JoinTableData>(); }