Java Examples for javax.persistence.JoinColumn
The following java examples will help you to understand the usage of javax.persistence.JoinColumn. These source code samples are taken from different open source projects.
Example 1
| Project: castor-master File: JPAJoinColumnProcessor.java View source code |
/**
* {@inheritDoc}
*
* @see org.castor.core.annotationprocessing.TargetAwareAnnotationProcessor#
* processAnnotation(BaseNature, AnnotatedElement)
*/
public <I extends BaseNature, A extends Annotation> boolean processAnnotation(final I info, final A annotation, final AnnotatedElement target) {
if ((info instanceof JPAFieldNature) && (annotation instanceof JoinColumn) && ((target instanceof Field) || (target instanceof Method))) {
_log.debug("processing field annotation " + annotation.toString());
boolean targetValid = false;
if (target.getAnnotation(OneToOne.class) != null) {
targetValid = true;
}
if (target.getAnnotation(ManyToOne.class) != null) {
targetValid = true;
}
if (target.getAnnotation(OneToMany.class) != null) {
targetValid = true;
}
if (!targetValid) {
_log.error("JoinTable annotation on " + ((Member) target).getName() + " is not valid! Needs a relationship annotation! Ignoring @JoinTable!");
return false;
}
JPAFieldNature jpaFieldNature = (JPAFieldNature) info;
JoinColumn joinColumn = (JoinColumn) annotation;
jpaFieldNature.setJoinColumnName(joinColumn.name());
jpaFieldNature.setJoinColumnReferencedColumnName(joinColumn.referencedColumnName());
jpaFieldNature.setJoinColumnUnique(joinColumn.unique());
jpaFieldNature.setJoinColumnNullable(joinColumn.nullable());
jpaFieldNature.setJoinColumnInsertable(joinColumn.insertable());
jpaFieldNature.setJoinColumnUpdatable(joinColumn.updatable());
jpaFieldNature.setJoinColumnColumnDefinition(joinColumn.columnDefinition());
jpaFieldNature.setJoinColumnTable(joinColumn.table());
return true;
}
return false;
}Example 2
| Project: ebean-master File: AnnotationAssocManys.java View source code |
private void read(DeployBeanPropertyAssocMany<?> prop) {
OneToMany oneToMany = get(prop, OneToMany.class);
if (oneToMany != null) {
readToOne(oneToMany, prop);
if (oneToMany.orphanRemoval()) {
prop.setModifyListenMode(ModifyListenMode.REMOVALS);
prop.getCascadeInfo().setDelete(true);
}
PrivateOwned privateOwned = get(prop, PrivateOwned.class);
if (privateOwned != null) {
prop.setModifyListenMode(ModifyListenMode.REMOVALS);
prop.getCascadeInfo().setDelete(privateOwned.cascadeRemove());
}
}
ManyToMany manyToMany = get(prop, ManyToMany.class);
if (manyToMany != null) {
readToMany(manyToMany, prop);
}
if (get(prop, HistoryExclude.class) != null) {
prop.setExcludedFromHistory();
}
OrderBy orderBy = get(prop, OrderBy.class);
if (orderBy != null) {
prop.setFetchOrderBy(orderBy.value());
}
MapKey mapKey = get(prop, MapKey.class);
if (mapKey != null) {
prop.setMapKey(mapKey.name());
}
Where where = get(prop, Where.class);
if (where != null) {
prop.setExtraWhere(where.clause());
}
// check for manually defined joins
BeanTable beanTable = prop.getBeanTable();
Set<JoinColumn> joinColumns = getAll(prop, JoinColumn.class);
if (joinColumns != null) {
prop.getTableJoin().addJoinColumn(true, joinColumns, beanTable);
}
JoinTable joinTable = get(prop, JoinTable.class);
if (joinTable != null) {
if (prop.isManyToMany()) {
// expected this
readJoinTable(joinTable, prop);
} else {
// OneToMany in theory
prop.getTableJoin().addJoinColumn(true, joinTable.joinColumns(), beanTable);
}
}
if (prop.getMappedBy() != null) {
// Refer BeanDescriptorManager.readEntityRelationships()
return;
}
if (prop.isManyToMany()) {
manyToManyDefaultJoins(prop);
return;
}
if (!prop.getTableJoin().hasJoinColumns() && beanTable != null) {
// use naming convention to define join (based on the bean name for this side of relationship)
// A unidirectional OneToMany or OneToMany with no mappedBy property
NamingConvention nc = factory.getNamingConvention();
String fkeyPrefix = null;
if (nc.isUseForeignKeyPrefix()) {
fkeyPrefix = nc.getColumnFromProperty(descriptor.getBeanType(), descriptor.getName());
}
// Use the owning bean table to define the join
BeanTable owningBeanTable = factory.getBeanTable(descriptor.getBeanType());
owningBeanTable.createJoinColumn(fkeyPrefix, prop.getTableJoin(), false, prop.getSqlFormulaSelect());
}
}Example 3
| Project: TechnologyReadinessTool-master File: BaseEntity.java View source code |
@XmlTransient
@JsonIgnore
public Map<String, FieldInfo> getColumnFieldInfo() {
if (fieldMap == null) {
fieldMap = new HashMap<>();
Field[] fields = this.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
String colName = fields[i].getName();
OneToMany oneToMany = fields[i].getAnnotation(OneToMany.class);
// ManyToOne manyToOne = fields[i].getAnnotation(ManyToOne.class);
Transient trans = fields[i].getAnnotation(Transient.class);
String modifier = Modifier.toString(fields[i].getModifiers());
if (trans != null || oneToMany != null || StringUtils.contains(modifier, "static")) {
continue;
}
JoinColumn joinColumn = fields[i].getAnnotation(JoinColumn.class);
if (joinColumn != null && StringUtils.isNotBlank(joinColumn.name())) {
colName = joinColumn.name();
}
Column column = fields[i].getAnnotation(Column.class);
if (column != null && StringUtils.isNotBlank(column.name())) {
colName = column.name();
}
FieldInfo fieldInfo = new FieldInfo(colName, fields[i].getType());
fieldMap.put(fields[i].getName(), fieldInfo);
}
}
return fieldMap;
}Example 4
| Project: cloud-odata-java-master File: JPAEdmAssociationTest.java View source code |
@SuppressWarnings("unchecked")
@Override
public Annotation getAnnotation(@SuppressWarnings("rawtypes") final Class annotationClass) {
if (annotationClass.equals(JoinColumn.class)) {
JoinColumn joinColumn = EasyMock.createMock(JoinColumn.class);
EasyMock.expect(joinColumn.name()).andStubReturn("SO_ID");
EasyMock.expect(joinColumn.referencedColumnName()).andStubReturn("DEMO_ID");
EasyMock.replay(joinColumn);
return joinColumn;
} else {
OneToMany oneToMany = EasyMock.createMock(OneToMany.class);
EasyMock.expect(oneToMany.mappedBy()).andStubReturn("demo");
EasyMock.replay(oneToMany);
return oneToMany;
}
}Example 5
| Project: hibernate-delta-master File: EntityValidator.java View source code |
private void addJoinTable(Class<?> entity, Field field) {
JoinTable joinTable = field.getAnnotation(JoinTable.class);
if (joinTable != null) {
HibernateTable table = addTableElement(entity.getName() + "." + field.getName(), HibernateModelUtil.getSequenceName(entity), joinTable.name(), false);
JoinColumn sourceColumn = joinTable.joinColumns()[0];
JoinColumn targetColumn = joinTable.inverseJoinColumns()[0];
table.addColumn(createJoinTableColumn(entity, sourceColumn.name(), field.getDeclaringClass(), field));
ParameterizedType collectionType = (ParameterizedType) field.getGenericType();
Class<?> type = (Class<?>) collectionType.getActualTypeArguments()[0];
table.addColumn(createJoinTableColumn(entity, targetColumn.name(), type, field));
addIndexForJoinColumn(table, field, sourceColumn, false);
addIndexForJoinColumn(table, field, targetColumn, field.getAnnotation(OneToMany.class) != null);
}
}Example 6
| Project: ormlite-core-master File: JavaxPersistenceImpl.java View source code |
@Override
public DatabaseFieldConfig createFieldConfig(DatabaseType databaseType, Field field) {
Column columnAnnotation = field.getAnnotation(Column.class);
Basic basicAnnotation = field.getAnnotation(Basic.class);
Id idAnnotation = field.getAnnotation(Id.class);
GeneratedValue generatedValueAnnotation = field.getAnnotation(GeneratedValue.class);
OneToOne oneToOneAnnotation = field.getAnnotation(OneToOne.class);
ManyToOne manyToOneAnnotation = field.getAnnotation(ManyToOne.class);
JoinColumn joinColumnAnnotation = field.getAnnotation(JoinColumn.class);
Enumerated enumeratedAnnotation = field.getAnnotation(Enumerated.class);
Version versionAnnotation = field.getAnnotation(Version.class);
if (columnAnnotation == null && basicAnnotation == null && idAnnotation == null && oneToOneAnnotation == null && manyToOneAnnotation == null && enumeratedAnnotation == null && versionAnnotation == null) {
return null;
}
DatabaseFieldConfig config = new DatabaseFieldConfig();
String fieldName = field.getName();
if (databaseType.isEntityNamesMustBeUpCase()) {
fieldName = databaseType.upCaseEntityName(fieldName);
}
config.setFieldName(fieldName);
if (columnAnnotation != null) {
if (stringNotEmpty(columnAnnotation.name())) {
config.setColumnName(columnAnnotation.name());
}
if (stringNotEmpty(columnAnnotation.columnDefinition())) {
config.setColumnDefinition(columnAnnotation.columnDefinition());
}
config.setWidth(columnAnnotation.length());
config.setCanBeNull(columnAnnotation.nullable());
config.setUnique(columnAnnotation.unique());
}
if (basicAnnotation != null) {
config.setCanBeNull(basicAnnotation.optional());
}
if (idAnnotation != null) {
if (generatedValueAnnotation == null) {
config.setId(true);
} else {
// generatedValue only works if it is also an id according to {@link GeneratedValue)
config.setGeneratedId(true);
}
}
if (oneToOneAnnotation != null || manyToOneAnnotation != null) {
// if we have a collection then make it a foreign collection
if (Collection.class.isAssignableFrom(field.getType()) || ForeignCollection.class.isAssignableFrom(field.getType())) {
config.setForeignCollection(true);
if (joinColumnAnnotation != null && stringNotEmpty(joinColumnAnnotation.name())) {
config.setForeignCollectionColumnName(joinColumnAnnotation.name());
}
if (manyToOneAnnotation != null) {
FetchType fetchType = manyToOneAnnotation.fetch();
if (fetchType != null && fetchType == FetchType.EAGER) {
config.setForeignCollectionEager(true);
}
}
} else {
// otherwise it is a foreign field
config.setForeign(true);
if (joinColumnAnnotation != null) {
if (stringNotEmpty(joinColumnAnnotation.name())) {
config.setColumnName(joinColumnAnnotation.name());
}
config.setCanBeNull(joinColumnAnnotation.nullable());
config.setUnique(joinColumnAnnotation.unique());
}
}
}
if (enumeratedAnnotation != null) {
EnumType enumType = enumeratedAnnotation.value();
if (enumType != null && enumType == EnumType.STRING) {
config.setDataType(DataType.ENUM_STRING);
} else {
config.setDataType(DataType.ENUM_INTEGER);
}
}
if (versionAnnotation != null) {
// just the presence of the version...
config.setVersion(true);
}
if (config.getDataPersister() == null) {
config.setDataPersister(DataPersisterManager.lookupForField(field));
}
config.setUseGetSet(DatabaseFieldConfig.findGetMethod(field, false) != null && DatabaseFieldConfig.findSetMethod(field, false) != null);
return config;
}Example 7
| Project: resin-master File: ManyToOneField.java View source code |
/**
* Initializes the field.
*/
public void init(EntityType relatedType) throws ConfigException {
boolean isJPA = relatedType.getPersistenceUnit().isJPA();
int loadGroupIndex = getEntitySourceType().getDefaultLoadGroupIndex();
super.setLoadGroupIndex(loadGroupIndex);
// jpa/0l40 vs. ejb/0602
if (isJPA)
_targetLoadIndex = loadGroupIndex;
else
_targetLoadIndex = relatedType.nextLoadGroupIndex();
AmberTable sourceTable = relatedType.getTable();
if (sourceTable == null || !isJPA) {
// jpa/0ge3, ejb/0602
super.init();
return;
}
// jpa/0j67
setSourceCascadeDelete(isCascade(CascadeType.REMOVE));
int n = 0;
if (_joinColumnMap != null)
n = _joinColumnMap.size();
ArrayList<ForeignColumn> foreignColumns = new ArrayList<ForeignColumn>();
EntityType parentType = _targetType;
ArrayList<AmberColumn> targetIdColumns = _targetType.getId().getColumns();
while (targetIdColumns.size() == 0) {
parentType = parentType.getParentType();
if (parentType == null)
break;
targetIdColumns = parentType.getId().getColumns();
}
for (AmberColumn keyColumn : targetIdColumns) {
String columnName;
columnName = getName() + '_' + keyColumn.getName();
boolean nullable = true;
boolean unique = false;
if (n > 0) {
JoinColumnConfig joinColumn;
if (n == 1) {
joinColumn = (JoinColumnConfig) _joinColumnMap.values().toArray()[0];
} else
joinColumn = _joinColumnMap.get(keyColumn.getName());
if (joinColumn != null) {
// jpa/0h0d
if (!"".equals(joinColumn.getName()))
columnName = joinColumn.getName();
nullable = joinColumn.isNullable();
unique = joinColumn.isUnique();
}
} else {
JoinColumn joinAnn = BaseConfigIntrospector.getJoinColumn(_joinColumnsAnn, keyColumn.getName());
if (joinAnn != null) {
columnName = joinAnn.name();
nullable = joinAnn.nullable();
unique = joinAnn.unique();
}
}
ForeignColumn foreignColumn;
foreignColumn = sourceTable.createForeignColumn(columnName, keyColumn);
foreignColumn.setNotNull(!nullable);
foreignColumn.setUnique(unique);
foreignColumns.add(foreignColumn);
}
LinkColumns linkColumns = new LinkColumns(sourceTable, _targetType.getTable(), foreignColumns);
setLinkColumns(linkColumns);
super.init();
Id id = getEntityTargetType().getId();
ArrayList<AmberColumn> keys = id.getColumns();
if (_linkColumns == null) {
ArrayList<ForeignColumn> columns = new ArrayList<ForeignColumn>();
for (int i = 0; i < keys.size(); i++) {
AmberColumn key = keys.get(i);
String name;
if (keys.size() == 1)
name = getName();
else
name = getName() + "_" + key.getName();
columns.add(sourceTable.createForeignColumn(name, key));
}
_linkColumns = new LinkColumns(relatedType.getTable(), _targetType.getTable(), columns);
}
if (relatedType.getId() != null) {
// resolve any alias
for (AmberField field : relatedType.getId().getKeys()) {
for (ForeignColumn column : _linkColumns.getColumns()) {
if (field.getColumn() != null && field.getColumn().getName().equals(column.getName())) {
_aliasField = field;
}
}
}
}
// nextLoadGroupIndex();
_targetLoadIndex = relatedType.getLoadGroupIndex();
_linkColumns.setTargetCascadeDelete(isTargetCascadeDelete());
_linkColumns.setSourceCascadeDelete(isSourceCascadeDelete());
}Example 8
| Project: clinic-softacad-master File: JPAOverriddenAnnotationReader.java View source code |
private JoinTable overridesDefaultsInJoinTable(Annotation annotation, XMLContext.Default defaults) {
//no element but might have some default or some annotation
boolean defaultToJoinTable = !(isJavaAnnotationPresent(JoinColumn.class) || isJavaAnnotationPresent(JoinColumns.class));
final Class<? extends Annotation> annotationClass = annotation.annotationType();
defaultToJoinTable = defaultToJoinTable && ((annotationClass == ManyToMany.class && StringHelper.isEmpty(((ManyToMany) annotation).mappedBy())) || (annotationClass == OneToMany.class && StringHelper.isEmpty(((OneToMany) annotation).mappedBy())) || (annotationClass == ElementCollection.class));
final Class<JoinTable> annotationType = JoinTable.class;
if (defaultToJoinTable && (StringHelper.isNotEmpty(defaults.getCatalog()) || StringHelper.isNotEmpty(defaults.getSchema()))) {
AnnotationDescriptor ad = new AnnotationDescriptor(annotationType);
if (defaults.canUseJavaAnnotations()) {
JoinTable table = getJavaAnnotation(annotationType);
if (table != null) {
ad.setValue("name", table.name());
ad.setValue("schema", table.schema());
ad.setValue("catalog", table.catalog());
ad.setValue("uniqueConstraints", table.uniqueConstraints());
ad.setValue("joinColumns", table.joinColumns());
ad.setValue("inverseJoinColumns", table.inverseJoinColumns());
}
}
if (StringHelper.isEmpty((String) ad.valueOf("schema")) && StringHelper.isNotEmpty(defaults.getSchema())) {
ad.setValue("schema", defaults.getSchema());
}
if (StringHelper.isEmpty((String) ad.valueOf("catalog")) && StringHelper.isNotEmpty(defaults.getCatalog())) {
ad.setValue("catalog", defaults.getCatalog());
}
return AnnotationFactory.create(ad);
} else if (defaults.canUseJavaAnnotations()) {
return getJavaAnnotation(annotationType);
} else {
return null;
}
}Example 9
| Project: hexa.tools-master File: PersistenceConfigurationFactoryGenerator.java View source code |
private void writeBody(SourceWriter sourceWriter) {
sourceWriter.println("private PersistenceConfiguration config;");
sourceWriter.println("@Override");
sourceWriter.println("public PersistenceConfiguration getPersistenceConfiguration() {");
sourceWriter.println("if( config == null )");
sourceWriter.println("createConfig();");
sourceWriter.println("return config;");
sourceWriter.println("}");
sourceWriter.println("private void createConfig() {");
sourceWriter.println("ClassBundle clazzBundle = GWT.create( ClassBundle.class );");
sourceWriter.println("clazzBundle.register();");
sourceWriter.println("config = new PersistenceConfiguration();");
sourceWriter.println("EntityConfiguration ec = null;");
for (int i = 0; i < entityClasses.length; i++) {
Class<?> entityClass = entityClasses[i];
// ensure class has the @Entity annotation...
assert entityClass.getAnnotation(Entity.class) != null : "Class xxx should be annotated with @Entity !";
// search @Id field : class, name, generation policy
Field idField = getIdField(entityClass);
assert idField != null : "Entity class should have an @Id field";
String generationTypeString = "GenerationType.SEQUENCE";
GeneratedValue generatedValueAnnotation = idField.getAnnotation(GeneratedValue.class);
if (generatedValueAnnotation != null && generatedValueAnnotation.strategy() != null)
generationTypeString = "GenerationType." + generatedValueAnnotation.strategy().name();
sourceWriter.println("ec = config.addEntityConfiguration( " + entityClass.getName() + ".class, " + idField.getType().getName() + ".class, \"" + idField.getName() + "\", " + generationTypeString + " );");
Field[] fields = entityClass.getDeclaredFields();
for (int f = 0; f < fields.length; f++) {
Id idAnnotation = fields[f].getAnnotation(Id.class);
if (idAnnotation != null)
continue;
// TODO : check transcient, final, ...
OneToMany oneToMany = fields[f].getAnnotation(OneToMany.class);
if (oneToMany != null) {
//@OneToMany( mappedBy = "category" )
//private List<Article> articles;
String mappedBy = oneToMany.mappedBy();
//ec.addOneToManyFieldConfiguration( List.class, Article.class, "articles", "category", false );
JClassType entityType = typeOracle.findType(entityClass.getName());
JField jField = entityType.findField(fields[f].getName());
String containerClassName = jField.getType().getErasedType().getQualifiedSourceName();
String targetClassName = jField.getType().isParameterized().getTypeArgs()[0].getQualifiedSourceName();
sourceWriter.println("ec.addOneToManyFieldConfiguration( " + containerClassName + ".class, " + targetClassName + ".class, \"" + fields[f].getName() + "\", \"" + mappedBy + "\", false );");
continue;
}
ManyToOne manyToOne = fields[f].getAnnotation(ManyToOne.class);
if (manyToOne != null) {
//@ManyToOne( fetch = FetchType.LAZY, cascade = { CascadeType.MERGE } )
//@JoinColumn( name="category_id" )
//Category category;
String columnName = fields[f].getName() + "_id";
JoinColumn joinColumn = fields[f].getAnnotation(JoinColumn.class);
if (joinColumn != null)
columnName = joinColumn.name();
String fetchTypeString = "FetchType." + manyToOne.fetch();
// ec.addManyToOneFieldConfiguration( Category.class, "category", "category_id", FetchType.LAZY );
sourceWriter.println("ec.addManyToOneFieldConfiguration( " + fields[f].getType().getName() + ".class, \"" + fields[f].getName() + "\", \"" + columnName + "\", " + fetchTypeString + " );");
continue;
}
// normal field fields
sourceWriter.println("ec.addFieldConfiguration( " + fields[f].getType().getName() + ".class, \"" + fields[f].getName() + "\" );");
}
}
sourceWriter.println("}");
}Example 10
| Project: hibernate-core-3.6.x-mod-master File: JPAOverridenAnnotationReader.java View source code |
private JoinTable overridesDefaultsInJoinTable(Annotation annotation, XMLContext.Default defaults) {
//no element but might have some default or some annotation
boolean defaultToJoinTable = !(isJavaAnnotationPresent(JoinColumn.class) || isJavaAnnotationPresent(JoinColumns.class));
final Class<? extends Annotation> annotationClass = annotation.annotationType();
defaultToJoinTable = defaultToJoinTable && ((annotationClass == ManyToMany.class && StringHelper.isEmpty(((ManyToMany) annotation).mappedBy())) || (annotationClass == OneToMany.class && StringHelper.isEmpty(((OneToMany) annotation).mappedBy())) || (annotationClass == //legacy Hibernate
CollectionOfElements.class) || (annotationClass == ElementCollection.class));
final Class<JoinTable> annotationType = JoinTable.class;
if (defaultToJoinTable && (StringHelper.isNotEmpty(defaults.getCatalog()) || StringHelper.isNotEmpty(defaults.getSchema()))) {
AnnotationDescriptor ad = new AnnotationDescriptor(annotationType);
if (defaults.canUseJavaAnnotations()) {
JoinTable table = getJavaAnnotation(annotationType);
if (table != null) {
ad.setValue("name", table.name());
ad.setValue("schema", table.schema());
ad.setValue("catalog", table.catalog());
ad.setValue("uniqueConstraints", table.uniqueConstraints());
ad.setValue("joinColumns", table.joinColumns());
ad.setValue("inverseJoinColumns", table.inverseJoinColumns());
}
}
if (StringHelper.isEmpty((String) ad.valueOf("schema")) && StringHelper.isNotEmpty(defaults.getSchema())) {
ad.setValue("schema", defaults.getSchema());
}
if (StringHelper.isEmpty((String) ad.valueOf("catalog")) && StringHelper.isNotEmpty(defaults.getCatalog())) {
ad.setValue("catalog", defaults.getCatalog());
}
return AnnotationFactory.create(ad);
} else if (defaults.canUseJavaAnnotations()) {
return getJavaAnnotation(annotationType);
} else {
return null;
}
}Example 11
| Project: hibernate-core-ogm-master File: JPAOverridenAnnotationReader.java View source code |
private JoinTable overridesDefaultsInJoinTable(Annotation annotation, XMLContext.Default defaults) {
//no element but might have some default or some annotation
boolean defaultToJoinTable = !(isJavaAnnotationPresent(JoinColumn.class) || isJavaAnnotationPresent(JoinColumns.class));
final Class<? extends Annotation> annotationClass = annotation.annotationType();
defaultToJoinTable = defaultToJoinTable && ((annotationClass == ManyToMany.class && StringHelper.isEmpty(((ManyToMany) annotation).mappedBy())) || (annotationClass == OneToMany.class && StringHelper.isEmpty(((OneToMany) annotation).mappedBy())) || (annotationClass == ElementCollection.class));
final Class<JoinTable> annotationType = JoinTable.class;
if (defaultToJoinTable && (StringHelper.isNotEmpty(defaults.getCatalog()) || StringHelper.isNotEmpty(defaults.getSchema()))) {
AnnotationDescriptor ad = new AnnotationDescriptor(annotationType);
if (defaults.canUseJavaAnnotations()) {
JoinTable table = getJavaAnnotation(annotationType);
if (table != null) {
ad.setValue("name", table.name());
ad.setValue("schema", table.schema());
ad.setValue("catalog", table.catalog());
ad.setValue("uniqueConstraints", table.uniqueConstraints());
ad.setValue("joinColumns", table.joinColumns());
ad.setValue("inverseJoinColumns", table.inverseJoinColumns());
}
}
if (StringHelper.isEmpty((String) ad.valueOf("schema")) && StringHelper.isNotEmpty(defaults.getSchema())) {
ad.setValue("schema", defaults.getSchema());
}
if (StringHelper.isEmpty((String) ad.valueOf("catalog")) && StringHelper.isNotEmpty(defaults.getCatalog())) {
ad.setValue("catalog", defaults.getCatalog());
}
return AnnotationFactory.create(ad);
} else if (defaults.canUseJavaAnnotations()) {
return getJavaAnnotation(annotationType);
} else {
return null;
}
}Example 12
| Project: hibernate-orm-master File: JPAOverriddenAnnotationReader.java View source code |
private JoinTable overridesDefaultsInJoinTable(Annotation annotation, XMLContext.Default defaults) {
//no element but might have some default or some annotation
boolean defaultToJoinTable = !(isPhysicalAnnotationPresent(JoinColumn.class) || isPhysicalAnnotationPresent(JoinColumns.class));
final Class<? extends Annotation> annotationClass = annotation.annotationType();
defaultToJoinTable = defaultToJoinTable && ((annotationClass == ManyToMany.class && StringHelper.isEmpty(((ManyToMany) annotation).mappedBy())) || (annotationClass == OneToMany.class && StringHelper.isEmpty(((OneToMany) annotation).mappedBy())) || (annotationClass == ElementCollection.class));
final Class<JoinTable> annotationType = JoinTable.class;
if (defaultToJoinTable && (StringHelper.isNotEmpty(defaults.getCatalog()) || StringHelper.isNotEmpty(defaults.getSchema()))) {
AnnotationDescriptor ad = new AnnotationDescriptor(annotationType);
if (defaults.canUseJavaAnnotations()) {
JoinTable table = getPhysicalAnnotation(annotationType);
if (table != null) {
ad.setValue("name", table.name());
ad.setValue("schema", table.schema());
ad.setValue("catalog", table.catalog());
ad.setValue("uniqueConstraints", table.uniqueConstraints());
ad.setValue("joinColumns", table.joinColumns());
ad.setValue("inverseJoinColumns", table.inverseJoinColumns());
}
}
if (StringHelper.isEmpty((String) ad.valueOf("schema")) && StringHelper.isNotEmpty(defaults.getSchema())) {
ad.setValue("schema", defaults.getSchema());
}
if (StringHelper.isEmpty((String) ad.valueOf("catalog")) && StringHelper.isNotEmpty(defaults.getCatalog())) {
ad.setValue("catalog", defaults.getCatalog());
}
return AnnotationFactory.create(ad);
} else if (defaults.canUseJavaAnnotations()) {
return getPhysicalAnnotation(annotationType);
} else {
return null;
}
}Example 13
| Project: eclipselink.runtime-master File: AnnotationsTestSuite.java View source code |
/**
* Verify that repeating annotations work as expected and are backwards
* compatible.
*/
public void testRepeatingAnnotations() throws Exception {
// @AssociationOverride
verifyContainerAnnotation(Employee.class, PROPERTY, "getPeriod", AssociationOverrides.class, 2);
verifyAnnotation(Employee.class, PROPERTY, "getPeriod", AssociationOverride.class, 2);
verifyMetadata(Employee.class, PROPERTY, "period", "javax.persistence.AssociationOverrides", 2);
// @AttributeOverride
verifyContainerAnnotation(Employee.class, PROPERTY, "getPeriod", AttributeOverrides.class, 2);
verifyAnnotation(Employee.class, PROPERTY, "getPeriod", AttributeOverride.class, 2);
verifyMetadata(Employee.class, PROPERTY, "period", "javax.persistence.AttributeOverrides", 2);
// @Convert
verifyContainerAnnotation(Race.class, FIELD, "organizers", Converts.class, 2);
verifyAnnotation(Race.class, FIELD, "organizers", Convert.class, 2);
verifyMetadata(Race.class, FIELD, "organizers", "javax.persistence.Converts", 2);
// @JoinColumn
verifyContainerAnnotation(Employee.class, PROPERTY, "getPhoneNumbers", JoinColumns.class, 2);
verifyAnnotation(Employee.class, PROPERTY, "getPhoneNumbers", JoinColumn.class, 2);
verifyMetadata(Employee.class, PROPERTY, "phoneNumbers", "javax.persistence.JoinColumns", 2);
// @MapKeyJoinColumn
verifyContainerAnnotation(Department.class, PROPERTY, "getEmployeesByPhoneNumber", MapKeyJoinColumns.class, 2);
verifyAnnotation(Department.class, PROPERTY, "getEmployeesByPhoneNumber", MapKeyJoinColumn.class, 2);
verifyMetadata(Department.class, PROPERTY, "employeesByPhoneNumber", "javax.persistence.MapKeyJoinColumns", 2);
// @NamedEntityGraph
verifyContainerAnnotation(Employee.class, NamedEntityGraphs.class, 2);
verifyAnnotation(Employee.class, NamedEntityGraph.class, 2);
verifyMetadata(Employee.class, "javax.persistence.NamedEntityGraphs", 2);
// @NamedNativeQuery
verifyContainerAnnotation(Runner.class, NamedNativeQueries.class, 2);
verifyAnnotation(Runner.class, NamedNativeQuery.class, 2);
verifyMetadata(Runner.class, "javax.persistence.NamedNativeQueries", 2);
// @NamedQuery
verifyContainerAnnotation(Employee.class, NamedQueries.class, 2);
verifyAnnotation(Employee.class, NamedQuery.class, 2);
verifyMetadata(Employee.class, "javax.persistence.NamedQueries", 2);
// @NamedStoredProcedureQuery
verifyContainerAnnotation(Employee.class, NamedStoredProcedureQueries.class, 4);
verifyAnnotation(Employee.class, NamedStoredProcedureQuery.class, 4);
verifyMetadata(Employee.class, "javax.persistence.NamedStoredProcedureQueries", 4);
// @PersistenceContext
verifyContainerAnnotation(AnnotationsTestSuite.class, PersistenceContexts.class, 3);
verifyAnnotation(AnnotationsTestSuite.class, PersistenceContext.class, 3);
verifyMetadata(AnnotationsTestSuite.class, "javax.persistence.PersistenceContexts", 3);
// @PersistenceUnit
verifyContainerAnnotation(AnnotationsTestSuite.class, PersistenceUnits.class, 2);
verifyAnnotation(AnnotationsTestSuite.class, PersistenceUnit.class, 2);
verifyMetadata(AnnotationsTestSuite.class, "javax.persistence.PersistenceUnits", 2);
// @PrimaryKeyJoinColumn
verifyContainerAnnotation(PhoneNumber.class, PROPERTY, "getPhoneNumberDetails", PrimaryKeyJoinColumns.class, 2);
verifyAnnotation(PhoneNumber.class, PROPERTY, "getPhoneNumberDetails", PrimaryKeyJoinColumn.class, 2);
verifyMetadata(PhoneNumber.class, PROPERTY, "phoneNumberDetails", "javax.persistence.PrimaryKeyJoinColumns", 2);
// @SecondaryTable
verifyContainerAnnotation(Employee.class, SecondaryTables.class, 2);
verifyAnnotation(Employee.class, SecondaryTable.class, 2);
verifyMetadata(Employee.class, "javax.persistence.SecondaryTables", 2);
// @SqlResultSetMapping
verifyContainerAnnotation(Employee.class, SqlResultSetMappings.class, 2);
verifyAnnotation(Employee.class, SqlResultSetMapping.class, 2);
verifyMetadata(Employee.class, "javax.persistence.SqlResultSetMappings", 2);
}Example 14
| Project: financisto-master File: EntityManager.java View source code |
private static EntityDefinition parseDefinition(Class<?> clazz) {
if (!clazz.isAnnotationPresent(Entity.class)) {
throw new IllegalArgumentException("Class " + clazz + " is not an @Entity");
}
EntityDefinition.Builder edb = new EntityDefinition.Builder(clazz);
try {
Constructor<?> constructor = clazz.getConstructor();
edb.withConstructor(constructor);
} catch (Exception e) {
throw new IllegalArgumentException("Entity must have an empty constructor");
}
if (clazz.isAnnotationPresent(Table.class)) {
Table tableAnnotation = clazz.getAnnotation(Table.class);
edb.withTable(tableAnnotation.name());
}
Field[] fields = clazz.getFields();
if (fields != null) {
int index = 0;
for (Field f : fields) {
if ((f.getModifiers() & Modifier.STATIC) == 0) {
if (f.isAnnotationPresent(Id.class)) {
edb.withIdField(parseField(f));
} else {
if (f.isAnnotationPresent(Transient.class)) {
continue;
} else if (f.isAnnotationPresent(JoinColumn.class)) {
JoinColumn c = f.getAnnotation(JoinColumn.class);
edb.withField(FieldInfo.entity(index++, f, c.name(), c.required()));
} else {
edb.withField(parseField(f));
}
}
}
}
}
return edb.create();
}Example 15
| Project: jirm-master File: SqlParameterDefinition.java View source code |
static SqlParameterDefinition parameterDef(SqlObjectConfig config, Class<?> objectType, String parameterName, Class<?> parameterType, int order) {
final SqlParameterDefinition definition;
String sn = null;
ManyToOne manyToOne = getAnnotation(objectType, parameterName, ManyToOne.class);
if (manyToOne != null) {
Class<?> subK = checkNotNull(manyToOne.targetEntity(), "targetEntity not set");
JoinColumn joinColumn = getAnnotation(objectType, parameterName, JoinColumn.class);
SqlObjectDefinition<?> od = SqlObjectDefinition.fromClass(subK, config);
checkState(!od.getIdParameters().isEmpty(), "No id parameters");
if (joinColumn != null)
sn = joinColumn.name();
if (sn == null)
sn = config.getNamingStrategy().propertyToColumnName(parameterName);
FetchType fetch = manyToOne.fetch();
int depth;
if (FetchType.LAZY == fetch) {
depth = 1;
} else {
depth = config.getMaximumLoadDepth();
}
SqlParameterObjectDefinition sod = new SqlParameterObjectDefinition(od, depth);
definition = SqlParameterDefinition.newComplexInstance(config.getConverter(), parameterName, sod, order, sn);
} else {
Column col = getAnnotation(objectType, parameterName, Column.class);
if (col != null && !isNullOrEmpty(col.name()))
sn = col.name();
Id id = getAnnotation(objectType, parameterName, Id.class);
Version version = getAnnotation(objectType, parameterName, Version.class);
GeneratedValue generated = getAnnotation(objectType, parameterName, GeneratedValue.class);
Enumerated enumerated = getAnnotation(objectType, parameterName, Enumerated.class);
boolean idFlag = id != null;
boolean versionFlag = version != null;
boolean generatedFlag = generated != null;
if (sn == null)
sn = config.getNamingStrategy().propertyToColumnName(parameterName);
definition = SqlParameterDefinition.newSimpleInstance(config.getConverter(), parameterName, parameterType, order, sn, idFlag, versionFlag, generatedFlag, Optional.fromNullable(enumerated));
}
return definition;
}Example 16
| Project: olingo-odata2-master File: JPAEdmPropertyTest.java View source code |
@SuppressWarnings("unchecked")
@Override
public <T extends Annotation> T getAnnotation(final Class<T> annotationClass) {
if (annotationClass.equals(ManyToOne.class)) {
ManyToOne manyToOne = EasyMock.createMock(ManyToOne.class);
EasyMock.expect(manyToOne.optional()).andReturn(true).anyTimes();
return (T) manyToOne;
} else if (annotationClass.equals(JoinColumn.class)) {
JoinColumn joinColumn = EasyMock.createMock(JoinColumn.class);
EasyMock.expect(joinColumn.insertable()).andReturn(true).anyTimes();
EasyMock.expect(joinColumn.updatable()).andReturn(true).anyTimes();
if (testCase.equals("Default")) {
EasyMock.expect(joinColumn.name()).andReturn("FSOID").anyTimes();
EasyMock.expect(joinColumn.referencedColumnName()).andReturn("SOLITID").anyTimes();
EasyMock.expect(joinColumn.nullable()).andReturn(false).anyTimes();
EasyMock.replay(joinColumn);
} else if (testCase.equals("NoJoinColumnNames")) {
EasyMock.expect(joinColumn.name()).andReturn("").anyTimes();
EasyMock.expect(joinColumn.referencedColumnName()).andReturn("").anyTimes();
EasyMock.expect(joinColumn.nullable()).andReturn(true).anyTimes();
EasyMock.replay(joinColumn);
} else if (testCase.equals("JoinColumnWithFacets")) {
EasyMock.expect(joinColumn.name()).andReturn("ColumnWithFacets").anyTimes();
EasyMock.expect(joinColumn.referencedColumnName()).andReturn("").anyTimes();
EasyMock.expect(joinColumn.nullable()).andReturn(false).anyTimes();
EasyMock.replay(joinColumn);
}
return (T) joinColumn;
} else {
if (testCase.equals("Default")) {
Column column = EasyMock.createMock(Column.class);
EasyMock.expect(column.name()).andReturn("SOLITID").anyTimes();
EasyMock.expect(column.nullable()).andReturn(true).anyTimes();
EasyMock.expect(column.length()).andReturn(30).anyTimes();
EasyMock.replay(column);
return (T) column;
}
}
return null;
}Example 17
| Project: enterprise-app-master File: DefaultCrudFieldFactory.java View source code |
/**
* Configures the specified Field (adds caption, validators, etc.).
* @param field Field to configure.
* @param bean bean to which the field belongs.
* @param item item to which the field belongs.
* @param pid field property.
* @param uiContext the component where the field is presented.
* @param propertyType the field property type.
* @param crudFieldAnnotation CrudFieldAnnotation annotation (if present).
* @param columnAnnotation ColumnAnnotation annotation (if present).
* @param joinColumnAnnotation ColumnAnnotation annotation (if present).
* @param typeAnnotation TypeAnnotation (if present)
*/
public void configureField(Field field, Object bean, Item item, String pid, Component uiContext, Class<?> propertyType, CrudField crudFieldAnnotation, Column columnAnnotation, JoinColumn joinColumnAnnotation, Type typeAnnotation) {
field.setCaption(getFieldCaption(pid, bean.getClass()));
checkRequired(field, crudFieldAnnotation, columnAnnotation, joinColumnAnnotation);
checkLength(field, columnAnnotation, typeAnnotation);
checkNullRepresentation(field);
addValidators(field, bean, item, pid, uiContext, propertyType, crudFieldAnnotation);
field.setWidth("100%");
}Example 18
| Project: mobicents-master File: ConcreteProfileEntityGenerator.java View source code |
/**
* Generates a class that extends {@link ProfileEntityArrayAttributeValue} for a specific entity attribute of array type value
* @param concreteProfileEntityClass
* @param profileAttributeName
* @return
*/
private Class<?> generateProfileAttributeArrayValueClass(CtClass concreteProfileEntityClass, String profileAttributeName, boolean unique) {
CtClass concreteArrayValueClass = null;
try {
// define the concrete profile attribute array value class name
String concreteArrayValueClassName = profileComponent.getProfileCmpInterfaceClass().getName() + "PEAAV_" + ClassGeneratorUtils.capitalize(profileAttributeName);
// create javassist class
concreteArrayValueClass = ClassGeneratorUtils.createClass(concreteArrayValueClassName, new String[] { Serializable.class.getName() });
// set inheritance
ClassGeneratorUtils.createInheritanceLink(concreteArrayValueClass, ProfileEntityArrayAttributeValue.class.getName());
// annotate class with @Entity
ClassGeneratorUtils.addAnnotation(Entity.class.getName(), new LinkedHashMap<String, Object>(), concreteArrayValueClass);
// generate a random table name
addTableAnnotationToPEAAV("SLEE_PEAAV_" + profileComponent.getProfileCmpInterfaceClass().getSimpleName() + "_" + Math.abs(profileComponent.getComponentID().hashCode()) + profileAttributeName, unique, concreteArrayValueClass);
// override @id
String getIdNameMethodSrc = "public long getId() { return super.getId(); }";
CtMethod getIdNameMethod = CtNewMethod.make(getIdNameMethodSrc, concreteArrayValueClass);
ClassGeneratorUtils.addAnnotation(Id.class.getName(), new LinkedHashMap<String, Object>(), getIdNameMethod);
ClassGeneratorUtils.addAnnotation(GeneratedValue.class.getName(), new LinkedHashMap<String, Object>(), getIdNameMethod);
concreteArrayValueClass.addMethod(getIdNameMethod);
// override getter methods
String getSerializableMethodSrc = "public " + Serializable.class.getName() + " getSerializable() { return super.getSerializable(); }";
CtMethod getSerializableMethod = CtNewMethod.make(getSerializableMethodSrc, concreteArrayValueClass);
LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>();
map.put("name", "serializable");
//if (unique)map.put("unique", true);
ClassGeneratorUtils.addAnnotation(Column.class.getName(), map, getSerializableMethod);
concreteArrayValueClass.addMethod(getSerializableMethod);
String getStringMethodSrc = "public String getString() { return super.getString(); }";
CtMethod getStringMethod = CtNewMethod.make(getStringMethodSrc, concreteArrayValueClass);
map = new LinkedHashMap<String, Object>();
map.put("name", "string");
//if (unique)map.put("unique", true);
ClassGeneratorUtils.addAnnotation(Column.class.getName(), map, getStringMethod);
concreteArrayValueClass.addMethod(getStringMethod);
// FIXME add join columns here or in profile entity class to make
// the relation without a join table, atm if this is changed, the
// inserts on this table go with profile and table name as null %)
// THE PROFILENTITY FIELD IN AAV CLASS IS REQUIRED FOR THE RELATION WITH PROFILE ENTITY CLASS WITHOUT A JOIN TABLE
// add join column regarding the relation from array attr value to profile entity
CtField ctField = ClassGeneratorUtils.addField(concreteProfileEntityClass, "owner", concreteArrayValueClass);
ClassGeneratorUtils.generateSetter(ctField, null);
CtMethod getter = ClassGeneratorUtils.generateGetter(ctField, null);
//ClassGeneratorUtils.addAnnotation(ManyToOne.class.getName(), new LinkedHashMap<String, Object>(), getter);
// ----
ConstPool cp = getter.getMethodInfo().getConstPool();
AnnotationsAttribute attr = (AnnotationsAttribute) getter.getMethodInfo().getAttribute(AnnotationsAttribute.visibleTag);
if (attr == null) {
attr = new AnnotationsAttribute(cp, AnnotationsAttribute.visibleTag);
}
Annotation manyToOne = new Annotation(ManyToOne.class.getName(), cp);
manyToOne.addMemberValue("optional", new BooleanMemberValue(false, cp));
attr.addAnnotation(manyToOne);
Annotation joinColumns = new Annotation(JoinColumns.class.getName(), cp);
Annotation joinColumn1 = new Annotation(JoinColumn.class.getName(), cp);
joinColumn1.addMemberValue("name", new StringMemberValue("owner_tableName", cp));
joinColumn1.addMemberValue("referencedColumnName", new StringMemberValue("tableName", cp));
Annotation joinColumn2 = new Annotation(JoinColumn.class.getName(), cp);
joinColumn2.addMemberValue("name", new StringMemberValue("owner_profileName", cp));
joinColumn2.addMemberValue("referencedColumnName", new StringMemberValue("profileName", cp));
ArrayMemberValue joinColumnsMemberValue = new ArrayMemberValue(cp);
joinColumnsMemberValue.setValue(new MemberValue[] { new AnnotationMemberValue(joinColumn1, cp), new AnnotationMemberValue(joinColumn2, cp) });
joinColumns.addMemberValue("value", joinColumnsMemberValue);
attr.addAnnotation(joinColumns);
getter.getMethodInfo().addAttribute(attr);
// generate concrete setProfileEntity method
String setProfileEntityMethodSrc = "public void setProfileEntity(" + ProfileEntity.class.getName() + " profileEntity){ setOwner((" + concreteProfileEntityClass.getName() + ")profileEntity); }";
CtMethod setProfileEntityMethod = CtMethod.make(setProfileEntityMethodSrc, concreteArrayValueClass);
concreteArrayValueClass.addMethod(setProfileEntityMethod);
// write and load the attr array value class
String deployDir = profileComponent.getDeploymentDir().getAbsolutePath();
if (logger.isDebugEnabled()) {
logger.debug("Writing PROFILE ATTR ARRAY VALUE CONCRETE CLASS ( " + concreteArrayValueClass.getName() + " ) to: " + deployDir);
}
concreteArrayValueClass.writeFile(deployDir);
return Thread.currentThread().getContextClassLoader().loadClass(concreteArrayValueClass.getName());
} catch (Throwable e) {
throw new SLEEException(e.getMessage(), e);
} finally {
if (concreteArrayValueClass != null) {
concreteArrayValueClass.defrost();
}
}
}Example 19
| Project: ProvToolbox-master File: Entity.java View source code |
/**
* Gets the value of the value property.
*
* @return
* possible object is
* {@link org.openprovenance.prov.sql.Value }
*
*/
@ManyToOne(targetEntity = org.openprovenance.prov.sql.Value.class, cascade = { CascadeType.ALL })
@JoinColumn(name = "VALUE")
public org.openprovenance.prov.model.Value getValue() {
if (value == null) {
if (// TODO: inefficient, I search this list every time getValue is called, though there may be no value
all != null) {
for (Attribute attr : all) {
if (attr instanceof org.openprovenance.prov.model.Value) {
value = (Value) attr;
}
}
}
}
return value;
}Example 20
| Project: rhq-master File: MappingTranslator.java View source code |
private static String[] getPkColumns(Node node) {
Set<AnnotatedField> pkFields = getIdFields(node.getEntity());
if (pkFields.isEmpty()) {
return null;
}
String[] columns = new String[pkFields.size()];
int idx = 0;
for (AnnotatedField f : pkFields) {
columns[idx] = getColumnName(f);
if (columns[idx] == null) {
//check for the special case, @Id with @JoinColumn and @ManyToOne
ManyToOne manyToOne = f.getAnnotation(ManyToOne.class);
if (manyToOne == null) {
columns[idx] = f.getName().toUpperCase();
} else {
JoinColumn joinColumn = f.getAnnotation(JoinColumn.class);
columns[idx] = joinColumn.name();
if (columns[idx].isEmpty()) {
columns[idx] = f.getName().toUpperCase();
}
}
}
idx++;
}
return columns;
}Example 21
| Project: seasar2-master File: PropertyMetaFactoryImpl.java View source code |
/**
* JoinColumnを処����。
*
* @param propertyMeta
* プãƒãƒ‘ティメタデータ
* @param field
* フィールド
* @param entityMeta
* エンティティメタデータ
*/
protected void doJoinColumn(PropertyMeta propertyMeta, Field field, EntityMeta entityMeta) {
JoinColumn joinColumn = field.getAnnotation(JoinColumn.class);
if (joinColumn != null) {
JoinColumnMeta meta = new JoinColumnMeta(joinColumn.name(), joinColumn.referencedColumnName());
propertyMeta.addJoinColumnMeta(meta);
} else {
JoinColumns joinColumns = field.getAnnotation(JoinColumns.class);
if (joinColumns != null) {
JoinColumn[] array = joinColumns.value();
for (int i = 0; i < array.length; i++) {
JoinColumn jc = array[i];
JoinColumnMeta meta = new JoinColumnMeta(jc.name(), jc.referencedColumnName());
if (i > 0 && (meta.getName() == null || meta.getReferencedColumnName() == null)) {
throw new JoinColumnNameAndReferencedColumnNameMandatoryRuntimeException(entityMeta.getName(), propertyMeta.getName(), i + 1);
}
propertyMeta.addJoinColumnMeta(meta);
}
}
}
}Example 22
| Project: jain-slee-master File: ConcreteProfileEntityGenerator.java View source code |
/**
* Generates a class that extends {@link ProfileEntityArrayAttributeValue} for a specific entity attribute of array type value
* @param concreteProfileEntityClass
* @param profileAttributeName
* @return
*/
private Class<?> generateProfileAttributeArrayValueClass(CtClass concreteProfileEntityClass, String profileAttributeName, boolean unique) {
CtClass concreteArrayValueClass = null;
try {
// define the concrete profile attribute array value class name
String concreteArrayValueClassName = profileComponent.getProfileCmpInterfaceClass().getName() + "PEAAV_" + ClassGeneratorUtils.capitalize(profileAttributeName);
// create javassist class
concreteArrayValueClass = ClassGeneratorUtils.createClass(concreteArrayValueClassName, new String[] { Serializable.class.getName() });
// set inheritance
ClassGeneratorUtils.createInheritanceLink(concreteArrayValueClass, ProfileEntityArrayAttributeValue.class.getName());
// annotate class with @Entity
ClassGeneratorUtils.addAnnotation(Entity.class.getName(), new LinkedHashMap<String, Object>(), concreteArrayValueClass);
// generate a random table name
addTableAnnotationToPEAAV("SLEE_PEAAV_" + profileComponent.getProfileCmpInterfaceClass().getSimpleName() + "_" + Math.abs((long) profileComponent.getComponentID().hashCode()) + profileAttributeName, unique, concreteArrayValueClass);
// override @id
String getIdNameMethodSrc = "public long getId() { return super.getId(); }";
CtMethod getIdNameMethod = CtNewMethod.make(getIdNameMethodSrc, concreteArrayValueClass);
ClassGeneratorUtils.addAnnotation(Id.class.getName(), new LinkedHashMap<String, Object>(), getIdNameMethod);
ClassGeneratorUtils.addAnnotation(GeneratedValue.class.getName(), new LinkedHashMap<String, Object>(), getIdNameMethod);
concreteArrayValueClass.addMethod(getIdNameMethod);
// override getter methods
String getSerializableMethodSrc = "public " + Serializable.class.getName() + " getSerializable() { return super.getSerializable(); }";
CtMethod getSerializableMethod = CtNewMethod.make(getSerializableMethodSrc, concreteArrayValueClass);
LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>();
map.put("name", "serializable");
map.put("length", 512);
//if (unique)map.put("unique", true);
ClassGeneratorUtils.addAnnotation(Column.class.getName(), map, getSerializableMethod);
concreteArrayValueClass.addMethod(getSerializableMethod);
String getStringMethodSrc = "public String getString() { return super.getString(); }";
CtMethod getStringMethod = CtNewMethod.make(getStringMethodSrc, concreteArrayValueClass);
map = new LinkedHashMap<String, Object>();
map.put("name", "string");
//if (unique)map.put("unique", true);
ClassGeneratorUtils.addAnnotation(Column.class.getName(), map, getStringMethod);
concreteArrayValueClass.addMethod(getStringMethod);
// FIXME add join columns here or in profile entity class to make
// the relation without a join table, atm if this is changed, the
// inserts on this table go with profile and table name as null %)
// THE PROFILENTITY FIELD IN AAV CLASS IS REQUIRED FOR THE RELATION WITH PROFILE ENTITY CLASS WITHOUT A JOIN TABLE
// add join column regarding the relation from array attr value to profile entity
CtField ctField = ClassGeneratorUtils.addField(concreteProfileEntityClass, "owner", concreteArrayValueClass);
ClassGeneratorUtils.generateSetter(ctField, null);
CtMethod getter = ClassGeneratorUtils.generateGetter(ctField, null);
//ClassGeneratorUtils.addAnnotation(ManyToOne.class.getName(), new LinkedHashMap<String, Object>(), getter);
// ----
ConstPool cp = getter.getMethodInfo().getConstPool();
AnnotationsAttribute attr = (AnnotationsAttribute) getter.getMethodInfo().getAttribute(AnnotationsAttribute.visibleTag);
if (attr == null) {
attr = new AnnotationsAttribute(cp, AnnotationsAttribute.visibleTag);
}
Annotation manyToOne = new Annotation(ManyToOne.class.getName(), cp);
manyToOne.addMemberValue("optional", new BooleanMemberValue(false, cp));
attr.addAnnotation(manyToOne);
Annotation joinColumns = new Annotation(JoinColumns.class.getName(), cp);
Annotation joinColumn1 = new Annotation(JoinColumn.class.getName(), cp);
joinColumn1.addMemberValue("name", new StringMemberValue("owner_tableName", cp));
joinColumn1.addMemberValue("referencedColumnName", new StringMemberValue("tableName", cp));
Annotation joinColumn2 = new Annotation(JoinColumn.class.getName(), cp);
joinColumn2.addMemberValue("name", new StringMemberValue("owner_profileName", cp));
joinColumn2.addMemberValue("referencedColumnName", new StringMemberValue("profileName", cp));
ArrayMemberValue joinColumnsMemberValue = new ArrayMemberValue(cp);
joinColumnsMemberValue.setValue(new MemberValue[] { new AnnotationMemberValue(joinColumn1, cp), new AnnotationMemberValue(joinColumn2, cp) });
joinColumns.addMemberValue("value", joinColumnsMemberValue);
attr.addAnnotation(joinColumns);
getter.getMethodInfo().addAttribute(attr);
// generate concrete setProfileEntity method
String setProfileEntityMethodSrc = "public void setProfileEntity(" + ProfileEntity.class.getName() + " profileEntity){ setOwner((" + concreteProfileEntityClass.getName() + ")profileEntity); }";
CtMethod setProfileEntityMethod = CtMethod.make(setProfileEntityMethodSrc, concreteArrayValueClass);
concreteArrayValueClass.addMethod(setProfileEntityMethod);
// write and load the attr array value class
String deployDir = profileComponent.getDeploymentDir().getAbsolutePath();
if (logger.isDebugEnabled()) {
logger.debug("Writing PROFILE ATTR ARRAY VALUE CONCRETE CLASS ( " + concreteArrayValueClass.getName() + " ) to: " + deployDir);
}
concreteArrayValueClass.writeFile(deployDir);
return Thread.currentThread().getContextClassLoader().loadClass(concreteArrayValueClass.getName());
} catch (Throwable e) {
throw new SLEEException(e.getMessage(), e);
} finally {
if (concreteArrayValueClass != null) {
concreteArrayValueClass.defrost();
}
}
}Example 23
| Project: openjpa-master File: AnnotationPersistenceMappingParser.java View source code |
/**
* Parse @AssociationOverride(s).
*/
private void parseAssociationOverrides(ClassMapping cm, AssociationOverride... assocs) {
FieldMapping sup;
JoinColumn[] scols;
int unique;
List<Column> jcols;
JoinTable joinTbl;
for (AssociationOverride assoc : assocs) {
if (StringUtil.isEmpty(assoc.name()))
throw new MetaDataException(_loc.get("no-override-name", cm));
sup = (FieldMapping) cm.getDefinedSuperclassField(assoc.name());
if (sup == null)
sup = (FieldMapping) cm.addDefinedSuperclassField(assoc.name(), Object.class, Object.class);
scols = assoc.joinColumns();
joinTbl = assoc.joinTable();
if ((scols == null || scols.length == 0) && joinTbl == null)
//continue;
throw new MetaDataException(_loc.get("embed-override-name", sup, assoc.name()));
if (scols != null && scols.length > 0) {
jcols = new ArrayList<Column>(scols.length);
unique = 0;
for (JoinColumn scol : scols) {
unique |= (scol.unique()) ? TRUE : FALSE;
jcols.add(newColumn(scol));
}
setColumns(sup, sup.getValueInfo(), jcols, unique);
} else if (joinTbl != null) {
parseJoinTable(sup, joinTbl);
}
}
}Example 24
| Project: opentides3-master File: CacheUtil.java View source code |
/**
* Retrieves persistent fields from the cache, if available. Otherwise,
* returns the list of field names that are persisted in database. These
* includes all non-transient fields. This method uses reflection and
* annotation to generate the list of fields.
*
* @param obj
* @return
*/
public static Map<String, String> getColumnNames(BaseEntity obj, Class<?> clazz, boolean includeParent) {
if (clazz == null)
clazz = obj.getClass();
String clazzCode = clazz.toString() + ";p=" + includeParent;
Map<String, String> ret = columnNames.get(clazzCode);
if (ret == null) {
Map<String, String> columns = new HashMap<String, String>();
final List<Field> fields = CrudUtil.getAllFields(clazz, includeParent);
for (Field field : fields) {
if (CacheUtil.isPersistent(field)) {
Annotation annotation = field.getAnnotation(Column.class);
if (annotation == null) {
annotation = field.getAnnotation(JoinColumn.class);
}
if (annotation != null) {
try {
String name = (String) annotation.annotationType().getMethod("name").invoke(annotation);
columns.put(field.getName(), name);
} catch (Exception e) {
_log.warn("Unable to execute annotated method @Column of " + obj.getClass().getSimpleName(), e);
}
} else {
annotation = field.getAnnotation(Columns.class);
if (annotation != null) {
try {
Column[] cols = (Column[]) annotation.annotationType().getMethod("columns").invoke(annotation);
if (cols != null && cols.length > 0) {
String name = "";
for (int i = 0; i < cols.length; i++) {
if (i > 0) {
name += ",";
}
name += cols[i].name();
}
columns.put(field.getName(), name);
}
} catch (Exception ex) {
_log.warn("Unable to execute annotated method @Columns of " + obj.getClass().getSimpleName(), ex);
}
}
}
}
}
if (_log.isDebugEnabled()) {
_log.debug(clazz.getSimpleName() + " contains the following persistent fields");
for (String fieldName : columns.keySet()) {
_log.debug(fieldName);
}
}
columnNames.put(clazzCode, columns);
ret = columnNames.get(clazzCode);
}
return ret;
}Example 25
| Project: requery-master File: AttributeMember.java View source code |
private void processBasicColumnAnnotations(ElementValidator validator) {
if (annotationOf(Key.class).isPresent() || annotationOf(javax.persistence.Id.class).isPresent()) {
isKey = true;
if (isTransient) {
validator.error("Key field cannot be transient");
}
}
// generated keys can't be set through a setter
if (annotationOf(Generated.class).isPresent() || annotationOf(GeneratedValue.class).isPresent()) {
isGenerated = true;
isReadOnly = true;
// check generation strategy
annotationOf(GeneratedValue.class).ifPresent( generatedValue -> {
if (generatedValue.strategy() != GenerationType.IDENTITY && generatedValue.strategy() != GenerationType.AUTO) {
validator.warning("GeneratedValue.strategy() " + generatedValue.strategy() + " not supported", generatedValue.getClass());
}
});
}
if (annotationOf(Lazy.class).isPresent()) {
if (isKey) {
cannotCombine(validator, Key.class, Lazy.class);
}
isLazy = true;
}
if (annotationOf(Nullable.class).isPresent() || isOptional || Mirrors.findAnnotationMirror(element(), "javax.annotation.Nullable").isPresent()) {
isNullable = true;
} else {
// if not a primitive type the value assumed nullable
if (element().getKind().isField()) {
isNullable = !element().asType().getKind().isPrimitive();
} else if (element().getKind() == ElementKind.METHOD) {
ExecutableElement executableElement = (ExecutableElement) element();
isNullable = !executableElement.getReturnType().getKind().isPrimitive();
}
}
if (annotationOf(Version.class).isPresent() || annotationOf(javax.persistence.Version.class).isPresent()) {
isVersion = true;
if (isKey) {
cannotCombine(validator, Key.class, Version.class);
}
}
Column column = annotationOf(Column.class).orElse(null);
ForeignKey foreignKey = null;
boolean foreignKeySetFromColumn = false;
if (column != null) {
name = "".equals(column.name()) ? null : column.name();
isUnique = column.unique();
isNullable = column.nullable();
defaultValue = column.value();
collate = column.collate();
definition = column.definition();
if (column.length() > 0) {
length = column.length();
}
if (column.foreignKey().length > 0) {
foreignKey = column.foreignKey()[0];
foreignKeySetFromColumn = true;
}
}
if (!foreignKeySetFromColumn) {
foreignKey = annotationOf(ForeignKey.class).orElse(null);
}
if (foreignKey != null) {
this.isForeignKey = true;
deleteAction = foreignKey.delete();
updateAction = foreignKey.update();
referencedColumn = foreignKey.referencedColumn();
}
annotationOf(Index.class).ifPresent( index -> {
isIndexed = true;
Collections.addAll(indexNames, index.value());
});
// JPA specific
annotationOf(Basic.class).ifPresent( basic -> {
isNullable = basic.optional();
isLazy = basic.fetch() == FetchType.LAZY;
});
annotationOf(javax.persistence.Index.class).ifPresent( index -> {
isIndexed = true;
Collections.addAll(indexNames, index.name());
});
annotationOf(JoinColumn.class).ifPresent( joinColumn -> {
javax.persistence.ForeignKey joinForeignKey = joinColumn.foreignKey();
this.isForeignKey = true;
ConstraintMode constraintMode = joinForeignKey.value();
switch(constraintMode) {
default:
case PROVIDER_DEFAULT:
case CONSTRAINT:
deleteAction = ReferentialAction.CASCADE;
updateAction = ReferentialAction.CASCADE;
break;
case NO_CONSTRAINT:
deleteAction = ReferentialAction.NO_ACTION;
updateAction = ReferentialAction.NO_ACTION;
break;
}
this.referencedTable = joinColumn.table();
this.referencedColumn = joinColumn.referencedColumnName();
});
annotationOf(javax.persistence.Column.class).ifPresent( persistenceColumn -> {
name = "".equals(persistenceColumn.name()) ? null : persistenceColumn.name();
isUnique = persistenceColumn.unique();
isNullable = persistenceColumn.nullable();
length = persistenceColumn.length();
isReadOnly = !persistenceColumn.updatable();
definition = persistenceColumn.columnDefinition();
});
annotationOf(Enumerated.class).ifPresent( enumerated -> {
EnumType enumType = enumerated.value();
if (enumType == EnumType.ORDINAL) {
converterType = EnumOrdinalConverter.class.getCanonicalName();
}
});
}Example 26
| Project: screensaver-master File: ModelIntrospectionUtil.java View source code |
public static boolean isNonNullableProperty(PropertyDescriptor propertyDescriptor) {
Method getter = propertyDescriptor.getReadMethod();
javax.persistence.Column jpaColumn = getter.getAnnotation(javax.persistence.Column.class);
JoinColumn jpaJoinColumn = getter.getAnnotation(JoinColumn.class);
ManyToOne manyToOne = getter.getAnnotation(ManyToOne.class);
OneToOne oneToOne = getter.getAnnotation(OneToOne.class);
return (jpaColumn != null && !jpaColumn.nullable()) || (jpaJoinColumn != null && !jpaJoinColumn.nullable()) || (manyToOne != null && !manyToOne.optional()) || (oneToOne != null && !oneToOne.optional());
}Example 27
| Project: hbnpojogen-master File: Core.java View source code |
/**
* @param classes
*/
private static void addImports(TreeMap<String, Clazz> classes) {
for (Clazz clazz : classes.values()) {
clazz.getImports().add("javax.persistence.Transient");
List<String> keySearch = new LinkedList<String>();
String tmp = clazz.getClassPackage() + "." + clazz.getClassName();
keySearch.add(tmp);
keySearch.add("*." + clazz.getClassName());
keySearch.add(clazz.getClassPackage() + ".*");
keySearch.add("*.*");
String classannotation = "";
for (String key : keySearch) {
String ann = State.getInstance().customClassAnnotations.get(key);
if (ann != null) {
classannotation = String.format("%s\n%s", classannotation, ann);
}
}
State.getInstance().customClassAnnotations.put(tmp, classannotation);
for (JoinTable joinTable : clazz.getJoinMappings()) {
clazz.getImports().add(joinTable.getDstProperty().getClazz().getFullClassName());
}
if (!clazz.isSubclass()) {
if (!clazz.isEmbeddable()) {
if (State.getInstance().isEnableSpringData()) {
clazz.getImports().add(SyncUtils.getConfigPackage("", PackageTypeEnum.UTIL) + ".IPojoGenEntity");
} else {
clazz.getImports().add("com.github.wwadge.hbnpojogen.persistence.IPojoGenEntity");
}
}
clazz.getImports().add("java.io.Serializable");
}
if (!clazz.isEmbeddable() && !clazz.hasEmbeddableClass()) {
if (!clazz.isSubclass()) {
clazz.getImports().add("java.util.Map");
clazz.getImports().add("java.util.Collections");
clazz.getImports().add("java.util.WeakHashMap");
}
clazz.getImports().add("org.hibernate.proxy.HibernateProxy");
// clazz.getImports().add(clazz.getDataLayerImplFullClassName());
}
boolean didScrubbedEnum = false;
for (PropertyObj property : clazz.getProperties().values()) {
if (property.isDefaultValue()) {
clazz.setDynamicUpdatesInserts(true);
}
if (property.isGeneratedValue()) {
switch(property.getGeneratorType()) {
case AUTO:
if (!property.isComposite()) {
clazz.getImports().add("javax.persistence.GenerationType");
clazz.getImports().add("javax.persistence.GeneratedValue");
}
// no annotation necessary
break;
case GUID:
clazz.setGeneratedValueGUID(true);
clazz.getImports().add("javax.persistence.GeneratedValue");
break;
case CUSTOM:
clazz.setGeneratedValueCustom(true);
clazz.getImports().add("javax.persistence.GeneratedValue");
break;
case PKS:
clazz.setGeneratedValuePKS(true);
clazz.getImports().add("javax.persistence.GeneratedValue");
break;
case IDAWARE:
clazz.setGeneratedValueIDAware(true);
clazz.getImports().add("javax.persistence.GeneratedValue");
break;
case UUID:
clazz.setGeneratedValueUUID(true);
clazz.getImports().add("javax.persistence.GeneratedValue");
clazz.getImports().add("org.hibernate.annotations.Parameter");
break;
case UUIDWithoutDashes:
clazz.setGeneratedValueUUIDWithoutDashes(true);
clazz.getImports().add("javax.persistence.GeneratedValue");
break;
default:
break;
}
}
if (property.isOneToMany() && !property.isOneToNBackLinkDisabled()) {
clazz.getImports().add("javax.persistence.OneToMany");
clazz.getImports().add("javax.persistence.FetchType");
if (property.isOneToManyCascadeEnabledByConfig()) {
clazz.getImports().add("javax.persistence.CascadeType");
}
clazz.getImports().add("java.util.HashSet");
clazz.getImports().add("java.util.Set");
if (!property.getOneToManyLink().getClazz().isEmbeddable()) {
clazz.getImports().add(property.getOneToManyLink().getClazz().getFullClassName());
} else {
clazz.getImports().add(property.getOneToManyLink().getClazz().getEmbeddedFrom().getFullClassName());
}
}
if (property.isManyToMany() && !property.isOneToNBackLinkDisabled()) {
clazz.getImports().add("java.util.HashSet");
clazz.getImports().add("java.util.Set");
clazz.getImports().add("javax.persistence.FetchType");
clazz.getImports().add("javax.persistence.ManyToMany");
if (property.isManyToManyCascadeEnabledByConfig()) {
clazz.getImports().add("javax.persistence.CascadeType");
}
}
if (property.isManyToOne() && !property.isManyToMany()) {
clazz.getImports().add("javax.persistence.JoinColumn");
}
if (property.isOneToOne()) {
clazz.getImports().add("javax.persistence.OneToOne");
clazz.getImports().add("javax.persistence.FetchType");
if (!property.isOneTooneInverseSide()) {
clazz.getImports().add("javax.persistence.JoinColumn");
}
if (property.isOneToOneCascadeEnabledByConfig()) {
clazz.getImports().add("javax.persistence.CascadeType");
}
}
if (property.isManyToOne() && property.isManyToOneCascadeEnabledByConfig()) {
clazz.getImports().add("javax.persistence.CascadeType");
}
if (property.isEnumType()) {
clazz.getImports().add(Core.doEnumImport(clazz.getTableObj().getDbCat(), property.getFieldObj().getEnumName()));
if (clazz.getTableObj().isContainsScrubbedEnum()) {
if (!didScrubbedEnum) {
didScrubbedEnum = true;
enumTypedefImport(classes, clazz, tmp);
}
} else {
clazz.getImports().add("javax.persistence.Enumerated");
clazz.getImports().add("javax.persistence.EnumType");
}
}
if (property.isArrayType()) {
clazz.getImports().add("java.util.Arrays");
}
if (property.isTransientField()) {
clazz.getImports().add("javax.persistence.Transient");
}
if ((property.getJavaType() != null) && property.getJavaType().equalsIgnoreCase(Constants.DATE)) {
clazz.getImports().add("java.util.Date");
}
if ((property.getJavaType() != null) && property.getJavaType().equalsIgnoreCase(Constants.LOCALDATE)) {
if (State.getInstance().isEnableJDK8Support()) {
clazz.getImports().add("java.time.LocalDate");
} else {
clazz.getImports().add("org.joda.time.LocalDate");
}
clazz.getImports().add("org.hibernate.annotations.Type");
}
if ((property.getJavaType() != null) && (property.getJavaType().equalsIgnoreCase(Constants.DATETIME) || property.getJavaType().equalsIgnoreCase(Constants.OFFSETDATETIME))) {
if (State.getInstance().isEnableJDK8Support()) {
clazz.getImports().add("java.time.OffsetDateTime");
} else {
clazz.getImports().add("org.joda.time.DateTime");
}
clazz.getImports().add("org.hibernate.annotations.Type");
}
if (!property.getColumnAnnotation().equals("")) {
clazz.getImports().add("javax.persistence.Column");
}
if (!property.isNullable()) {
clazz.getImports().add("javax.persistence.Basic");
}
if (State.getInstance().isEnableHibernateValidator()) {
if (!property.getValidatorAnnotations().isEmpty()) {
if (!property.isManyToOne() && !property.isManyToMany() && !property.isPFK() && !property.isOneToOne()) {
if (!property.isNullable()) {
clazz.getImports().add("com.github.wwadge.hbnpojogen.persistence.validator.Mandatory");
}
}
if (property.isValidatorAnnotated()) {
clazz.getImports().add("org.hibernate.validator.Valid");
}
if (property.hasLength()) {
clazz.getImports().add("org.hibernate.validator.Length");
}
}
}
}
// else {
// clazz.setClassAnnotation("");
// }
String classCustomCode = State.getInstance().customClassCode.get(clazz.getClassPackage() + "." + clazz.getClassName());
if (classCustomCode != null) {
clazz.setClassCustomCode(classCustomCode);
} else {
clazz.setClassCustomCode("");
}
String classCustomCodeFields = State.getInstance().customClassCodeFields.get(clazz.getClassPackage() + "." + clazz.getClassName());
if (classCustomCode != null) {
// System.out.println(clazz.getClassPackage() + "."
// + clazz.getClassName());
clazz.setClassCustomCodeFields(classCustomCodeFields);
} else {
clazz.setClassCustomCodeFields("");
}
for (String key : keySearch) {
TreeSet<String> customClassImports = State.getInstance().customClassImports.get(key);
if (customClassImports != null) {
clazz.getImports().addAll(customClassImports);
}
}
TreeSet<String> customInterfaces = State.getInstance().customClassInterfaces.get(clazz.getClassPackage() + "." + clazz.getClassName());
if (customInterfaces != null) {
clazz.getCustomInterfaces().addAll(customInterfaces);
}
customInterfaces = State.getInstance().customClassInterfaces.get(clazz.getClassPackage() + ".*");
if (customInterfaces != null) {
clazz.getCustomInterfaces().addAll(customInterfaces);
}
customInterfaces = State.getInstance().customClassInterfaces.get("*." + clazz.getClassName());
if (customInterfaces != null) {
clazz.getCustomInterfaces().addAll(customInterfaces);
}
customInterfaces = State.getInstance().customClassInterfaces.get("*.*");
if (customInterfaces != null) {
clazz.getCustomInterfaces().addAll(customInterfaces);
}
TreeSet<String> customExtends = State.getInstance().customClassExtends.get(clazz.getClassPackage() + "." + clazz.getClassName());
if (customExtends != null) {
clazz.getCustomExtends().addAll(customExtends);
}
customExtends = State.getInstance().customClassExtends.get(clazz.getClassPackage() + ".*");
if (customExtends != null) {
clazz.getCustomExtends().addAll(customExtends);
}
customExtends = State.getInstance().customClassExtends.get("*." + clazz.getClassName());
if (customExtends != null) {
clazz.getCustomExtends().addAll(customExtends);
}
customExtends = State.getInstance().customClassExtends.get("*.*");
if (customExtends != null) {
clazz.getCustomExtends().addAll(customExtends);
}
TreeMap<String, CustomAnnotations> annotation = State.getInstance().customAnnotations.get(clazz.getClassPackage() + "." + clazz.getClassName());
if (annotation == null) {
annotation = State.getInstance().customAnnotations.get("*." + clazz.getClassName());
if (annotation == null) {
annotation = State.getInstance().customAnnotations.get(clazz.getClassPackage() + ".*");
if (annotation == null) {
annotation = State.getInstance().customAnnotations.get("*.*");
}
}
}
if (annotation != null) {
// we have some custom annotation
for (Entry<String, PropertyObj> property : clazz.getProperties().entrySet()) {
CustomAnnotations settings = annotation.get(property.getValue().getJavaName());
if (settings != null) {
property.getValue().getPropertyLevelAnnotations().addAll(settings.getPropertyLevelAnnotations());
property.getValue().getMethodLevelAnnotationsOnGetters().addAll(settings.getMethodLevelAnnotationsOnGetters());
property.getValue().getMethodLevelAnnotationsOnSetters().addAll(settings.getMethodLevelAnnotationsOnSetters());
property.getValue().getMethodLevelSettersPrecondition().addAll(settings.getMethodLevelSetterPrecondition());
property.getValue().getMethodLevelGettersPrecondition().addAll(settings.getMethodLevelGetterPrecondition());
property.getValue().getMethodLevelSettersPostcondition().addAll(settings.getMethodLevelSetterPostcondition());
property.getValue().getMethodLevelGettersPostcondition().addAll(settings.getMethodLevelGetterPostcondition());
}
}
}
String classAnnotation = State.getInstance().customClassAnnotations.get(clazz.getClassPackage() + "." + clazz.getClassName());
if (classAnnotation != null) {
clazz.getClassAnnotation().add(classAnnotation);
}
String typeDefAnnotation = State.getInstance().classTypeDefsAnnotations.get(clazz.getClassPackage() + "." + clazz.getClassName());
if (typeDefAnnotation != null) {
clazz.getClassTypedefsAnnotation().add(typeDefAnnotation);
}
}
}Example 28
| Project: breeze.server.java-master File: JPAMetadata.java View source code |
/**
* Get the column names for the given attribute. Recurses into embedded complex types.
* @param attr
* @return
*/
List<String> getAttributeColumnNames(Attribute attr) {
List<String> names = new ArrayList<String>();
if (attr.getPersistentAttributeType() == PersistentAttributeType.EMBEDDED) {
@SuppressWarnings("unchecked") EmbeddableType<?> bed = _emFactory.getMetamodel().embeddable(attr.getJavaType());
for (Attribute<?, ?> battr : bed.getAttributes()) {
// recursive call
names.addAll(getAttributeColumnNames(battr));
}
return names;
}
if (attr.getPersistentAttributeType() == PersistentAttributeType.ONE_TO_MANY || attr.getPersistentAttributeType() == PersistentAttributeType.ONE_TO_ONE) {
Class<?> relatedEntityClass = getEntityType(attr);
javax.persistence.metamodel.EntityType<?> relatedEntityType = _emFactory.getMetamodel().entity(relatedEntityClass);
OneToMany otm = ((AnnotatedElement) attr.getJavaMember()).getAnnotation(OneToMany.class);
if (otm != null && !isEmpty(otm.mappedBy())) {
Attribute mappedAttr = relatedEntityType.getAttribute(otm.mappedBy());
return getAttributeColumnNames(mappedAttr);
}
OneToOne oto = ((AnnotatedElement) attr.getJavaMember()).getAnnotation(OneToOne.class);
if (oto != null && !isEmpty(oto.mappedBy())) {
Attribute mappedAttr = relatedEntityType.getAttribute(oto.mappedBy());
return getAttributeColumnNames(mappedAttr);
}
return getIdAttributeColumnNames(relatedEntityType);
}
Column col = ((AnnotatedElement) attr.getJavaMember()).getAnnotation(Column.class);
if (col != null && !isEmpty(col.name())) {
names.add(col.name());
return names;
} else {
JoinColumn jcol = ((AnnotatedElement) attr.getJavaMember()).getAnnotation(JoinColumn.class);
if (jcol != null && !isEmpty(jcol.name())) {
names.add(jcol.name());
return names;
} else {
JoinColumns jcols = ((AnnotatedElement) attr.getJavaMember()).getAnnotation(JoinColumns.class);
if (jcols != null && jcols.value() != null) {
for (JoinColumn jjcol : jcols.value()) {
names.add(jjcol.name());
}
return names;
} else {
names.add(attr.getName());
return names;
}
}
}
}Example 29
| Project: hibernate-tools-master File: EntityPOJOClass.java View source code |
private void buildJoinColumnAnnotation(Selectable selectable, Selectable referencedColumn, StringBuffer annotations, boolean insertable, boolean updatable) {
if (selectable.isFormula()) {
//TODO not supported by HA
} else {
Column column = (Column) selectable;
annotations.append("@").append(importType("javax.persistence.JoinColumn")).append("(name=\"").append(column.getName()).append("\"");
//TODO handle referenced column name, this is a hard one
if (referencedColumn != null) {
annotations.append(", referencedColumnName=\"").append(referencedColumn.getText()).append("\"");
}
appendCommonColumnInfo(annotations, column, insertable, updatable);
//TODO support secondary table
annotations.append(")");
}
}Example 30
| Project: ef-orm-master File: MetaHolder.java View source code |
private static JoinPath getHint(FieldAnnotationProvider annos, AbstractMetadata meta, ITableMetadata target) {
if (annos.getAnnotation(JoinColumn.class) != null) {
JoinColumn j = annos.getAnnotation(JoinColumn.class);
return processJoin(meta, target, annos, j);
} else if (annos.getAnnotation(JoinColumns.class) != null) {
JoinColumns jj = annos.getAnnotation(JoinColumns.class);
return processJoin(meta, target, annos, jj.value());
} else if (annos.getAnnotation(JoinTable.class) != null) {
JoinTable jt = annos.getAnnotation(JoinTable.class);
return processJoin(meta, target, annos, jt);
}
return null;
}Example 31
| Project: jobexchangeGit-master File: AccessHistoryApplicant.java View source code |
/**
* @return the accessedApplicantProfile
*/
@ManyToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE })
@JoinColumn(nullable = true)
public Applicant getAccessedApplicantProfile() {
return accessedApplicantProfile;
}Example 32
| Project: brix-cms-plugins-master File: Role.java View source code |
@ManyToMany @JoinTable(name = "ROLE_PERMISSION", joinColumns = @JoinColumn(name = "ROLE_ID", referencedColumnName = "ID"), inverseJoinColumns = @JoinColumn(name = "PERMISSION_ID", referencedColumnName = "ID")) public Set<Permission> getPermissions() { return permissions; }
Example 33
| Project: CompEd-master File: ConcreteCompetency.java View source code |
@ManyToMany @JoinTable(name = "ccs_cp", joinColumns = @JoinColumn(name = "cc_id", referencedColumnName = "id"), inverseJoinColumns = @JoinColumn(name = "cp_id", referencedColumnName = "id")) public List<CompetencyProcess> getProcesses() { return processes; }
Example 34
| Project: deliciousfruit-master File: Task.java View source code |
// JPA 基于USER_ID列的多对一关系定义
@ManyToOne
@JoinColumn(name = "user_id")
public User getUser() {
return user;
}Example 35
| Project: jboss-seam-2.3.0.Final-Hibernate.3-master File: Category.java View source code |
@ManyToOne
@JoinColumn(name = "PARENT_CATEGORY_ID")
public Category getParent() {
return parent;
}Example 36
| Project: jspxcms304-master File: InfoComment.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "f_fid", nullable = false, insertable = false, updatable = false)
public Info getInfo() {
return info;
}Example 37
| Project: seam-2.2-master File: Category.java View source code |
@ManyToOne
@JoinColumn(name = "PARENT_CATEGORY_ID")
public Category getParent() {
return parent;
}Example 38
| Project: seam2jsf2-master File: Category.java View source code |
@ManyToOne
@JoinColumn(name = "PARENT_CATEGORY_ID")
public Category getParent() {
return parent;
}Example 39
| Project: shopb2b-master File: Parameter.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(nullable = false)
public ParameterGroup getParameterGroup() {
return this.parameterGroup;
}Example 40
| Project: sneo-master File: FixedIpV4Route.java View source code |
@ManyToOne(optional = false, fetch = FetchType.LAZY)
@JoinColumn(name = "NODE_ID", nullable = false)
public Node getNode() {
return node;
}Example 41
| Project: springlab-master File: Reply.java View source code |
//与主题的多对一关系
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "subject_id")
public Subject getSubject() {
return subject;
}Example 42
| Project: threadfixRack-master File: AccessControlApplicationMap.java View source code |
@ManyToOne
@JoinColumn(name = "accessControlTeamMapId", nullable = false)
public AccessControlTeamMap getAccessControlTeamMap() {
return accessControlTeamMap;
}Example 43
| Project: intellij-samples-master File: OrderItem.java View source code |
@ManyToOne
@javax.persistence.JoinColumn(name = "order_id", referencedColumnName = "id", nullable = false)
public Order getOrderByOrderId() {
return orderByOrderId;
}Example 44
| Project: 5.2.0.RC-master File: RoleDepartment.java View source code |
@ManyToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE })
@JoinColumn(name = "FK_ROLE_ID")
public Role getRole() {
return role;
}Example 45
| Project: biobank-master File: Comment.java View source code |
@NotNull(message = "{edu.ualberta.med.biobank.model.Comment.user.NotNull}")
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "USER_ID", nullable = false)
public User getUser() {
return this.user;
}Example 46
| Project: cims-master File: UserDeptRelation.java View source code |
@ManyToOne
@JoinColumn(name = "user_id")
public User getUser() {
return user;
}Example 47
| Project: edu-master File: LineItem.java View source code |
@ManyToOne
@JoinColumn(name = "order_id")
public Order getOrder() {
return order;
}Example 48
| Project: exit-web-framework-master File: Role.java View source code |
@ManyToMany
@JoinTable(name = "TB_ACCOUNT_ROLE_MENU", joinColumns = { @JoinColumn(name = "ROLE_ID") }, inverseJoinColumns = { @JoinColumn(name = "MENU_ID") })
public List<Menu> getMenuList() {
return menuList;
}Example 49
| Project: fiware-rss-master File: Role.java View source code |
@ManyToMany
@JoinTable(name = "USER_ROLES", joinColumns = { @JoinColumn(name = "ROLE_ID") }, inverseJoinColumns = { @JoinColumn(name = "USER_ID") })
public Set<RSUser> getUsers() {
return users;
}Example 50
| Project: fluent-hibernate-master File: Transaction.java View source code |
@ManyToOne
@JoinColumn
public Merchant getMerchant() {
return merchant;
}Example 51
| Project: hibernate-ogm-master File: Beer.java View source code |
@ManyToOne
@JoinColumn(insertable = false, updatable = false, name = "brewery_id")
public Brewery getBrewery() {
return brewery;
}Example 52
| Project: hrms-master File: RoleModule.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "roleId", nullable = false)
public Role getRole() {
return this.role;
}Example 53
| Project: iMatrix6.0.0Dev-master File: RoleDepartment.java View source code |
@ManyToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE })
@JoinColumn(name = "FK_ROLE_ID")
public Role getRole() {
return role;
}Example 54
| Project: ismp_manager-master File: Domain.java View source code |
@ManyToOne
@JoinColumn(name = "parent_id")
public Domain getParentDomain() {
return parentDomain;
}Example 55
| Project: jbosstools-hibernate-master File: GeneNames.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "referenceGeneID", nullable = false, updatable = false, insertable = false)
public ReferencePhysicalGene getReferenceGene() {
return referenceGene;
}Example 56
| Project: jgt-master File: Task.java View source code |
// JPA 基于USER_ID列的多对一关系定义
@ManyToOne
@JoinColumn(name = "user_id")
public User getUser() {
return user;
}Example 57
| Project: OA-master File: ContractProductRecord.java View source code |
@ManyToOne
@JoinColumn(name = "productId", referencedColumnName = "id")
public Product getProduct() {
return product;
}Example 58
| Project: OpenESPI-Common-java-master File: ElectricPowerQualitySummaryPersistenceTests.java View source code |
@Test
public void usagePoint() {
TestUtils.assertAnnotationPresent(ElectricPowerQualitySummary.class, "usagePoint", ManyToOne.class);
TestUtils.assertAnnotationPresent(ElectricPowerQualitySummary.class, "usagePoint", JoinColumn.class);
}Example 59
| Project: ORCID-Source-master File: NotificationAddItemsEntity.java View source code |
@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name = "notification_id")
public Set<NotificationItemEntity> getNotificationItems() {
return notificationItems;
}Example 60
| Project: saos-master File: CommonCourtData.java View source code |
//------------------------ GETTERS --------------------------
@ManyToOne
@JoinColumn(name = "fk_court_division_type")
public CommonCourtDivisionType getDivisionType() {
return divisionType;
}Example 61
| Project: seaminfra-master File: Product.java View source code |
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "type")
@NotNull
public ProductType getType() {
return type;
}Example 62
| Project: spring-mvc-qq-weibo-master File: Task.java View source code |
// JPA 基于USER_ID列的多对一关系定义
@ManyToOne
@JoinColumn(name = "user_id")
public User getUser() {
return user;
}Example 63
| Project: ticket-monster-master File: Document.java View source code |
@OneToOne
@JoinColumn(name = "REVISION_ID")
public Revision getActiveRevision() {
return activeRevision;
}Example 64
| Project: tourismwork-master File: TblLineSights.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "SIGHT_NO", nullable = false, insertable = false, updatable = false)
public Sight getSight() {
return this.sight;
}Example 65
| Project: webctdbexport-master File: GcTask.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "LAST_PROCESS_ID")
public GcProcess getGcProcess() {
return this.gcProcess;
}Example 66
| Project: jboss-ejb3-tutorial-master File: Customer.java View source code |
@OneToOne(cascade = { CascadeType.ALL })
@JoinColumn(name = "ADDRESS_ID")
public Address getAddress() {
return address;
}Example 67
| Project: JBossAS51-master File: Ticket.java View source code |
@ManyToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "CUSTOMER_ID")
public Customer getCustomer() {
return customer;
}Example 68
| Project: JBossAS_5_1_EDG-master File: Ticket.java View source code |
@ManyToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "CUSTOMER_ID")
public Customer getCustomer() {
return customer;
}Example 69
| Project: AIDR-master File: TaskAssignment.java View source code |
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "documentID", nullable = false, insertable = false, updatable = false)
@JsonBackReference
public Document getDocument() {
return this.document;
}Example 70
| Project: artificer-master File: ArtificerStoredQuery.java View source code |
@ElementCollection(fetch = FetchType.EAGER)
@CollectionTable(name = "StoredQuery_propertyNames", joinColumns = @JoinColumn(name = "StoredQuery_queryName"))
public List<String> getPropertyNames() {
return propertyNames;
}Example 71
| Project: blaze-persistence-master File: DocumentForEntityKeyMaps.java View source code |
@ManyToMany @MapKeyJoinColumn(name = "person_id", nullable = false) @JoinTable(name = "doc_coll_contact_docs", joinColumns = @JoinColumn(name = "parent_doc_id"), inverseJoinColumns = @JoinColumn(name = "doc_id")) public Map<PersonForEntityKeyMaps, DocumentForEntityKeyMaps> getContactDocuments() { return contactDocuments; }
Example 72
| Project: cloudconductor-server-master File: EAgent.java View source code |
/**
* @return token for agent authentication
*/
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "agentauthtokenid")
public EAgentAuthToken getToken() {
return this.token;
}Example 73
| Project: cloudtm-data-platform-master File: Beer.java View source code |
@ManyToOne
@JoinColumn(insertable = false, updatable = false, name = "brewery_id")
public Brewery getBrewery() {
return brewery;
}Example 74
| Project: cmop-master File: Application.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "compute_item_id", nullable = false)
public ComputeItem getComputeItem() {
return this.computeItem;
}Example 75
| Project: coner-master File: HandicapGroupHibernateEntity.java View source code |
@ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinTable(name = "handicap_group_handicap_group_sets", joinColumns = { @JoinColumn(name = "handicapGroupId", nullable = false, updatable = false) }, inverseJoinColumns = { @JoinColumn(name = "handicapGroupSetId", nullable = false, updatable = false) })
public Set<HandicapGroupSetHibernateEntity> getHandicapGroupSets() {
return handicapGroupSets;
}Example 76
| Project: corona_src-master File: RelPrjClmBean.java View source code |
/**
* @return ターゲット-�����リレーション
*/
@OneToMany(targetEntity = RelClmProductBean.class)
@ForeignKey(name = "REL_CLM_PRODUCT_IBFK_2")
@JoinColumns({ @JoinColumn(name = "PRJ_ID"), @JoinColumn(name = "TBL_ID") })
public Set<RelClmProductBean> getRelClmProductBean() {
return relClmProductBean;
}Example 77
| Project: curso-javaee-primefaces-master File: Categoria.java View source code |
@ManyToOne
@JoinColumn(name = "categoria_pai_id")
public Categoria getCategoriaPai() {
return categoriaPai;
}Example 78
| Project: dbDiff-master File: LongColumnName.java View source code |
@ManyToOne(optional = false)
@JoinColumn(name = "the_name_of_this_column_is_very_very_long_for_no_reason_whatsoever")
public LongTableName getStuff() {
return m_stuff;
}Example 79
| Project: deltaspike-solder-master File: Address.java View source code |
@ManyToOne(optional = false)
@JoinColumn(name = "PERSON_ID")
public Person getPerson() {
return person;
}Example 80
| Project: ecommercePlaySample-master File: Product.java View source code |
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "categories_id")
public Category getCategory() {
return category;
}Example 81
| Project: Enrichr-master File: SharedGene.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "listid", nullable = false)
public SharedList getSharedList() {
return this.sharedList;
}Example 82
| Project: fastjson-master File: Payment.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "customerNumber", nullable = false, insertable = false, updatable = false)
@JsonIgnore
public Customer getCustomer() {
return this.customer;
}Example 83
| Project: gondor-master File: Process.java View source code |
/**
* @return the service
*/
@ManyToOne
@JoinColumn(name = "SERVICE_ID")
public Service getService() {
return service;
}Example 84
| Project: headmaster-master File: Event.java View source code |
@ManyToMany(cascade = CascadeType.ALL) @OrderColumn @JoinTable(joinColumns = @JoinColumn(name = "event_id"), inverseJoinColumns = @JoinColumn(name = "student_id")) @LazyCollection(LazyCollectionOption.FALSE) public List<Student> getAttendees() { return attendees; }
Example 85
| Project: hibernate-ogm-old-master File: Beer.java View source code |
@ManyToOne
@JoinColumn(insertable = false, updatable = false, name = "brewery_id")
public Brewery getBrewery() {
return brewery;
}Example 86
| Project: hibernate-search-master File: LegacyCarPlant.java View source code |
@IndexedEmbedded
@ManyToOne
@JoinColumn(name = "CAR_ID", insertable = false, updatable = false)
public LegacyCar getCar() {
return car;
}Example 87
| Project: imixs-marty-master File: UserId.java View source code |
/**
* It is important to rename the joinColum to 'ID' so the GlassFish
* jdbcRealm configuration will work on this colum
*
* @return
*/
@JoinTable(name = "USERID_USERGROUP", joinColumns = { @JoinColumn(name = "ID") }, inverseJoinColumns = { @JoinColumn(name = "GROUP_ID") })
@ManyToMany(cascade = CascadeType.PERSIST)
public Set<UserGroup> getUserGroups() {
return userGroups;
}Example 88
| Project: IntelligentMinds-master File: Group.java View source code |
@ManyToMany(fetch = FetchType.LAZY)
@JoinTable(name = "user_group", catalog = "mindmessages", joinColumns = { @JoinColumn(name = "group_id", nullable = false, updatable = false) }, inverseJoinColumns = { @JoinColumn(name = "user_id", nullable = false, updatable = false) })
public Set<User> getUsers() {
return this.users;
}Example 89
| Project: jackson-datatype-hibernate-master File: Payment.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "customerNumber", nullable = false, insertable = false, updatable = false)
@JsonIgnore
public Customer getCustomer() {
return this.customer;
}Example 90
| Project: Java-Examples-master File: Car.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "userId", nullable = false)
@XmlTransient
public User getUser() {
return this.user;
}Example 91
| Project: Java-Pet-Store-master File: Tag.java View source code |
@ManyToMany @JoinTable(name = "TAG_ITEM", joinColumns = @JoinColumn(name = "TAGID", referencedColumnName = "TAGID"), inverseJoinColumns = @JoinColumn(name = "ITEMID", referencedColumnName = "ITEMID")) public Collection<Item> getItems() { return items; }
Example 92
| Project: jblog-master File: ArticleCommentSupport.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "coment_id", nullable = false)
public ArticleComment getArticleComment() {
return this.articleComment;
}Example 93
| Project: jbosstools-integration-tests-master File: FilmActor.java View source code |
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "ACTOR_ID", nullable = false, insertable = false, updatable = false)
public Actor getActor() {
return this.actor;
}Example 94
| Project: jcommerce-master File: AdminAction.java View source code |
@ManyToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE }, fetch = FetchType.LAZY)
@org.hibernate.annotations.Cascade({ org.hibernate.annotations.CascadeType.SAVE_UPDATE })
@Basic(optional = true)
@JoinColumn(name = "parent_id", nullable = true)
public AdminAction getParent() {
return parent;
}Example 95
| Project: jnerator-maven-plugins-master File: Address.java View source code |
/**
* get contact
*/
@ManyToOne
@JoinColumn(name = "contact_id")
public Contact getContact() {
return this.contact;
}Example 96
| Project: jshoper3x-master File: ActIdGroup.java View source code |
@ManyToMany(fetch = FetchType.LAZY)
@JoinTable(name = "act_id_membership", catalog = "jshoper3", joinColumns = { @JoinColumn(name = "GROUP_ID_", nullable = false, updatable = false) }, inverseJoinColumns = { @JoinColumn(name = "USER_ID_", nullable = false, updatable = false) })
public Set<ActIdUser> getActIdUsers() {
return this.actIdUsers;
}Example 97
| Project: juddi-master File: BindingCategoryBag.java View source code |
@OneToOne(optional = false, fetch = FetchType.LAZY)
@JoinColumn(name = "entity_key")
public BindingTemplate getBindingTemplate() {
return bindingTemplate;
}Example 98
| Project: kfs-master File: TemProfileEmergencyContact.java View source code |
@ManyToOne
@JoinColumn(name = "tem_profile_id")
public TemProfile getProfile() {
return profile;
}Example 99
| Project: ldrbrd-master File: AbstractGolfRound.java View source code |
/**
*
* @return
*/
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "crs_id", nullable = false)
@ForeignKey(name = "id")
public Course getCourse() {
return this.course;
}Example 100
| Project: LearningCommunity-master File: BlogTag.java View source code |
@ManyToMany(fetch = FetchType.LAZY)
@JoinTable(name = "relBlogTag", catalog = "LearningCommunity", joinColumns = { @JoinColumn(name = "blogTagId", nullable = false, updatable = false) }, inverseJoinColumns = { @JoinColumn(name = "blogId", nullable = false, updatable = false) })
public Set<Blog> getBlogs() {
return this.blogs;
}Example 101
| Project: Lemo-Data-Management-Server-master File: CourseAttribute.java View source code |
/**
* @return the learningId
*/
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "course_id")
public Course getCourse() {
return course;
}