Java ClassDescriptor.getPkFields方法代码示例

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private Object getReferenceFKValue(Object persistableObject, ObjectReferenceDescriptor chkRefCld, String fkName) {
    ClassDescriptor classDescriptor = getClassDescriptor(persistableObject.getClass());
    Object referenceObject = ObjectUtils.getPropertyValue(persistableObject, chkRefCld.getAttributeName());

    if (referenceObject == null) {
        return null;
    }

    FieldDescriptor[] refFkNames = chkRefCld.getForeignKeyFieldDescriptors(classDescriptor);
    ClassDescriptor refCld = getClassDescriptor(chkRefCld.getItemClass());
    FieldDescriptor[] refPkNames = refCld.getPkFields();


    Object fkValue = null;
    for (int i = 0; i < refFkNames.length; i++) {
        FieldDescriptor fkField = refFkNames[i];

        if (fkField.getAttributeName().equals(fkName)) {
            fkValue = ObjectUtils.getPropertyValue(referenceObject, refPkNames[i].getAttributeName());
            break;
        }
    }

    return fkValue;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * @see org.kuali.rice.krad.service.PersistenceService#getForeignKeyFieldName(java.lang.Object,
 *      java.lang.String, java.lang.String)
 */

@Override
public String getForeignKeyFieldName(Class persistableObjectClass, String attributeName, String pkName) {
	String fkName = "";
	ClassDescriptor classDescriptor = getClassDescriptor(persistableObjectClass);
	ObjectReferenceDescriptor objectReferenceDescriptor = classDescriptor.getObjectReferenceDescriptorByName(attributeName);
	if (objectReferenceDescriptor == null) {
		throw new RuntimeException("Attribute name " + attributeName + " is not a valid reference to class " + persistableObjectClass.getName());
	}
	ClassDescriptor referenceDescriptor = this.getClassDescriptor(objectReferenceDescriptor.getItemClass());

	FieldDescriptor[] fkFields = objectReferenceDescriptor.getForeignKeyFieldDescriptors(classDescriptor);
	FieldDescriptor[] pkFields = referenceDescriptor.getPkFields();
	for (int i = 0; i < pkFields.length; i++) {
		FieldDescriptor pkField = pkFields[i];
		if (pkField.getAttributeName().equals(pkName)) {
			fkName = fkFields[i].getAttributeName();
		}
	}
	return fkName;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * @see org.kuali.rice.krad.service.PersistenceService#getNestedForeignKeyMap(java.lang.Class)
 */

@Override
public Map getNestedForeignKeyMap(Class persistableObjectClass) {
	Map fkMap = new HashMap();
	ClassDescriptor classDescriptor = getClassDescriptor(persistableObjectClass);
	Vector objectReferences = classDescriptor.getObjectReferenceDescriptors();
	for (Iterator iter = objectReferences.iterator(); iter.hasNext();) {
		ObjectReferenceDescriptor objectReferenceDescriptor = (ObjectReferenceDescriptor) iter.next();
		ClassDescriptor referenceDescriptor = this.getClassDescriptor(objectReferenceDescriptor.getItemClass());

		FieldDescriptor[] fkFields = objectReferenceDescriptor.getForeignKeyFieldDescriptors(classDescriptor);
		FieldDescriptor[] pkFields = referenceDescriptor.getPkFields();
		for (int i = 0; i < pkFields.length; i++) {
			FieldDescriptor pkField = pkFields[i];
			fkMap.put(objectReferenceDescriptor.getAttributeName() + "." + pkField.getAttributeName(), fkFields[i].getAttributeName());
		}
	}

	return fkMap;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
public void readPkValuesFrom(ResultSetAndStatement rs_stmt, Map row)
{
    String ojbClass = SqlHelper.getOjbClassName(rs_stmt.m_rs);
    ClassDescriptor cld;
    
    if (ojbClass != null)
    {
        cld = m_cld.getRepository().getDescriptorFor(ojbClass);
    }
    else
    {
        cld = m_cld;
    }

    FieldDescriptor[] pkFields = cld.getPkFields();
    readValuesFrom(rs_stmt, row, pkFields);
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * binds the Identities Primary key values to the statement
 */
public void bindDelete(PreparedStatement stmt, Identity oid, ClassDescriptor cld) throws SQLException
{
    Object[] pkValues = oid.getPrimaryKeyValues();
    FieldDescriptor[] pkFields = cld.getPkFields();
    int i = 0;
    try
    {
        for (; i < pkValues.length; i++)
        {
            setObjectForStatement(stmt, i + 1, pkValues[i], pkFields[i].getJdbcType().getType());
        }
    }
    catch (SQLException e)
    {
        m_log.error("bindDelete failed for: " + oid.toString() + ", while set value '" +
                pkValues[i] + "' for column " + pkFields[i].getColumnName());
        throw e;
    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * build the Join-Information if a super reference exists
 *
 * @param left
 * @param cld
 * @param name
 */
protected void buildSuperJoinTree(TableAlias left, ClassDescriptor cld, String name, boolean useOuterJoin)
{
    ClassDescriptor superCld = cld.getSuperClassDescriptor();
    if (superCld != null)
    {
        SuperReferenceDescriptor superRef = cld.getSuperReference();
        FieldDescriptor[] leftFields = superRef.getForeignKeyFieldDescriptors(cld);
        TableAlias base_alias = getTableAliasForPath(name, null, null);
        String aliasName = String.valueOf(getAliasChar()) + m_aliasCount++;
        TableAlias right = new TableAlias(superCld, aliasName, useOuterJoin, null);

        Join join1to1 = new Join(left, leftFields, right, superCld.getPkFields(), useOuterJoin, "superClass");
        base_alias.addJoin(join1to1);

        buildSuperJoinTree(right, superCld, name, useOuterJoin);
    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/** Return SELECT clause for object existence call */
public String getStatement()
{
    if(sql == null)
    {
        StringBuffer stmt = new StringBuffer(128);
        ClassDescriptor cld = getClassDescriptor();

        FieldDescriptor[] fieldDescriptors = cld.getPkFields();
        if(fieldDescriptors == null || fieldDescriptors.length == 0)
        {
            throw new OJBRuntimeException("No PK fields defined in metadata for " + cld.getClassNameOfObject());
        }
        FieldDescriptor field = fieldDescriptors[0];

        stmt.append(SELECT);
        stmt.append(field.getColumnName());
        stmt.append(FROM);
        stmt.append(cld.getFullTableName());
        appendWhereClause(cld, false, stmt);

        sql = stmt.toString();
    }
    return sql;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private void buildManyToManyReferences(ClassDescriptor cd, CollectionDescriptor collectionDescriptor,
                                        Object keys[], Vector columns)
 {
     if(cd.isAbstract() || cd.isInterface())
     {
logger.debug( "Skip foreign key build for MtoM, found abstract base class or interface " + cd.getClassNameOfObject() );
         return;
     }
     StringBuffer buffer = new StringBuffer(256);
     buildForeignKeyHeader(cd.getFullTableName(), buffer);

     for (int i = 0; i < keys.length; i++) {
         String columnName = (String) keys[i];

         FieldDescriptor foreignColumn = cd.getPkFields()[i];
         String foreignColumnName = foreignColumn.getPersistentField().getName();
         buildReferenceForColumn(buffer, columnName, foreignColumnName);
         FieldDescriptor fieldDescriptor = (FieldDescriptor)foreignColumn.clone();
         fieldDescriptor.setColumnName(columnName);
         columns.add(fieldDescriptor);
     }
     buffer.append("        </foreign-key>\n");

     addReferenceToTable(collectionDescriptor.getIndirectionTable(), buffer.toString());
 }
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Detect if the given object has a PK field represents a 'null' value.
 */
public boolean hasNullPKField(ClassDescriptor cld, Object obj)
{
    FieldDescriptor[] fields = cld.getPkFields();
    boolean hasNull = false;
    // an unmaterialized proxy object can never have nullified PK's
    IndirectionHandler handler = ProxyHelper.getIndirectionHandler(obj);
    if(handler == null || handler.alreadyMaterialized())
    {
        if(handler != null) obj = handler.getRealSubject();
        FieldDescriptor fld;
        for(int i = 0; i < fields.length; i++)
        {
            fld = fields[i];
            hasNull = representsNull(fld, fld.getPersistentField().get(obj));
            if(hasNull) break;
        }
    }
    return hasNull;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * returns true if the primary key fields are valid for delete, else false.
 * PK fields are valid if each of them contains a valid non-null value
 * @param cld the ClassDescriptor
 * @param obj the object
 * @return boolean
 */
public boolean assertValidPkForDelete(ClassDescriptor cld, Object obj)
{
    if(!ProxyHelper.isProxy(obj))
    {
        FieldDescriptor fieldDescriptors[] = cld.getPkFields();
        int fieldDescriptorSize = fieldDescriptors.length;
        for(int i = 0; i < fieldDescriptorSize; i++)
        {
            FieldDescriptor fd = fieldDescriptors[i];
            Object pkValue = fd.getPersistentField().get(obj);
            if (representsNull(fd, pkValue))
            {
                return false;
            }
        }
    }
    return true;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
public void ojbAdd(Object anObject)
{
	if (anObject != null)
	{
		ClassDescriptor cd = MetadataManager.getInstance().getRepository().getDescriptorFor(anObject.getClass());
           FieldDescriptor[] fields = cd.getPkFields();
           if(fields.length > 1 || fields.length == 0)
           {
               throw new MetadataException("ManageableHashMap can only be used for persistence capable objects with" +
                       " exactly one primiary key field defined in metadata, for " + anObject.getClass() + " the" +
                       " PK field count is " + fields.length);
           }
           else
           {
               Object key = fields[0].getPersistentField().get(anObject);
		    put(key,anObject);
           }
	}
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 *
 * This method returns a list of primary key field names.  This method uses the CacheNoCopy caching method.
 * "NoCopy" is the faster of the caching annotations, but because it does not make a copy the list that is
 * returned must not be modified.  To enforce this the returned list is wrapped in a Collections.unmodifiableList
 * method.  This will cause an exception to be thrown if the list is altered.
 *
 * @param clazz
 * @return unmodifiableList of field names.  Any attempt to alter list will result in an UnsupportedOperationException
 */
public List listPrimaryKeyFieldNames(Class clazz) {
       // Legacy OJB
       List fieldNamesLegacy = new ArrayList();
       ClassDescriptor classDescriptor = getClassDescriptor(clazz);
       FieldDescriptor keyDescriptors[] = classDescriptor.getPkFields();

       for (int i = 0; i < keyDescriptors.length; ++i) {
           FieldDescriptor keyDescriptor = keyDescriptors[i];
           fieldNamesLegacy.add(keyDescriptor.getAttributeName());
       }
       return fieldNamesLegacy;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * @see org.kuali.rice.krad.service.PersistenceService#getPrimaryKeys(java.lang.Class)
 */

@Override
public List getPrimaryKeys(Class clazz) {
	List pkList = new ArrayList();
	ClassDescriptor classDescriptor = getClassDescriptor(clazz);
	FieldDescriptor keyDescriptors[] = classDescriptor.getPkFields();
	for (int i = 0; i < keyDescriptors.length; ++i) {
		FieldDescriptor keyDescriptor = keyDescriptors[i];
		pkList.add(keyDescriptor.getAttributeName());
	}
	return pkList;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private List<Expression> processReferenceField(String enclosingClass, String fieldName, String mappedClass, ObjectReferenceDescriptor ord) {
    final List<Expression> joinColumns = new ArrayList<Expression>();
    final Collection<String> fks = ord.getForeignKeyFields();
    if (fks == null || fks.isEmpty()) {
        LOG.error(ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has a reference descriptor for " + fieldName
                + " but does not have any foreign keys configured");
        return joinColumns;
    }

    final Collection<String> pks = OjbUtil.getPrimaryKeyNames(mappedClass, descriptorRepositories);

    //make sure it isn't a one to one
    if (!(pks.containsAll(fks) && fks.containsAll(pks)) && !pks.isEmpty()) {

        final ClassDescriptor cd = OjbUtil.findClassDescriptor(mappedClass, descriptorRepositories);
        final ClassDescriptor icd = getItemClassDescriptor(enclosingClass, fieldName, mappedClass, ord);
        final FieldDescriptor[] fkDescs = ord.getForeignKeyFieldDescriptors(cd);
        final FieldDescriptor[] pkDescs = icd.getPkFields();

        if (fkDescs.length != pkDescs.length) {
            LOG.error(ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has a collection descriptor for " + fieldName
                    + " with an foreign key that is not joined to all of the primary key fields. This is not supported in JPA.");
        }

        for (int i = 0; i < fkDescs.length; i ++) {
            joinColumns.add(createJoinColumn(fkDescs[i], pkDescs[i]));
        }
    }
    return joinColumns;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private List<Expression> processCollectionField(String enclosingClass, String fieldName, String mappedClass, CollectionDescriptor cld) {
    final List<Expression> joinColumns = new ArrayList<Expression>();

    if (!cld.isMtoNRelation()) {
        final Collection<String> fks = cld.getForeignKeyFields();
        if (fks == null || fks.isEmpty()) {
            LOG.error(ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has a collection descriptor for " + fieldName
                    + " but does not have any inverse foreign keys configured");
            return joinColumns;
        }

        final ClassDescriptor cd = OjbUtil.findClassDescriptor(mappedClass, descriptorRepositories);
        final ClassDescriptor icd = getItemClassDescriptor(enclosingClass, fieldName, mappedClass, cld);
        final FieldDescriptor[] fkDescs =  cld.getForeignKeyFieldDescriptors(icd);
        final FieldDescriptor[] pkDescs = cd.getPkFields();

        if (fkDescs.length != pkDescs.length) {
            LOG.error(ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has a collection descriptor for " + fieldName
            + " with an inverse foreign key that is not joined to all of the primary key fields.  This is not supported in JPA.");
        }

        for (int i = 0; i < fkDescs.length; i ++) {
            joinColumns.add(createJoinColumn(pkDescs[i], fkDescs[i]));
        }
    }
    return joinColumns;
}