javax.persistence.ElementCollection Java Examples

@Override
public Optional<SerializeType> getSerializeType(BeanAttributeInformation attributeDesc) {
    Optional<OneToMany> oneToMany = attributeDesc.getAnnotation(OneToMany.class);
    if (oneToMany.isPresent()) {
        return toSerializeType(oneToMany.get().fetch());
    }
    Optional<ManyToOne> manyToOne = attributeDesc.getAnnotation(ManyToOne.class);
    if (manyToOne.isPresent()) {
        return toSerializeType(manyToOne.get().fetch());
    }
    Optional<ManyToMany> manyToMany = attributeDesc.getAnnotation(ManyToMany.class);
    if (manyToMany.isPresent()) {
        return toSerializeType(manyToMany.get().fetch());
    }
    Optional<ElementCollection> elementCollection = attributeDesc.getAnnotation(ElementCollection.class);
    if (elementCollection.isPresent()) {
        return toSerializeType(elementCollection.get().fetch());
    }
    return Optional.empty();
}
 

protected boolean isJpaLazy(Collection<Annotation> annotations, boolean isAssociation) {
	for (Annotation annotation : annotations) {
		if (annotation instanceof OneToMany) {
			OneToMany oneToMany = (OneToMany) annotation;
			return oneToMany.fetch() == FetchType.LAZY;
		}
		if (annotation instanceof ManyToOne) {
			ManyToOne manyToOne = (ManyToOne) annotation;
			return manyToOne.fetch() == FetchType.LAZY;
		}
		if (annotation instanceof ManyToMany) {
			ManyToMany manyToMany = (ManyToMany) annotation;
			return manyToMany.fetch() == FetchType.LAZY;
		}
		if (annotation instanceof ElementCollection) {
			ElementCollection elementCollection = (ElementCollection) annotation;
			return elementCollection.fetch() == FetchType.LAZY;
		}
	}
	return isAssociation;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@CollectionTable(
      name="race_award_category_depths",
      joinColumns=@JoinColumn(name="ac_id")
)
protected List<AwardDepth> getCustomDepthList(){
    return customDepthList;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@MapKeyColumn(name="chip", insertable=false,updatable=false)
@Column(name="bib")
@CollectionTable(name="bib2chipmap", joinColumns=@JoinColumn(name="bib2chip_id"))
public Map<String, String> getChip2BibMap() {
    //System.out.println("TLI.getAttributes called, returning " + attributes.size() + " attributes");
    return chip2bibMap;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@MapKeyColumn(name="attribute", insertable=false,updatable=false)
@Column(name="value")
@CollectionTable(name="event_options_attributes", joinColumns=@JoinColumn(name="event_id"))
//@OrderColumn(name = "index_id")
private Map<String, String> getAttributes() {
    System.out.println("EventOptions::getAttributes()");
    attributes.keySet().forEach(k -> {
    System.out.println("  " + k + " -> " + attributes.get(k));
    });
    return attributes;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@MapKeyColumn(name="attribute_id")
@Column(name="attribute_value")
@CollectionTable(name="participant_attributes", joinColumns=@JoinColumn(name="participant_id"))
public Map<Integer,String> getCustomAttributes(){
    return customAttributeMap;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@MapKeyColumn(name="attribute", insertable=false,updatable=false)
@Column(name="value")
@CollectionTable(name="timing_location_input_attributes", joinColumns=@JoinColumn(name="tli_id"))
@OrderColumn(name = "index_id")
public Map<String, String> getAttributes() {
    //System.out.println("TLI.getAttributes called, returning " + attributes.size() + " attributes");
    return attributes;
}
 

@Override
@ElementCollection(fetch = FetchType.LAZY)
@CollectionTable(name = "MCRCategoryLabels",
    joinColumns = @JoinColumn(name = "category"),
    uniqueConstraints = {
        @UniqueConstraint(columnNames = { "category", "lang" }) })
public Set<MCRLabel> getLabels() {
    return super.getLabels();
}
 

/**
 * Returns all set parameters of the job.
 * 
 * @return the job parameters
 */
@ElementCollection(fetch = FetchType.EAGER)
@CollectionTable(name = "MCRJobParameter", joinColumns = @JoinColumn(name = "jobID"))
@MapKeyColumn(name = "paramKey", length = 128)
@Column(name = "paramValue", length = 255)
public Map<String, String> getParameters() {
    return parameters;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@CollectionTable(name = "MCRUserAttr",
    joinColumns = @JoinColumn(name = "id"),
    indexes = { @Index(name = "MCRUserAttributes", columnList = "name, value"),
        @Index(name = "MCRUserValues", columnList = "value") })
@SortNatural
@XmlElementWrapper(name = "attributes")
@XmlElement(name = "attribute")
public SortedSet<MCRUserAttribute> getAttributes() {
    return this.attributes;
}
 

@ElementCollection
@MapKeyColumn(name = "parameters_idx")
@Column(name = "parameters_elt")
@CollectionTable(name = "info_parameters")
public Map<String, String> getParameters() {
    return parameters;
}
 

/**
 * As per sections 12.2.3.23.9, 12.2.4.8.9 and 12.2.5.3.6 of the JPA 2.0
 * specification, the element-collection subelement completely overrides the
 * mapping for the specified field or property.  Thus, any methods which
 * might in some contexts merge with annotations must not do so in this
 * context.
 */
private void getElementCollection(List<Annotation> annotationList, XMLContext.Default defaults) {
	for ( Element element : elementsForProperty ) {
		if ( "element-collection".equals( element.getName() ) ) {
			AnnotationDescriptor ad = new AnnotationDescriptor( ElementCollection.class );
			addTargetClass( element, ad, "target-class", defaults );
			getFetchType( ad, element );
			getOrderBy( annotationList, element );
			getOrderColumn( annotationList, element );
			getMapKey( annotationList, element );
			getMapKeyClass( annotationList, element, defaults );
			getMapKeyTemporal( annotationList, element );
			getMapKeyEnumerated( annotationList, element );
			getMapKeyColumn( annotationList, element );
			buildMapKeyJoinColumns( annotationList, element );
			Annotation annotation = getColumn( element.element( "column" ), false, element );
			addIfNotNull( annotationList, annotation );
			getTemporal( annotationList, element );
			getEnumerated( annotationList, element );
			getLob( annotationList, element );
			//Both map-key-attribute-overrides and attribute-overrides
			//translate into AttributeOverride annotations, which need
			//need to be wrapped in the same AttributeOverrides annotation.
			List<AttributeOverride> attributes = new ArrayList<>();
			attributes.addAll( buildAttributeOverrides( element, "map-key-attribute-override" ) );
			attributes.addAll( buildAttributeOverrides( element, "attribute-override" ) );
			annotation = mergeAttributeOverrides( defaults, attributes, false );
			addIfNotNull( annotationList, annotation );
			annotation = getAssociationOverrides( element, defaults, false );
			addIfNotNull( annotationList, annotation );
			getCollectionTable( annotationList, element, defaults );
			annotationList.add( AnnotationFactory.create( ad ) );
			getAccessType( annotationList, element );
		}
	}
}
 

private static void bindCollectionSecondPass(
		Collection collValue,
		PersistentClass collectionEntity,
		Ejb3JoinColumn[] joinColumns,
		boolean cascadeDeleteEnabled,
		XProperty property,
		PropertyHolder propertyHolder,
		MetadataBuildingContext buildingContext) {
	try {
		BinderHelper.createSyntheticPropertyReference(
				joinColumns,
				collValue.getOwner(),
				collectionEntity,
				collValue,
				false,
				buildingContext
		);
	}
	catch (AnnotationException ex) {
		throw new AnnotationException( "Unable to map collection " + collValue.getOwner().getClassName() + "." + property.getName(), ex );
	}
	SimpleValue key = buildCollectionKey( collValue, joinColumns, cascadeDeleteEnabled, property, propertyHolder, buildingContext );
	if ( property.isAnnotationPresent( ElementCollection.class ) && joinColumns.length > 0 ) {
		joinColumns[0].setJPA2ElementCollection( true );
	}
	TableBinder.bindFk( collValue.getOwner(), collectionEntity, joinColumns, key, false, buildingContext );
}
 

@ElementCollection(fetch = FetchType.EAGER)
    @Column(name="wave_id", nullable=false)
    @CollectionTable(name="part2wave", joinColumns=@JoinColumn(name="participant_id"))
//    @OrderColumn(name = "index_id")
    public Set<Integer> getWaveIDs() {
        return waveIDSet;  
    }
 

@ElementCollection(fetch = FetchType.EAGER)
@CollectionTable(
      name="race_age_group_increments",
      joinColumns=@JoinColumn(name="ag_id")
)
protected List<AgeGroupIncrement> getCustomIncrementsList(){
    return customIncrementList;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@CollectionTable(
      name="race_award_category_filters",
      joinColumns=@JoinColumn(name="ac_id")
)
protected List<AwardFilter> getFilterList(){
    return filters;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@CollectionTable(
      name="race_award_category_subdivide_list",
      joinColumns=@JoinColumn(name="ac_id")
)
@Column(name="attribute")
protected Set<String> getSubDivideList(){
    return splitBy;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@OneToMany(mappedBy="raceAward",cascade={CascadeType.PERSIST, CascadeType.REMOVE},fetch = FetchType.EAGER)
@Fetch(FetchMode.SELECT)
@OrderColumn(name = "category_priority")
public List<AwardCategory> getAwardCategories(){
    return awardCategories;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@MapKeyColumn(name="attribute", insertable=false,updatable=false)
@Column(name="value")
@CollectionTable(name="race_awards_attributes", joinColumns=@JoinColumn(name="race_id"))
@OrderColumn(name = "index_id")
private Map<String, String> getAttributes() {
    return attributes;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@MapKeyColumn(name="attribute", insertable=false,updatable=false)
@Column(name="value")
@CollectionTable(name="race_attributes", joinColumns=@JoinColumn(name="race_id"))
private Map<String, String> getAttributes() {
    return attributes;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@MapKeyColumn(name="attribute", insertable=false,updatable=false)
@Column(name="value")
@CollectionTable(name="race_output_attributes", joinColumns=@JoinColumn(name="output_id"))
@OrderColumn(name = "id")
private Map<String, String> getAttributes() {
    return attributes;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@MapKeyColumn(name="split_id", insertable=false,updatable=false)
@Column(name="split_time",nullable=false)
@CollectionTable(name="split_results", joinColumns=@JoinColumn(name="result_id"))
public Map<Integer,Long> getSplitMap(){
    return splitMap;
}
 

private boolean hasJpaAnnotations(MetaAttribute attribute) {
	List<Class<? extends Annotation>> annotationClasses = Arrays.asList(Id.class, EmbeddedId.class, Column.class,
			ManyToMany.class, ManyToOne.class, OneToMany.class, OneToOne.class, Version.class,
			ElementCollection.class);
	for (Class<? extends Annotation> annotationClass : annotationClasses) {
		if (attribute.getAnnotation(annotationClass) != null) {
			return true;
		}
	}
	return false;
}
 

@ElementCollection(fetch = FetchType.LAZY)
@CollectionTable(name = "TASK_DATA_DEPENDENCIES", joinColumns = { @JoinColumn(name = "JOB_ID", referencedColumnName = "TASK_ID_JOB"),
                                                                  @JoinColumn(name = "TASK_ID", referencedColumnName = "TASK_ID_TASK") }, indexes = { @Index(name = "TASK_DATA_DEP_JOB_ID", columnList = "JOB_ID"),
                                                                                                                                                      @Index(name = "TASK_DATA_DEP_TASK_ID_JOB_ID", columnList = "TASK_ID,JOB_ID"),
                                                                                                                                                      @Index(name = "TASK_DATA_DEP_TASK_ID", columnList = "TASK_ID"), })
@BatchSize(size = 100)
public List<DBTaskId> getDependentTasks() {
    return dependentTasks;
}
 

@ElementCollection(fetch = FetchType.LAZY)
@CollectionTable(name = "TASK_DATA_JOINED_BRANCHES", joinColumns = { @JoinColumn(name = "JOB_ID", referencedColumnName = "TASK_ID_JOB"),
                                                                     @JoinColumn(name = "TASK_ID", referencedColumnName = "TASK_ID_TASK") }, indexes = { @Index(name = "TASK_DATA_JB_JOB_ID", columnList = "JOB_ID"),
                                                                                                                                                         @Index(name = "TASK_DATA_JB_TASK_ID_JOB_ID", columnList = "TASK_ID,JOB_ID"),
                                                                                                                                                         @Index(name = "TASK_DATA_JB_TASK_ID", columnList = "TASK_ID"), })
@BatchSize(size = 100)
public List<DBTaskId> getJoinedBranches() {
    return joinedBranches;
}
 

@ElementCollection(targetClass = Role.class, fetch = FetchType.EAGER)
@CollectionTable(name = "USER_ROLES", joinColumns = @JoinColumn(name = "USER_ID"))
@Enumerated(EnumType.STRING)
@Column(name = "role", nullable = false)
public Set<Role> getRoles() {
	return roles;
}
 

@ElementCollection(targetClass = Permission.class, fetch = FetchType.EAGER)
@CollectionTable(name = "USER_PERMISSIONS", joinColumns = @JoinColumn(name = "USER_ID"))
@Enumerated(EnumType.STRING)
@Column(name = "permission", nullable = false)
public Set<Permission> getPermissions() {
	return permissions;
}
 

@ElementCollection
public List<String> getAuthors() {
    return authors;
}
 

@Override
public Class<?> getAnnotationType() {
	return ElementCollection.class;
}
 

@ElementCollection(fetch = FetchType.EAGER)
@OrderColumn
@Lob
public List<String> getApplicationCertificates() {
    return applicationCertificates;
}