Java UniqueConstraint类代码示例

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
private static void buildUniqueConstraints(AnnotationDescriptor annotation, Element element) {
	List uniqueConstraintElementList = element.elements( "unique-constraint" );
	UniqueConstraint[] uniqueConstraints = new UniqueConstraint[uniqueConstraintElementList.size()];
	int ucIndex = 0;
	Iterator ucIt = uniqueConstraintElementList.listIterator();
	while ( ucIt.hasNext() ) {
		Element subelement = (Element) ucIt.next();
		List<Element> columnNamesElements = subelement.elements( "column-name" );
		String[] columnNames = new String[columnNamesElements.size()];
		int columnNameIndex = 0;
		Iterator it = columnNamesElements.listIterator();
		while ( it.hasNext() ) {
			Element columnNameElt = (Element) it.next();
			columnNames[columnNameIndex++] = columnNameElt.getTextTrim();
		}
		AnnotationDescriptor ucAnn = new AnnotationDescriptor( UniqueConstraint.class );
		copyStringAttribute( ucAnn, subelement, "name", false );
		ucAnn.setValue( "columnNames", columnNames );
		uniqueConstraints[ucIndex++] = AnnotationFactory.create( ucAnn );
	}
	annotation.setValue( "uniqueConstraints", uniqueConstraints );
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
/**
 * Build a list of {@link org.hibernate.cfg.UniqueConstraintHolder} instances given a list of
 * {@link UniqueConstraint} annotations.
 *
 * @param annotations The {@link UniqueConstraint} annotations.
 *
 * @return The built {@link org.hibernate.cfg.UniqueConstraintHolder} instances.
 */
public static List<UniqueConstraintHolder> buildUniqueConstraintHolders(UniqueConstraint[] annotations) {
	List<UniqueConstraintHolder> result;
	if ( annotations == null || annotations.length == 0 ) {
		result = java.util.Collections.emptyList();
	}
	else {
		result = new ArrayList<UniqueConstraintHolder>( CollectionHelper.determineProperSizing( annotations.length ) );
		for ( UniqueConstraint uc : annotations ) {
			result.add(
					new UniqueConstraintHolder()
							.setName( uc.name() )
							.setColumns( uc.columnNames() )
			);
		}
	}
	return result;
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
@Override
@ElementCollection(fetch = FetchType.LAZY)
@CollectionTable(name = "MCRCategoryLabels",
    joinColumns = @JoinColumn(name = "category"),
    uniqueConstraints = {
        @UniqueConstraint(columnNames = { "category", "lang" }) })
public Set<MCRLabel> getLabels() {
    return super.getLabels();
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
protected <T> void register(OObjectDatabaseTx db, OSchema schema, Class<T> aClass) {
    if (schema.getClass(aClass.getSimpleName()) == null) {
        db.getEntityManager().registerEntityClasses(aClass, true);
        OClass cls = db.getMetadata().getSchema().getClass(aClass);
        String indexName = aClass.getName() + ".unq";
        Table t = aClass.getAnnotation(Table.class);
        if (t != null) {
            Set<String> fields = new HashSet<>();
            for (UniqueConstraint uc : t.uniqueConstraints()) {
                fields.addAll(Lists.newArrayList(uc.columnNames()));
            }
            if (fields.size() > 0) {
                LOG.info("Registering unique constraint for fields: " + fields);
                for (String field : fields)
                    cls.createIndex(indexName + "." + field, OClass.INDEX_TYPE.UNIQUE_HASH_INDEX, field);
            }
        }
    } else {
        db.getEntityManager().registerEntityClasses(aClass, true);
    }
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
private void instpectUniqueConstraint(final UniqueConstraint constraint) {
	UniquePropertyQuality currentQuality = UniquePropertyQuality.onlyRequiredPrimitives;
	final List<SingularProperty<E, ?>> uniques = new ArrayList<>();
	final String[] columnNames = constraint.columnNames();
	for (final String columnName : columnNames) {
		for (final Property<E, ?> property : this.properties.values()) {
			if (property instanceof SingularProperty) {
				final SingularProperty<E, ?> singularProperty = (SingularProperty<E, ?>) property;
				if (columnName.equals(singularProperty.getColumn().getName())) {
					final UniquePropertyQuality quality = UniquePropertyQuality.getMatchingQuality(property);
					if (quality != null) {
						if (quality.ordinal() > currentQuality.ordinal()) {
							currentQuality = quality;
						}
						uniques.add(singularProperty);
					}
				}
			}
		}
	}
	if (uniques.size() == columnNames.length && isBetterUniquePropertyQuality(currentQuality)) {
		this.uniqueProperties = uniques;
		this.uniquePropertiesQuality = currentQuality;
	}
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
/**
 * @deprecated Use {@link #buildUniqueConstraintHolders} instead
 */
@Deprecated
@SuppressWarnings({ "JavaDoc" })
public static List<String[]> buildUniqueConstraints(UniqueConstraint[] constraintsArray) {
	List<String[]> result = new ArrayList<String[]>();
	if ( constraintsArray.length != 0 ) {
		for (UniqueConstraint uc : constraintsArray) {
			result.add( uc.columnNames() );
		}
	}
	return result;
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
private ArrayList<String[]> _getFieldsFromUniqueConstraint(Object value){
    ArrayList<String[]> result = new ArrayList<>();

    if(value.getClass().isAnnotationPresent(Table.class)){
        Table ta = value.getClass().getAnnotation(Table.class);
        for(UniqueConstraint uc : ta.uniqueConstraints()){
            result.add(uc.columnNames());
        }
    }

    return result;
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
private static String getUniqueColumns(Class<?> clazz, String name) {
    return Optional.of(clazz)
        .map(c -> c.getAnnotation(Table.class))
        .map(Table::uniqueConstraints)
        .map(Stream::of)
        .flatMap(s -> s
            .filter(uc -> uc.name().equals(name))
            .findAny()
            .map(UniqueConstraint::columnNames))
        .map(Stream::of)
        .map(s -> s.collect(Collectors.joining(", ")))
        .get();
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
private List<String> validateCompositeUniqueConstraints(Identifiable<?> entity) {
    Class<?> entityClass = getClassWithoutInitializingProxy(entity);
    Table table = findAnnotation(entityClass, Table.class);
    if (table == null) {
        return emptyList();
    }
    List<String> errors = newArrayList();
    for (UniqueConstraint uniqueConstraint : table.uniqueConstraints()) {
        if (!checkCompositeUniqueConstraint(entity, entityClass, uniqueConstraint)) {
            errors.add(compositeUniqueConstraintErrorCode(entity, uniqueConstraint));
        }
    }
    return errors;
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
private Map<String, Object> getPropertyConstraints(Object entity, Class<?> entityClass, UniqueConstraint u, String prefix) {
    Map<String, Object> values = newHashMap();
    for (String column : u.columnNames()) {
        Method method = columnNameToMethod(entityClass, column);
        if (method != null) {
            values.put(prefix + methodToProperty(method), invokeMethod(method, entity));
        } else {
            Field field = columnNameToField(entityClass, column);
            if (field != null) {
                values.put(prefix + field.getName(), getValueFromField(field, entity));
            }
        }
    }
    return values;
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
private void buildUniqueProperties(final UniqueConstraint[] uniqueConstraints) {
	for (final UniqueConstraint constraint : uniqueConstraints) {
		if (constraint.columnNames().length <= this.context.getMaxUniqueProperties()) {
			instpectUniqueConstraint(constraint);
		}
	}
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
@ElementCollection
@CollectionTable(name="judgment_court_reporter", uniqueConstraints={@UniqueConstraint(name="judgment_court_reporter_unique", columnNames={"fk_judgment", "court_reporter"})})
@Column(name="court_reporter")
@OrderBy("court_reporter")
private List<String> getCourtReporters_() {
    return courtReporters;
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
@ElementCollection
@CollectionTable(name="judgment_legal_bases", uniqueConstraints={@UniqueConstraint(name="judgment_legal_base_unique", columnNames={"fk_judgment", "legal_base"})})
@Column(name="legal_base")
@OrderBy("legal_base")
private List<String> getLegalBases_() {
    return legalBases;
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
@ElementCollection
@CollectionTable(name="judgment_lower_court_judgments", uniqueConstraints={@UniqueConstraint(name="judgment_lower_court_judgment_unique", columnNames={"fk_judgment", "lower_court_judgment"})})
@Column(name="lower_court_judgment")
@OrderBy("lower_court_judgment")
private List<String> getLowerCourtJudgments_() {
    return lowerCourtJudgments;
}
 

import javax.persistence.UniqueConstraint; //导入依赖的package包/类
@ElementCollection
@CollectionTable(name="ct_judgment_opinion_author",
                joinColumns = {@JoinColumn(name = "fk_ct_judgment_opinion", nullable = false)},
                uniqueConstraints={@UniqueConstraint(name="ct_judgment_opinion_author_unique", columnNames={"fk_ct_judgment_opinion", "author"})})
@Column(name="author", nullable=false)
private List<String> getAuthors_() {
    return authors;
}