Refine search
@Embedded @AttributeOverrides(value = { @AttributeOverride(name = "tenor", column = @Column(name = "SHORT_TENOR")), @AttributeOverride(name = "fixedLeg.paymentFrequency", column = @Column(name = "SHORT_FIXED_FREQUENCY")), @AttributeOverride(name = "fixedLeg.rate", column = @Column(name = "SHORT_FIXED_RATE")), @AttributeOverride(name = "floatLeg.paymentFrequency", column = @Column(name = "SHORT_FLOAT_FREQUENCY")), @AttributeOverride(name = "floatLeg.rateIndex", column = @Column(name = "SHORT_FLOAT_RATEINDEX")), @AttributeOverride(name = "floatLeg.rateSpread", column = @Column(name = "SHORT_FLOAT_RATESPREAD")) }) public Swap getShortSwap() { return shortSwap; }
AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 2, overrides.length ); assertEquals( "field1", overrides[0].name() ); assertEquals( "", overrides[0].column().name() ); assertFalse( overrides[0].column().unique() ); assertTrue( overrides[0].column().nullable() ); assertTrue( overrides[0].column().insertable() ); assertTrue( overrides[0].column().updatable() );
@AttributeOverrides( { @AttributeOverride(name = "size", column = @Column(name = "summ_size", table = "BookSummary")), @AttributeOverride(name = "text", column = @Column(table = "BookSummary")) }) public Summary getSummary() { return summary; }
/** * Tests that map-key-attribute-override and attribute-override elements * both end up in the AttributeOverrides annotation. */ @Test public void testMixedAttributeOverrides() throws Exception { reader = getReader( Entity3.class, "field1", "element-collection.orm23.xml" ); assertAnnotationPresent( ElementCollection.class ); assertAnnotationNotPresent( AttributeOverride.class ); assertAnnotationPresent( AttributeOverrides.class ); AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 2, overrides.length ); assertEquals( "field1", overrides[0].name() ); assertEquals( "col1", overrides[0].column().name() ); assertEquals( "field2", overrides[1].name() ); assertEquals( "col2", overrides[1].column().name() ); }
/** * @param mergeWithAnnotations Whether to use Java annotations for this * element, if present and not disabled by the XMLContext defaults. * In some contexts (such as an association mapping) merging with * annotations is never allowed. */ private AttributeOverrides mergeAttributeOverrides(XMLContext.Default defaults, List<AttributeOverride> attributes, boolean mergeWithAnnotations) { if ( mergeWithAnnotations && defaults.canUseJavaAnnotations() ) { AttributeOverride annotation = getPhysicalAnnotation( AttributeOverride.class ); addAttributeOverrideIfNeeded( annotation, attributes ); AttributeOverrides annotations = getPhysicalAnnotation( AttributeOverrides.class ); if ( annotations != null ) { for ( AttributeOverride current : annotations.value() ) { addAttributeOverrideIfNeeded( current, attributes ); } } } if ( attributes.size() > 0 ) { AnnotationDescriptor ad = new AnnotationDescriptor( AttributeOverrides.class ); ad.setValue( "value", attributes.toArray( new AttributeOverride[attributes.size()] ) ); return AnnotationFactory.create( ad ); } else { return null; } }
@EmbeddedId @AttributeOverrides( { @AttributeOverride(name = "firstId", column = @Column(name = "idcolumn", nullable = false)), @AttributeOverride(name = "secondId", column = @Column(name = "idcolumn_second", nullable = false, length = 50)), @AttributeOverride(name = "thirdId", column = @Column(name = "thirdcolumn", nullable = false, length = 20)) }) public TableBId getId() { return this.id; }
/** * When there's a single attribute override, we still wrap it with an * AttributeOverrides annotation. */ @Test public void testSingleAttributeOverride() throws Exception { reader = getReader( Entity3.class, "field1", "element-collection.orm21.xml" ); assertAnnotationPresent( ElementCollection.class ); assertAnnotationNotPresent( AttributeOverride.class ); assertAnnotationPresent( AttributeOverrides.class ); AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 1, overrides.length ); assertEquals( "field1", overrides[0].name() ); assertEquals( "col1", overrides[0].column().name() ); }
private static Map<String, Column[]> buildColumnOverride(XAnnotatedElement element, String path) { Map<String, Column[]> columnOverride = new HashMap<String, Column[]>(); if ( element == null ) return columnOverride; AttributeOverride singleOverride = element.getAnnotation( AttributeOverride.class ); AttributeOverrides multipleOverrides = element.getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides; if ( singleOverride != null ) { overrides = new AttributeOverride[] { singleOverride }; } else if ( multipleOverrides != null ) { overrides = multipleOverrides.value(); } else { overrides = null; } //fill overridden columns if ( overrides != null ) { for (AttributeOverride depAttr : overrides) { columnOverride.put( StringHelper.qualify( path, depAttr.name() ), new Column[] { depAttr.column() } ); } } return columnOverride; }
private boolean mappingDefinedAttributeOverrideOnMapKey(XProperty property) { if ( property.isAnnotationPresent( AttributeOverride.class ) ) { return namedMapKey( property.getAnnotation( AttributeOverride.class ) ); } if ( property.isAnnotationPresent( AttributeOverrides.class ) ) { final AttributeOverrides annotations = property.getAnnotation( AttributeOverrides.class ); for ( AttributeOverride attributeOverride : annotations.value() ) { if ( namedMapKey( attributeOverride ) ) { return true; } } } return false; }
/** * @author Brett Meyer */ @Embeddable public class EmbeddableA { @Embedded @AttributeOverrides({@AttributeOverride(name = "embedAttrB" , column = @Column(table = "TableB"))}) private EmbeddableB embedB; private String embedAttrA; public EmbeddableB getEmbedB() { return embedB; } public void setEmbedB(EmbeddableB embedB) { this.embedB = embedB; } public String getEmbedAttrA() { return embedAttrA; } public void setEmbedAttrA(String embedAttrA) { this.embedAttrA = embedAttrA; } }
@EmbeddedId @AttributeOverrides({ @AttributeOverride(name = "brand", column = @Column(name = "computer_brand")), @AttributeOverride(name = "model", column = @Column(name = "computer_model")) }) public ComputerPk getId() { return id; }
AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 2, overrides.length ); assertEquals( "field1", overrides[0].name() ); assertEquals( "", overrides[0].column().name() ); assertFalse( overrides[0].column().unique() ); assertTrue( overrides[0].column().nullable() ); assertTrue( overrides[0].column().insertable() ); assertTrue( overrides[0].column().updatable() );
/** * When there's a single map key attribute override, we still wrap it with * an AttributeOverrides annotation. */ @Test public void testSingleMapKeyAttributeOverride() throws Exception { reader = getReader( Entity3.class, "field1", "many-to-many.orm10.xml" ); assertAnnotationPresent( ManyToMany.class ); assertAnnotationNotPresent( MapKey.class ); assertAnnotationNotPresent( MapKeyClass.class ); assertAnnotationNotPresent( MapKeyTemporal.class ); assertAnnotationNotPresent( MapKeyEnumerated.class ); assertAnnotationNotPresent( MapKeyColumn.class ); assertAnnotationNotPresent( MapKeyJoinColumns.class ); assertAnnotationNotPresent( MapKeyJoinColumn.class ); assertAnnotationNotPresent( AttributeOverride.class ); assertAnnotationPresent( AttributeOverrides.class ); AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 1, overrides.length ); assertEquals( "field1", overrides[0].name() ); assertEquals( "col1", overrides[0].column().name() ); }
/** * INTERNAL: (Overridden in XMLEmbeddedAccessor and XMLEmbeddedIdAccessor) * * Process an @AttributeOverrides for an embedded object, that is, an * aggregate object mapping in TopLink. * * It will also look for an @AttributeOverride. */ protected void processAttributeOverrides(AggregateObjectMapping mapping) { // Look for an @AttributeOverrides. AttributeOverrides attributeOverrides = getAnnotation(AttributeOverrides.class); if (attributeOverrides != null) { for (AttributeOverride attributeOverride : attributeOverrides.value()) { processAttributeOverride(mapping, new MetadataColumn(attributeOverride.column(), attributeOverride.name(), getAnnotatedElement())); } } // Look for an @AttributeOverride. AttributeOverride attributeOverride = getAnnotation(AttributeOverride.class); if (attributeOverride != null) { processAttributeOverride(mapping, new MetadataColumn(attributeOverride.column(), attributeOverride.name(), getAnnotatedElement())); } }
public static final AttributeOverride[] getAttributeOverrides(AnnotatedElement ae) { AttributeOverride[] overrides = null; AttributeOverrides aos = ae.getAnnotation(AttributeOverrides.class); if (aos != null) { overrides = aos.value(); } if (overrides == null || overrides.length == 0) { AttributeOverride override = ae.getAnnotation(AttributeOverride.class); if (override != null) { overrides = new AttributeOverride[1]; overrides[0] = override; } else { overrides = new AttributeOverride[0]; } } return overrides; }
@Entity @Table( name = "AGG_TYPE" ) public static class AggregatedTypeValue { @Id UUID id; @Embedded @AttributeOverrides({ @AttributeOverride(name = "type", column = @Column(name = "content_type")), @AttributeOverride(name = "value", column = @Column(name = "content_value")) }) TypeValue content; @CollectionTable( name = "ATTRIBUTES" ) @ElementCollection(fetch = FetchType.EAGER) @MapKeyColumn(name = "attribute_name") @AttributeOverrides({ @AttributeOverride(name = "value.type", column = @Column(name = "attribute_type")), @AttributeOverride(name = "value.value", column = @Column(name = "attribute_value")) }) Map<String, TypeValue> attributes; } }
/** * @author Emmanuel Bernard */ @AttributeOverrides(value = { @AttributeOverride(name = "swap.tenor", column = @Column(name = "TENOR")), //should be ovvriden by deal @AttributeOverride(name = "id", column = @Column(name = "NOTONIALDEAL_ID")) }) @MappedSuperclass public class NotonialDeal extends Deal { /** * Notional amount of both IRSs. */ private double notional; public double getNotional() { return notional; } public void setNotional(double notional) { this.notional = notional; } }
AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 2, overrides.length ); assertEquals( "field1", overrides[0].name() ); assertEquals( "", overrides[0].column().name() ); assertFalse( overrides[0].column().unique() ); assertTrue( overrides[0].column().nullable() ); assertTrue( overrides[0].column().insertable() ); assertTrue( overrides[0].column().updatable() );
/** * When there's a single map key attribute override, we still wrap it with * an AttributeOverrides annotation. */ @Test public void testSingleMapKeyAttributeOverride() throws Exception { reader = getReader( Entity3.class, "field1", "element-collection.orm10.xml" ); assertAnnotationPresent( ElementCollection.class ); assertAnnotationNotPresent( MapKey.class ); assertAnnotationNotPresent( MapKeyClass.class ); assertAnnotationNotPresent( MapKeyTemporal.class ); assertAnnotationNotPresent( MapKeyEnumerated.class ); assertAnnotationNotPresent( MapKeyColumn.class ); assertAnnotationNotPresent( MapKeyJoinColumns.class ); assertAnnotationNotPresent( MapKeyJoinColumn.class ); assertAnnotationNotPresent( AttributeOverride.class ); assertAnnotationPresent( AttributeOverrides.class ); AttributeOverrides overridesAnno = reader .getAnnotation( AttributeOverrides.class ); AttributeOverride[] overrides = overridesAnno.value(); assertEquals( 1, overrides.length ); assertEquals( "field1", overrides[0].name() ); assertEquals( "col1", overrides[0].column().name() ); }