Java FieldDescriptor.isPrimaryKey方法代码示例

import org.apache.ojb.broker.metadata.FieldDescriptor; //导入方法依赖的package包/类
private Collection<FieldDescriptor> getPrimaryKeyDescriptors(String clazz) {
    final Collection<FieldDescriptor> pks = new ArrayList<FieldDescriptor>();

    final ClassDescriptor cd = OjbUtil.findClassDescriptor(clazz, descriptorRepositories);
    if (cd != null) {
        //This causes a stackoverflow and appears to not work correctly
        //return cd.getPkFields().length > 1;
        int i = 0;
        FieldDescriptor[] fds = cd.getFieldDescriptions();
        if (fds != null) {
            for (FieldDescriptor fd : fds) {
                if (fd.isPrimaryKey()) {
                    pks.add(fd);
                }
            }
        }
    }
    return pks;
}
 

import org.apache.ojb.broker.metadata.FieldDescriptor; //导入方法依赖的package包/类
private boolean isPrimaryKeyColumn(String clazz, String fieldName) {
    final FieldDescriptor fd = OjbUtil.findFieldDescriptor(clazz, fieldName, descriptorRepositories);

    if (fd != null) {
        return fd.isPrimaryKey();
    }
    return false;
}
 

import org.apache.ojb.broker.metadata.FieldDescriptor; //导入方法依赖的package包/类
/**
 * Decide if the given object value represents 'null'.<br/>
 *
 * - If given value is 'null' itself, true will be returned<br/>
 *
 * - If given value is instance of Number with value 0 and the field-descriptor
 * represents a primitive field, true will be returned<br/>
 *
 * - If given value is instance of String with length 0 and the field-descriptor
 * is a primary key, true will be returned<br/>
 */
public boolean representsNull(FieldDescriptor fld, Object aValue)
{
    if(aValue == null) return true;

    boolean result = false;
    if(((aValue instanceof Number) && (((Number) aValue).longValue() == 0)))
    {
        Class type = fld.getPersistentField().getType();
        /*
        AnonymousPersistentFields will *always* have a null type according to the
        javadoc comments in AnonymousPersistentField.getType() and never represents
        a primitve java field with value 0, thus we return always 'false' in this case.
        (If the value object is null, the first check above return true)
        */
        if(type != null)
        {
            result = type.isPrimitive();
        }
    }
    // TODO: Do we need this check?? String could be nullified, why should we assume
    // it's 'null' on empty string?
    else if((aValue instanceof String) && (((String) aValue).length() == 0))
    {
        result = fld.isPrimaryKey();
    }
    return result;
}
 

import org.apache.ojb.broker.metadata.FieldDescriptor; //导入方法依赖的package包/类
/**
 * Set the FK value on the target object, extracted from the referenced object. If the referenced object was
 * <i>null</i> the FK values were set to <i>null</i>, expect when the FK field was declared as PK.
 *
 * @param targetObject real (non-proxy) target object
 * @param cld {@link ClassDescriptor} of the real target object
 * @param rds An {@link ObjectReferenceDescriptor} or {@link CollectionDescriptor}
 * @param referencedObject The referenced object or <i>null</i>
 */
private void setFKField(Object targetObject, ClassDescriptor cld, ObjectReferenceDescriptor rds, Object referencedObject)
{
    ValueContainer[] refPkValues;
    FieldDescriptor fld;
    FieldDescriptor[] objFkFields = rds.getForeignKeyFieldDescriptors(cld);
    if (objFkFields == null)
    {
        throw new PersistenceBrokerException("No foreign key fields defined for class '"+cld.getClassNameOfObject()+"'");
    }
    if(referencedObject == null)
    {
        refPkValues = null;
    }
    else
    {
        Class refClass = proxyFactory.getRealClass(referencedObject);
        ClassDescriptor refCld = getClassDescriptor(refClass);
        refPkValues = brokerHelper.getKeyValues(refCld, referencedObject, false);
    }
    for (int i = 0; i < objFkFields.length; i++)
    {
        fld = objFkFields[i];
        /*
        arminw:
        we set the FK value when the extracted PK fields from the referenced object are not null at all
        or if null, the FK field was not a PK field of target object too.
        Should be ok, because the values of the extracted PK field values should never be null and never
        change, so it doesn't matter if the target field is a PK too.
        */
        if(refPkValues != null || !fld.isPrimaryKey())
        {
            fld.getPersistentField().set(targetObject, refPkValues != null ? refPkValues[i].getValue(): null);
        }
    }
}