@Override public Optional<Boolean> isPostable(BeanAttributeInformation attributeDesc) { Optional<Column> column = attributeDesc.getAnnotation(Column.class); Optional<Version> version = attributeDesc.getAnnotation(Version.class); if (!version.isPresent() && column.isPresent()) { return Optional.of(column.get().insertable()); } Optional<GeneratedValue> generatedValue = attributeDesc.getAnnotation(GeneratedValue.class); if (generatedValue.isPresent()) { return Optional.of(false); } return Optional.empty(); }
@Override public Optional<Boolean> isPatchable(BeanAttributeInformation attributeDesc) { Optional<Column> column = attributeDesc.getAnnotation(Column.class); Optional<Version> version = attributeDesc.getAnnotation(Version.class); if (!version.isPresent() && column.isPresent()) { return Optional.of(column.get().updatable()); } Optional<GeneratedValue> generatedValue = attributeDesc.getAnnotation(GeneratedValue.class); if (generatedValue.isPresent()) { return Optional.of(false); } return Optional.empty(); }
private boolean include(Class<?> type, PropertyDescriptor descriptor) { Field field = findField(type, descriptor.getName()); if (field == null) { return false; } if (hasAnnotation(Version.class, descriptor.getReadMethod(), field)) { return false; } if (hasAnnotation(Transient.class, descriptor.getReadMethod(), field)) { return false; } if (Modifier.isStatic(field.getModifiers())) { return false; } if (Modifier.isTransient(field.getModifiers())) { return false; } return true; }
/** * Builds the property for the given attribute. * * @param attribute * the attribute to inspect * @param columnMetadata * the attached (or overriden) column metadata * @param override * the AssociationOverride found for this attribute * @return the property that represents the attribute or {@code null} if not persistent */ <X> Property<X, ?> buildProperty(final AttributeAccessor attribute, final Column columnMetadata, final AssociationOverride override) { if (attribute.isPersistent()) { if (CollectionProperty.isCollectionProperty(attribute)) { return new CollectionProperty<>(this, attribute, override); } else if (MapProperty.isMapProperty(attribute)) { return new MapProperty<>(this, attribute, override); } else if (EntityProperty.isEntityProperty(attribute)) { return new EntityProperty<>(this.context, getTable(), attribute, override); } else if (attribute.isAnnotationPresent(Embedded.class)) { return new EmbeddedProperty<>(this, attribute); } else if (attribute.isAnnotationPresent(Version.class)) { return new VersionProperty<>(this.context, this.table, attribute, columnMetadata); } else { return new PrimitiveProperty<>(this.context, this.table, attribute, columnMetadata); } } return null; }
public static Property<Serializable> getVersionProperty(Class<?> entityClass) { List<PropertyCriteria> criteriaList = new LinkedList<PropertyCriteria>(); criteriaList.add(new AnnotatedPropertyCriteria(Version.class)); String fromMappingFiles = PersistenceUnitDescriptorProvider.getInstance().versionField(entityClass); if (fromMappingFiles != null) { criteriaList.add(new NamedPropertyCriteria(fromMappingFiles)); } for (PropertyCriteria criteria : criteriaList) { PropertyQuery<Serializable> query = PropertyQueries.<Serializable> createQuery(entityClass).addCriteria(criteria); Property<Serializable> result = query.getFirstResult(); if (result != null) { return result; } } return null; }
@Override public Object process(AnnotationInfo ctx, Object value) { if (ctx.isAnnotationPresent(Id.class) || ctx.isAnnotationPresent(Version.class)) { return null; } return value; }
public static String getRecVersionFieldName(Class<? extends BaseMybatisModel> modelClass) { for (Method method : modelClass.getMethods()) { String methodName = method.getName(); if (method.isAnnotationPresent(Version.class)) { return methodName.substring(3, 4).toLowerCase() + methodName.substring(4); } } return null; }
public static String getRecVersionColumnName(Class<? extends BaseMybatisModel> modelClass) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException { for (Method method : modelClass.getMethods()) { if (method.isAnnotationPresent(Version.class)) { for (int i = 0; i < method.getAnnotations().length; i++) { Annotation annotation = method.getAnnotations()[i]; if (annotation.annotationType().equals(Column.class)) { Method annotationMethod = annotation.getClass().getDeclaredMethod("name", method.getParameterTypes()); return annotationMethod.invoke(annotation, null).toString(); } } } } return null; }
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; }
protected void initializeChecks(final Column annotation, final Collection<Check> checks, final AccessibleObject fieldOrMethod) { /* If the value is generated (annotated with @GeneratedValue) it is allowed to be null * before the entity has been persisted, same is true in case of optimistic locking * when a field is annotated with @Version. * Therefore and because of the fact that there is no generic way to determine if an entity * has been persisted already, a not-null check will not be performed for such fields. */ if (!annotation.nullable() && !fieldOrMethod.isAnnotationPresent(GeneratedValue.class) && !fieldOrMethod.isAnnotationPresent(Version.class) && !fieldOrMethod.isAnnotationPresent(NotNull.class)) if (!containsCheckOfType(checks, NotNullCheck.class)) checks.add(new NotNullCheck()); // add Length check based on Column.length parameter, but only: if (!fieldOrMethod.isAnnotationPresent(Lob.class) && // if @Lob is not present !fieldOrMethod.isAnnotationPresent(Enumerated.class) && // if @Enumerated is not present !fieldOrMethod.isAnnotationPresent(Length.class) // if an explicit @Length constraint is not present ) { final LengthCheck lengthCheck = new LengthCheck(); lengthCheck.setMax(annotation.length()); checks.add(lengthCheck); } // add Range check based on Column.precision/scale parameters, but only: if (!fieldOrMethod.isAnnotationPresent(Range.class) // if an explicit @Range is not present && annotation.precision() > 0 // if precision is > 0 && Number.class.isAssignableFrom(fieldOrMethod instanceof Field ? ((Field) fieldOrMethod).getType() : ((Method) fieldOrMethod).getReturnType()) // if numeric field type ) { /* precision = 6, scale = 2 => -9999.99<=x<=9999.99 * precision = 4, scale = 1 => -999.9<=x<=999.9 */ final RangeCheck rangeCheck = new RangeCheck(); rangeCheck.setMax(Math.pow(10, annotation.precision() - annotation.scale()) - Math.pow(0.1, annotation.scale())); rangeCheck.setMin(-1 * rangeCheck.getMax()); checks.add(rangeCheck); } }
/** * <p>Getter for the field <code>version</code>.</p> * * @return a {@link java.lang.Integer} object. */ @Version @Column(name="VERSION") public Integer getVersion() { return this.version; }
@Column(name = DbColumnNames.ENTITY_VERSION) @Nullable @Override @Version public Long getEntityVersion() { return this.entityVersion; }
/** * {@inheritDoc} */ @Override @Version @Column(name = "version") public int getModificationCounter() { return super.getModificationCounter(); }
/** * Get the version for the attached file. * @return the version for the attached file * @motivation for hibernate */ @Column(nullable=false) @Version private Integer getVersion() { return _version; }
/** * @motivation for hibernate */ @Version @Column(nullable = false) private Integer getVersion() { return _version; }
/** * Get the version. * @return the version * @motivation for hibernate */ @Column(nullable=false) @Version private Integer getVersion() { return _version; }
/** * Get the version for the screening library. * * @return the version for the screening library * @motivation for hibernate */ @Version @Column(nullable = false) private Integer getVersion() { return _version; }
/** * Get the version for the copy. * @return the version for the copy * @motivation for hibernate */ @Version @Column(nullable=false) private Integer getVersion() { return _version; }
/** * @motivation for hibernate */ @Version @Column(nullable=false) private Integer getVersion() { return _version; }
/** * Get the version for the activity. * @return the version for the activity * @motivation for hibernate */ @Column(nullable=false) @Version private Integer getVersion() { return _version; }
/** * Get the version for the annotation type. * @return the version for the annotation type * @motivation for hibernate */ @Column(nullable=false) @Version private Integer getVersion() { return _version; }
/** * Get the version number of the screen result. * @return the version number of the screen result * @motivation for hibernate */ @Column(nullable=false) @Version private Integer getVersion() { return _version; }
/** * @motivation for hibernate */ @Column(nullable=false) @Version private Integer getVersion() { return _version; }
/** * Get the version for the Screensaver user. * @return the version for the Screensaver user * @motivation for hibernate */ @Version @Column(nullable=false) private Integer getVersion() { return _version; }
/** * Get the version for the cherry pick request. * @return the version for the cherry pick request * @motivation for hibernate */ @Column(nullable=false) @Version private Integer getVersion() { return _version; }
/** * Get the version for the lab cherry pick. * @return the version for the lab cherry pick * @motivation for hibernate */ @Column(nullable=false) @Version private Integer getVersion() { return _version; }
/** * Get the version for the screener cherry pick. * @return the version for the screener cherry pick * @motivation for hibernate */ @Column(nullable=false) @Version private Integer getVersion() { return _version; }
/** * Get the version for the screen. * @return the version for the screen * @motivation for hibernate */ @Version @Column(nullable=false) private Integer getVersion() { return _version; }
/** * {@inheritDoc} */ @Column(name = "optlock_version") @Version @Override public int getOptlockVersion() { return optlockVersion; }
@Version @Column(name = VERSION, columnDefinition = TINYINT_UNSIGNED, nullable = false) @XmlTransient public byte getVersion() { return version; }
@Version @Column(name = "REV_") public Integer getRev() { return rev; }