public AbstractJoinImpl( CriteriaBuilderImpl criteriaBuilder, Class<X> javaType, PathSource<Z> pathSource, Attribute<? super Z, ?> joinAttribute, JoinType joinType) { super( criteriaBuilder, javaType, pathSource ); this.joinAttribute = joinAttribute; this.joinType = joinType; }
toAttrJoinType = parentJoinAttr.getJavaType(); } else if( parentJoinAttr instanceof PluralAttribute ) { toAttrJoinType = ((PluralAttribute) parentJoinAttr).getElementType().getJavaType();
private static void setFieldValue(Object entity, Object value, Attribute column) { value = PropertyAccessorHelper.fromSourceToTargetClass(column.getJavaType(), value.getClass(), value); PropertyAccessorHelper.set(entity, (Field) column.getJavaMember(), value); }
/** * validate columns. * * @param metadata * the metadata * @param attributes * the attributes * @return true, if successful */ private boolean validateColumns(EntityMetadata metadata, Set<Attribute> attributes) { boolean isValid = true; for (Attribute column : attributes) { if (!metadata.getIdAttribute().equals(column) && !validateColumn(column.getJavaType())) { isValid = false; break; } } return isValid; }
/** * Gets the composite id embeddables. * * @param embeddable * the embeddable * @param compositeEmbeddables * the composite embeddables * @param metaModel * the meta model * @return the composite id embeddables */ private void getCompositeIdEmbeddables(EmbeddableType embeddable, List compositeEmbeddables, MetamodelImpl metaModel) { compositeEmbeddables.add(embeddable.getJavaType().getSimpleName()); for (Object column : embeddable.getAttributes()) { Attribute columnAttribute = (Attribute) column; Field f = (Field) columnAttribute.getJavaMember(); if (columnAttribute.getJavaType().isAnnotationPresent(Embeddable.class)) { getCompositeIdEmbeddables(metaModel.embeddable(columnAttribute.getJavaType()), compositeEmbeddables, metaModel); } } }
/** * Sets the field value. * * @param entity * the entity * @param column * the column * @param value * the value */ private static void setFieldValue(Object entity, Attribute column, JsonElement value) { if (column.getJavaType().isAssignableFrom(byte[].class)) { PropertyAccessorHelper.set(entity, (Field) column.getJavaMember(), PropertyAccessorFactory.STRING.toBytes(value.getAsString())); } else { PropertyAccessorHelper.set( entity, (Field) column.getJavaMember(), PropertyAccessorHelper.fromSourceToTargetClass(column.getJavaType(), String.class, value.getAsString())); } }
/** * @param translatedColumns * @param metaModel * @param col */ private void onEmbeddable(List<String> translatedColumns, MetamodelImpl metaModel, Attribute col, boolean isEmbeddable) { if (isEmbeddable) { EmbeddableType embeddableType = metaModel.embeddable(col.getJavaType()); Set<Attribute> attributes = embeddableType.getAttributes(); for (Attribute attribute : attributes) { translatedColumns.add(((AbstractAttribute) attribute).getJPAColumnName()); } } else { translatedColumns.add(((AbstractAttribute) col).getJPAColumnName()); } }
private void prepareEmbeddedIdFields(Set<Attribute> embeddedAttributes, MetamodelImpl metaModel, Map<String, Object> embeddedIdFields, Document doc, EntityMetadata metadata) { for (Attribute attribute : embeddedAttributes) { if (!ReflectUtils.isTransientOrStatic((Field) attribute.getJavaMember())) { if (metaModel.isEmbeddable(attribute.getJavaType())) { EmbeddableType embeddable = metaModel.embeddable(attribute.getJavaType()); prepareEmbeddedIdFields(embeddable.getAttributes(), metaModel, embeddedIdFields, doc, metadata); } else { String columnName = ((AbstractAttribute) attribute).getJPAColumnName(); embeddedIdFields.put(columnName, doc.get(metadata.getEntityClazz().getSimpleName() + "." + columnName)); } } } }
private static void populateEmbeddedIdFieldsUtil(Set<Attribute> embeddedAttributes, MetamodelImpl metaModel, Set<String> embeddedIdFields) { for (Attribute attribute : embeddedAttributes) { if (!ReflectUtils.isTransientOrStatic((Field) attribute.getJavaMember())) { if (metaModel.isEmbeddable(attribute.getJavaType())) { EmbeddableType embeddable = metaModel.embeddable(attribute.getJavaType()); populateEmbeddedIdFieldsUtil(embeddable.getAttributes(), metaModel, embeddedIdFields); } else { String columnName = ((AbstractAttribute) attribute).getJPAColumnName(); embeddedIdFields.add(columnName); } } } }
private static void getAttributeOfEmbedddable(Map<String, Field> columnNameToFieldMap, Metamodel metaModel, Attribute attribute) { EmbeddableType embeddable = metaModel.embeddable(((AbstractAttribute) attribute).getBindableJavaType()); Iterator<Attribute> embeddableIter = embeddable.getAttributes().iterator(); while (embeddableIter.hasNext()) { Attribute embedAttrib = embeddableIter.next(); // Reason is to avoid in case embeddable attribute within // embeddable. if (!((MetamodelImpl) metaModel).isEmbeddable(embedAttrib.getJavaType())) { columnNameToFieldMap.put(((AbstractAttribute) embedAttrib).getJPAColumnName(), (Field) embedAttrib.getJavaMember()); } else { getAttributeOfEmbedddable(columnNameToFieldMap, metaModel, embedAttrib); } } }
/** * recursively populate all the fields present in partition key * * @param embeddedAttributes * @param metaModel * @param embeddedIdFields */ private static void populateEmbeddedIdFields(Set<Attribute> embeddedAttributes, MetamodelImpl metaModel, Set<String> embeddedIdFields) { for (Attribute attribute : embeddedAttributes) { if (!ReflectUtils.isTransientOrStatic((Field) attribute.getJavaMember())) { if (metaModel.isEmbeddable(attribute.getJavaType())) { EmbeddableType embeddable = metaModel.embeddable(attribute.getJavaType()); populateEmbeddedIdFieldsUtil(embeddable.getAttributes(), metaModel, embeddedIdFields); } } } }
/** * Gets the json object. * * @param columns * the columns * @param object * the object * @return the json object */ private static JsonObject getJsonObject(Set<Attribute> columns, Object object) { JsonObject jsonObject = new JsonObject(); for (Attribute column : columns) { if (!column.isAssociation()) { Object valueObject = PropertyAccessorHelper.getObject(object, (Field) column.getJavaMember()); jsonObject.add(((AbstractAttribute) column).getJPAColumnName(), getJsonPrimitive(valueObject, column.getJavaType())); } } return jsonObject; }
/** * Gets the json object. * * @param declaredFields * the declared fields * @param embeddableType * the embeddable type * @param embeddedObject * the embedded object * @return the json object */ private static JsonElement getJsonObject(Field[] declaredFields, EmbeddableType embeddableType, Object embeddedObject) { JsonObject jsonObject = new JsonObject(); for (Field field : declaredFields) { if (!ReflectUtils.isTransientOrStatic(field) && !embeddableType.getAttribute(field.getName()).isAssociation()) { Object valueObject = PropertyAccessorHelper.getObject(embeddedObject, field); jsonObject.add(((AbstractAttribute) (embeddableType.getAttribute(field.getName()))).getJPAColumnName(), getJsonPrimitive(valueObject, embeddableType.getAttribute(field.getName()).getJavaType())); } } return jsonObject; }
/** * index compositekey * * @param metadata * @param id * @param document * @param metaModel */ protected void indexCompositeKey(Set<Attribute> embeddedAttributes, EntityMetadata metadata, Object id, Document document, final MetamodelImpl metaModel) { // indexing individual fields of the composite key try { for (Attribute attribute : embeddedAttributes) { if (!ReflectUtils.isTransientOrStatic((java.lang.reflect.Field) attribute.getJavaMember())) { if (metaModel.isEmbeddable(attribute.getJavaType())) { EmbeddableType embeddable = metaModel.embeddable(attribute.getJavaType()); indexCompositeKey(embeddable.getAttributes(), metadata, ((java.lang.reflect.Field) attribute.getJavaMember()).get(id), document, metaModel); } else { String columnName = ((AbstractAttribute) attribute).getJPAColumnName(); addFieldToDocument(id, document, (java.lang.reflect.Field) attribute.getJavaMember(), columnName, metadata.getEntityClazz().getSimpleName()); } } } } catch (IllegalAccessException e) { LOG.error(e.getMessage()); } }
private void updateOrCreateIndexEmbeddedIdFields(Set<Attribute> embeddedAttributes, MetamodelImpl metaModel, Document document, EntityMetadata metadata, Object rowKey) { try { for (Attribute attribute : embeddedAttributes) { if (!ReflectUtils.isTransientOrStatic((Field) attribute.getJavaMember())) { if (metaModel.isEmbeddable(attribute.getJavaType())) { EmbeddableType embeddable = metaModel.embeddable(attribute.getJavaType()); updateOrCreateIndexEmbeddedIdFields(embeddable.getAttributes(), metaModel, document, metadata, ((Field) attribute.getJavaMember()).get(rowKey)); } else { String columnName = ((AbstractAttribute) attribute).getJPAColumnName(); Object embeddedColumn = PropertyAccessorHelper.getObject(rowKey, (Field) attribute.getJavaMember()); updateDocument(embeddedColumn.toString(), document, columnName); } } } } catch (IllegalAccessException e) { log.error(e.getMessage()); } }
private Object getObjectFromByteArray(EntityType entityType, byte[] value, String jpaColumnName, EntityMetadata m) { if (jpaColumnName != null) { String fieldName = m.getFieldName(jpaColumnName); if (fieldName != null) { Attribute attribute = fieldName != null ? entityType.getAttribute(fieldName) : null; EntityMetadata relationMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, attribute.getJavaType()); Object colValue = PropertyAccessorHelper.getObject(relationMetadata.getIdAttribute().getJavaType(), (byte[]) value); return colValue; } } log.warn("No value found for column {}, returning null.", jpaColumnName); return null; }
/** * Assert on embeddable type. * * @param <X> * the generic type * @param entityClazz * the entity clazz * @param attribute * the attribute * @param embeddableType * the embeddable type * @param attributeName * the attribute name * @param attributeClazz * the attribute clazz */ @SuppressWarnings({ "rawtypes", "unchecked" }) private <X> void assertOnEmbeddableType(Class entityClazz, Attribute<X, String> attribute, EmbeddableType<X> embeddableType, String attributeName, Class attributeClazz) { // Assert.assertEquals(entityClazz.getDeclaredFields().length, // embeddableType.getAttributes().size()); Assert.assertEquals(KunderaCoreUtils.countNonSyntheticFields(entityClazz), embeddableType.getAttributes() .size()); Assert.assertEquals(entityClazz, embeddableType.getJavaType()); Attribute attributeTwo = (Attribute) embeddableType.getAttribute(attributeName); Assert.assertNotNull(attribute); Assert.assertEquals(attributeClazz, attributeTwo.getJavaType()); Assert.assertEquals(attributeName, attributeTwo.getName()); }
/** * Assert on embeddable type. * * @param <X> * the generic type * @param entityClazz * the entity clazz * @param attribute * the attribute * @param embeddableType * the embeddable type * @param attributeName * the attribute name * @param attributeClazz * the attribute clazz */ @SuppressWarnings({ "rawtypes", "unchecked" }) private <X> void assertOnEmbeddableType(Class entityClazz, Attribute<X, String> attribute, EmbeddableType<X> embeddableType, String attributeName, Class attributeClazz) { Assert.assertNotSame(entityClazz.getDeclaredFields().length, embeddableType.getAttributes().size()); Assert.assertEquals(1, embeddableType.getAttributes().size()); Assert.assertEquals(entityClazz, embeddableType.getJavaType()); Attribute attributeTwo = (Attribute) embeddableType.getAttribute(attributeName); Assert.assertNotNull(attribute); Assert.assertEquals(attributeClazz, attributeTwo.getJavaType()); Assert.assertEquals(attributeName, attributeTwo.getName()); }
/** * Filter jpa parameter info. * * @param type * the type * @param name * the name * @param fieldName * the field name */ private void filterJPAParameterInfo(Type type, String name, String fieldName) { String attributeName = getAttributeName(fieldName); Attribute entityAttribute = ((MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(persistenceUnit)) .getEntityAttribute(entityClass, attributeName); Class fieldType = entityAttribute.getJavaType(); if (type.equals(Type.INDEXED)) { typedParameter.addJPAParameter(new JPAParameter(null, Integer.valueOf(name), fieldType)); } else { typedParameter.addJPAParameter(new JPAParameter(name, null, fieldType)); } }
/** * Assert on owner type attributes. * * @param managedType * the managed type * @param fieldName * the field name * @param fieldClazz * the field clazz * @param javaClazz * the java clazz */ private void assertOnOwnerTypeAttributes(AbstractManagedType managedType, String fieldName, Class fieldClazz, Class javaClazz) { Assert.assertNotNull(managedType); Assert.assertNotNull(managedType.getPluralAttributes()); Assert.assertEquals(4, managedType.getPluralAttributes().size()); Assert.assertNotNull(managedType.getAttribute(fieldName)); Assert.assertEquals(javaClazz, managedType.getAttribute(fieldName).getJavaType()); Assert.assertEquals(fieldClazz, ((PluralAttribute) managedType.getAttribute(fieldName)).getElementType() .getJavaType()); Assert.assertEquals(BindableType.PLURAL_ATTRIBUTE, ((PluralAttribute) managedType.getAttribute(fieldName)).getBindableType()); Assert.assertNotNull(((PluralAttribute) managedType.getAttribute(fieldName)).getJavaMember()); Assert.assertNotNull(fieldName, ((PluralAttribute) managedType.getAttribute(fieldName)).getJavaMember() .getName()); }