javax.persistence.JoinColumns Java Examples

private void addForeignKey(final Attribute<?, ?> jpaAttribute) throws ODataJPAModelException,
    ODataJPARuntimeException {

  AnnotatedElement annotatedElement = (AnnotatedElement) jpaAttribute.getJavaMember();
  joinColumnNames = null;
  if (annotatedElement == null) {
    return;
  }
  JoinColumn joinColumn = annotatedElement.getAnnotation(JoinColumn.class);
  if (joinColumn == null) {
    JoinColumns joinColumns = annotatedElement.getAnnotation(JoinColumns.class);
    if (joinColumns != null) {
      for (JoinColumn jc : joinColumns.value()) {
        buildForeignKey(jc, jpaAttribute);
      }
    }
  } else {
    buildForeignKey(joinColumn, jpaAttribute);
  }
}
 

private void buildJoinColumns(List<Annotation> annotationList, Element element) {
	JoinColumn[] joinColumns = getJoinColumns( element, false );
	if ( joinColumns.length > 0 ) {
		AnnotationDescriptor ad = new AnnotationDescriptor( JoinColumns.class );
		ad.setValue( "value", joinColumns );
		annotationList.add( AnnotationFactory.create( ad ) );
	}
}
 

public XAnnotation<?> createJoinColumns(List<JoinColumn> cJoinColumns) {
	return transform(
			JoinColumns.class,
			javax.persistence.JoinColumn.class,
			cJoinColumns,
			new Transformer<JoinColumn, XAnnotation<javax.persistence.JoinColumn>>() {
				public XAnnotation<javax.persistence.JoinColumn> transform(
						JoinColumn input) {
					return createJoinColumn(input);
				}
			});
}
 

/**
 * @return the configuration
 */
@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.REMOVE)
@JoinColumns({
		@JoinColumn(name = "clusterId", referencedColumnName = "clusterId"),
		@JoinColumn(name = "host", referencedColumnName = "publicIp") })
public List<Event> getEvents() {
	return events;
}
 

/**
 * @return the configuration
 */
@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.REMOVE)
@JoinColumns({
		@JoinColumn(name = "clusterId", referencedColumnName = "clusterId"),
		@JoinColumn(name = "host", referencedColumnName = "publicIp") })
public List<Configuration> getConfiguration() {
	return configuration;
}
 

private static int addProperty(
		PropertyContainer propertyContainer,
		XProperty property,
		List<PropertyData> inFlightPropertyDataList,
		MetadataBuildingContext context) {
	// see if inFlightPropertyDataList already contains a PropertyData for this name,
	// and if so, skip it..
	for ( PropertyData propertyData : inFlightPropertyDataList ) {
		if ( propertyData.getPropertyName().equals( property.getName() ) ) {
			// EARLY EXIT!!!
			return 0;
		}
	}

	final XClass declaringClass = propertyContainer.getDeclaringClass();
	final XClass entity = propertyContainer.getEntityAtStake();
	int idPropertyCounter = 0;
	PropertyData propertyAnnotatedElement = new PropertyInferredData(
			declaringClass,
			property,
			propertyContainer.getClassLevelAccessType().getType(),
			context.getBootstrapContext().getReflectionManager()
	);

	/*
	 * put element annotated by @Id in front
	 * since it has to be parsed before any association by Hibernate
	 */
	final XAnnotatedElement element = propertyAnnotatedElement.getProperty();
	if ( element.isAnnotationPresent( Id.class ) || element.isAnnotationPresent( EmbeddedId.class ) ) {
		inFlightPropertyDataList.add( 0, propertyAnnotatedElement );
		/**
		 * The property must be put in hibernate.properties as it's a system wide property. Fixable?
		 * TODO support true/false/default on the property instead of present / not present
		 * TODO is @Column mandatory?
		 * TODO add method support
		 */
		if ( context.getBuildingOptions().isSpecjProprietarySyntaxEnabled() ) {
			if ( element.isAnnotationPresent( Id.class ) && element.isAnnotationPresent( Column.class ) ) {
				String columnName = element.getAnnotation( Column.class ).name();
				for ( XProperty prop : declaringClass.getDeclaredProperties( AccessType.FIELD.getType() ) ) {
					if ( !prop.isAnnotationPresent( MapsId.class ) ) {
						/**
						 * The detection of a configured individual JoinColumn differs between Annotation
						 * and XML configuration processing.
						 */
						boolean isRequiredAnnotationPresent = false;
						JoinColumns groupAnnotation = prop.getAnnotation( JoinColumns.class );
						if ( (prop.isAnnotationPresent( JoinColumn.class )
								&& prop.getAnnotation( JoinColumn.class ).name().equals( columnName )) ) {
							isRequiredAnnotationPresent = true;
						}
						else if ( prop.isAnnotationPresent( JoinColumns.class ) ) {
							for ( JoinColumn columnAnnotation : groupAnnotation.value() ) {
								if ( columnName.equals( columnAnnotation.name() ) ) {
									isRequiredAnnotationPresent = true;
									break;
								}
							}
						}
						if ( isRequiredAnnotationPresent ) {
							//create a PropertyData fpr the specJ property holding the mapping
							PropertyData specJPropertyData = new PropertyInferredData(
									declaringClass,
									//same dec
									prop,
									// the actual @XToOne property
									propertyContainer.getClassLevelAccessType().getType(),
									//TODO we should get the right accessor but the same as id would do
									context.getBootstrapContext().getReflectionManager()
							);
							context.getMetadataCollector().addPropertyAnnotatedWithMapsIdSpecj(
									entity,
									specJPropertyData,
									element.toString()
							);
						}
					}
				}
			}
		}

		if ( element.isAnnotationPresent( ManyToOne.class ) || element.isAnnotationPresent( OneToOne.class ) ) {
			context.getMetadataCollector().addToOneAndIdProperty( entity, propertyAnnotatedElement );
		}
		idPropertyCounter++;
	}
	else {
		inFlightPropertyDataList.add( propertyAnnotatedElement );
	}
	if ( element.isAnnotationPresent( MapsId.class ) ) {
		context.getMetadataCollector().addPropertyAnnotatedWithMapsId( entity, propertyAnnotatedElement );
	}

	return idPropertyCounter;
}
 

@Override
public Class<? extends Annotation> annotationType() {
  return JoinColumns.class;
}
 

/**
 * @return the configuration
 */
@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.REMOVE)
@JoinColumns({ @JoinColumn(name = "node", referencedColumnName = "publicIp") })
public List<Service> getServices() {
	return services;
}
 

private void extractJoinColumns() {
  /*
   * Check against Static Buffer whether the join column was already
   * extracted.
   */
  if (!jpaAttribute.equals(bufferedJPAAttribute)) {
    bufferedJPAAttribute = jpaAttribute;
    bufferedJoinColumns.clear();
  } else if (bufferedJoinColumns.isEmpty()) {
    roleExists = false;
    return;
  } else {
    roleExists = true;
    return;
  }

  AnnotatedElement annotatedElement = (AnnotatedElement) jpaAttribute
      .getJavaMember();

  if (annotatedElement == null) {
    return;
  }

  JoinColumn joinColumn = annotatedElement
      .getAnnotation(JoinColumn.class);
  if (joinColumn == null) {
    JoinColumns joinColumns = annotatedElement
        .getAnnotation(JoinColumns.class);

    if (joinColumns != null) {
      JoinColumn[] joinColumnArray = joinColumns.value();

      for (JoinColumn element : joinColumnArray) {
        bufferedJoinColumns.add(element);
      }
    } else {
      return;
    }
  } else {
    bufferedJoinColumns.add(joinColumn);
  }
  roleExists = true;
}
 

@Override
public Class<? extends Annotation> annotationType() {
  return JoinColumns.class;
}