Java ClassDescriptor.getFullTableName方法代码示例

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * try to find the first none null table name for the given class-descriptor.
 * If cld has extent classes, all of these cld's searched for the first none null
 * table name.
 */
private static String firstFoundTableName(PersistenceBroker brokerForClass, ClassDescriptor cld)
{
    String name = null;
    if (!cld.isInterface() && cld.getFullTableName() != null)
    {
        return cld.getFullTableName();
    }
    if (cld.isExtent())
    {
        Collection extentClasses = cld.getExtentClasses();
        for (Iterator iterator = extentClasses.iterator(); iterator.hasNext();)
        {
            name = firstFoundTableName(brokerForClass, brokerForClass.getClassDescriptor((Class) iterator.next()));
            // System.out.println("## " + cld.getClassNameOfObject()+" - name: "+name);
            if (name != null) break;
        }
    }
    return name;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private HashSet getFullTableNames(ClassDescriptor desc, DescriptorRepository repos)
{
    String tableName;
    HashSet tableNamesSet = new HashSet();
    Collection extents = desc.getExtentClasses();

    tableName = desc.getFullTableName();
    if (tableName != null)
    {
        tableNamesSet.add(tableName);
    }
    for (Iterator it = extents.iterator(); it.hasNext();)
    {
        Class extClass = (Class) it.next();
        ClassDescriptor extDesc = repos.getDescriptorFor(extClass);
        tableName = extDesc.getFullTableName();
        if (tableName != null)
        {
            tableNamesSet.add(tableName);
        }
    }
    return tableNamesSet;
}
 

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

@Override
public String getTableName(Class<? extends PersistableBusinessObject> boClass) {
	ClassDescriptor cd = getClassDescriptor(boClass);
	return cd.getFullTableName();
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private String getMappedTable(String clazz) {
    final ClassDescriptor cd = OjbUtil.findClassDescriptor(clazz, descriptorRepositories);
    if (cd != null) {
        return cd.getFullTableName();
    }
    return null;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Retrieves the DB table name that's mapped to instances of CollectorDetail by finding the class descriptor name from the
 * class descriptor respository 
 * @return the table name where collector details are saved to
 * @see org.kuali.ole.gl.dataaccess.CollectorDetailDao#retrieveCollectorDetailTableName()
 */
public String retrieveCollectorDetailTableName() {
    ClassDescriptor classDescriptor = null;
    DescriptorRepository globalRepository = descriptorRepository;
    try {
        classDescriptor = globalRepository.getDescriptorFor(CollectorDetail.class);
    }
    catch (ClassNotPersistenceCapableException e) {
        throw new ClassNotPersistableException("class '" + CollectorDetail.class.getName() + "' is not persistable", e);
    }

    return classDescriptor.getFullTableName();
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private void buildStandardTable(ClassDescriptor cd) {
    String tableName = cd.getFullTableName();
    TableDescriptor tableDescriptor = (TableDescriptor) this.standardTables.get(tableName);
    if (tableDescriptor == null) {
        tableDescriptor = new TableDescriptor();
        tableDescriptor.setName(tableName);
        this.standardTables.put(tableName, tableDescriptor);
    }

    buildStandardTableFieldDescriptors(cd.getFieldDescriptions(), tableDescriptor);
    tableDescriptor.getIndices().addAll(cd.getIndexes());
    tableDescriptor.getReferences().addAll(cd.getObjectReferenceDescriptors());
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
protected void clearTable() throws Exception
{
    Connection conn = getConnection();
    ClassDescriptor cld = broker.getClassDescriptor(PerformanceArticle.class);
    String table = cld.getFullTableName();
    String column = cld.getFieldDescriptorByName("articleId").getColumnName();
    String sql = "DELETE FROM " + table + " WHERE " + column + " >= " + offsetId;
    PreparedStatement stmt = conn.prepareStatement(sql);
    stmt.execute();
    returnConnection(conn);
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Retrieves the DB table name that's mapped to instances of CollectorDetail by finding the class descriptor name from the
 * class descriptor respository 
 * @return the table name where collector details are saved to
 * @see org.kuali.kfs.gl.dataaccess.CollectorDetailDao#retrieveCollectorDetailTableName()
 */
public String retrieveCollectorDetailTableName() {
    ClassDescriptor classDescriptor = null;
    DescriptorRepository globalRepository = descriptorRepository;
    try {
        classDescriptor = globalRepository.getDescriptorFor(CollectorDetail.class);
    }
    catch (ClassNotPersistenceCapableException e) {
        throw new ClassNotPersistableException("class '" + CollectorDetail.class.getName() + "' is not persistable", e);
    }

    return classDescriptor.getFullTableName();
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
public Object processMetaData(DatabaseMetaData databaseMetaData) throws SQLException, MetaDataAccessException {
    Class workingBusinessObjectClass = businessObjectClass;
    String workingPropertyName = propertyName;
    while (workingPropertyName.contains(".")) {
        try {
            workingBusinessObjectClass = org.apache.ojb.broker.metadata.MetadataManager.getInstance().getGlobalRepository().getDescriptorFor(workingBusinessObjectClass).getObjectReferenceDescriptorByName(workingPropertyName.substring(0, workingPropertyName.indexOf("."))).getItemClass();
        }
        catch (Exception e1) {
            LOG.debug(new StringBuffer("Unable to get property type via reference descriptor for property ").append(workingPropertyName.substring(0, workingPropertyName.indexOf("."))).append(" of BusinessObject class ").append(workingBusinessObjectClass).toString(), e1);
            try {
                workingBusinessObjectClass = org.apache.ojb.broker.metadata.MetadataManager.getInstance().getGlobalRepository().getDescriptorFor(workingBusinessObjectClass).getCollectionDescriptorByName(workingPropertyName.substring(0, workingPropertyName.indexOf("."))).getItemClass();                        
            }
            catch (Exception e2) {
                LOG.debug(new StringBuffer("Unable to get property type via collection descriptor of property ").append(workingPropertyName.substring(0, workingPropertyName.indexOf("."))).append(" of BusinessObject class ").append(workingBusinessObjectClass).toString(), e2);
                BusinessObject businessObject = null;
                try {
                    businessObject = (BusinessObject)workingBusinessObjectClass.newInstance();
                }
                catch (Exception e3) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("Unable to instantiate BusinessObject class " + workingBusinessObjectClass, e3);
                    }
                    return populateAndReturnNonPersistableInstance();
                }
                try {
                    workingBusinessObjectClass = PropertyUtils.getPropertyType(businessObject, workingPropertyName.substring(0, workingPropertyName.indexOf(".")));
                }
                catch (Exception e4) {
                    LOG.debug(new StringBuffer("Unable to get type of property ").append(workingPropertyName.substring(0, workingPropertyName.indexOf("."))).append(" for BusinessObject class ").append(workingBusinessObjectClass).toString(), e4);
                    return populateAndReturnNonPersistableInstance();
                }
            }
        }
        if (workingBusinessObjectClass == null) {
            return populateAndReturnNonPersistableInstance();
        }
        else {
            workingPropertyName = workingPropertyName.substring(workingPropertyName.indexOf(".") + 1);
        }
    }
    if (!PersistableBusinessObject.class.isAssignableFrom(workingBusinessObjectClass)) {
        return populateAndReturnNonPersistableInstance();
    }
    ClassDescriptor classDescriptor = org.apache.ojb.broker.metadata.MetadataManager.getInstance().getGlobalRepository().getDescriptorFor(workingBusinessObjectClass);
    if (classDescriptor == null) {
        return populateAndReturnNonPersistableInstance();
    }
    tableName = classDescriptor.getFullTableName();
    if (classDescriptor.getFieldDescriptorByName(workingPropertyName) == null) {
        return populateAndReturnNonPersistableInstance();
    }
    columnName = classDescriptor.getFieldDescriptorByName(workingPropertyName).getColumnName();
    ResultSet resultSet = databaseMetaData.getColumns(null, null, tableName, columnName);
    if (resultSet.next()) {
        dataType = resultSet.getString("TYPE_NAME");
        length = resultSet.getInt("COLUMN_SIZE");
        decimalPlaces = resultSet.getInt("DECIMAL_DIGITS");
        encrypted = classDescriptor.getFieldDescriptorByName(workingPropertyName).getFieldConversion() instanceof OjbKualiEncryptDecryptFieldConversion;
    }
    resultSet.close();
    return this;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Prepares a representation of the model that is easier accessible for our purposes.
 * 
 * @param model  The original model
 * @return The model representation
 */
private void prepareModel(DescriptorRepository model)
{
    TreeMap result = new TreeMap();

    for (Iterator it = model.getDescriptorTable().values().iterator(); it.hasNext();)
    {
        ClassDescriptor classDesc = (ClassDescriptor)it.next();

        if (classDesc.getFullTableName() == null)
        {
            // not mapped to a database table
            continue;
        }

        String elementName        = getElementName(classDesc);
        Table  mappedTable        = getTableFor(elementName);
        Map    columnsMap         = getColumnsFor(elementName);
        Map    requiredAttributes = getRequiredAttributes(elementName);
        List   classDescs         = getClassDescriptorsMappingTo(elementName);

        if (mappedTable == null)
        {
            mappedTable = _schema.findTable(classDesc.getFullTableName());
            if (mappedTable == null)
            {
                continue;
            }
            columnsMap         = new TreeMap();
            requiredAttributes = new HashMap();
            classDescs         = new ArrayList();
            _elementToTable.put(elementName, mappedTable);
            _elementToClassDescriptors.put(elementName, classDescs);
            _elementToColumnMap.put(elementName, columnsMap);
            _elementToRequiredAttributesMap.put(elementName, requiredAttributes);
        }
        classDescs.add(classDesc);
        extractAttributes(classDesc, mappedTable, columnsMap, requiredAttributes);
    }
    extractIndirectionTables(model, _schema);
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
TableAlias(ClassDescriptor aCld, String anAlias, boolean lookForExtents, List hints)
     {
         this.cld = aCld;
         this.table = aCld.getFullTableName();
         this.alias = anAlias;
         boolean useHintsOnExtents = false;

         // BRJ: store alias map of in enclosing class
setTableAliasForClassDescriptor(aCld, this);

         //LEANDRO: use hints
         if (hints != null && hints.size() > 0)
         {
             useHintsOnExtents = true;
         }

         logger.debug("TableAlias(): using hints ? " + useHintsOnExtents);

         // BRJ : build alias for extents, only one per Table
         if (lookForExtents)
         {
             ClassDescriptor[] extCLDs = (ClassDescriptor[]) aCld.getRepository().getAllConcreteSubclassDescriptors(
                     aCld).toArray(new ClassDescriptor[0]);

             ClassDescriptor extCd;
             Class extClass;
             String extTable;
             Map extMap = new HashMap(); // only one Alias per Table
             int firstNonAbstractExtentIndex = 0;

             for (int i = 0; i < extCLDs.length; i++)
             {
                 extCd = extCLDs[i];
                 extClass = extCd.getClassOfObject();
                 if (useHintsOnExtents && (!hints.contains(extClass)))
                 {
                     //LEANDRO: don't include this class
                     logger.debug("Skipping class [" + extClass + "] from extents List");
                     firstNonAbstractExtentIndex++;
                     continue;
                 }
                 extTable = extCd.getFullTableName();

                 // BRJ : Use the first non abstract extent
                 // if the main cld is abstract
                 //logger.debug("cld abstract["+aCld.isAbstract()+"] i["+i+"] index ["+firtsNonAbstractExtentIndex+"]");
                 if (aCld.isAbstract() && i == firstNonAbstractExtentIndex)
                 {
                     this.cld = extCd;
                     this.table = extTable;
                 }
                 else
                 {
                     // Add a new extent entry only if the table of the extent
                     // does not match the table of the 'base' class.
                     if (extMap.get(extTable) == null && !extTable.equals(table))
                     {
                         extMap.put(extTable, new TableAlias(extCd, anAlias + "E" + i, false, hints));
                     }
                 }
             }
             extents.addAll(extMap.values());
         }

         if (cld == null)
         {
             throw new PersistenceBrokerSQLException("Table is NULL for alias: " + alias);
         }
     }
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * lookup current maximum value for a single field in
 * table the given class descriptor was associated.
 */
public static long getMaxIdForClass(
        PersistenceBroker brokerForClass, ClassDescriptor cldForOriginalOrExtent, FieldDescriptor original)
        throws PersistenceBrokerException
{
    FieldDescriptor field = null;
    if (!original.getClassDescriptor().equals(cldForOriginalOrExtent))
    {
        // check if extent match not the same table
        if (!original.getClassDescriptor().getFullTableName().equals(
                cldForOriginalOrExtent.getFullTableName()))
        {
            // we have to look for id's in extent class table
            field = cldForOriginalOrExtent.getFieldDescriptorByName(original.getAttributeName());
        }
    }
    else
    {
        field = original;
    }
    if (field == null)
    {
        // if null skip this call
        return 0;
    }

    String column = field.getColumnName();
    long result = 0;
    ResultSet rs = null;
    Statement stmt = null;
    StatementManagerIF sm = brokerForClass.serviceStatementManager();
    String table = cldForOriginalOrExtent.getFullTableName();
    // String column = cld.getFieldDescriptorByName(fieldName).getColumnName();
    String sql = SM_SELECT_MAX + column + SM_FROM + table;
    try
    {
        //lookup max id for the current class
        stmt = sm.getGenericStatement(cldForOriginalOrExtent, Query.NOT_SCROLLABLE);
        rs = stmt.executeQuery(sql);
        rs.next();
        result = rs.getLong(1);
    }
    catch (Exception e)
    {
        log.warn("Cannot lookup max value from table " + table + " for column " + column +
                ", PB was " + brokerForClass + ", using jdbc-descriptor " +
                brokerForClass.serviceConnectionManager().getConnectionDescriptor(), e);
    }
    finally
    {
        try
        {
            sm.closeResources(stmt, rs);
        }
        catch (Exception ignore)
        {
            // ignore it
       }
    }
    return result;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Extent aware Delete by Query
 * @param query
 * @param cld
 * @throws PersistenceBrokerException
 */
private void deleteByQuery(Query query, ClassDescriptor cld) throws PersistenceBrokerException
{
    if (logger.isDebugEnabled())
    {
        logger.debug("deleteByQuery " + cld.getClassNameOfObject() + ", " + query);
    }

    if (query instanceof QueryBySQL)
    {
        String sql = ((QueryBySQL) query).getSql();
        this.dbAccess.executeUpdateSQL(sql, cld);
    }
    else
    {
        // if query is Identity based transform it to a criteria based query first
        if (query instanceof QueryByIdentity)
        {
            QueryByIdentity qbi = (QueryByIdentity) query;
            Object oid = qbi.getExampleObject();
            // make sure it's an Identity
            if (!(oid instanceof Identity))
            {
                oid = serviceIdentity().buildIdentity(oid);
            }
            query = referencesBroker.getPKQuery((Identity) oid);
        }

        if (!cld.isInterface())
        {
            this.dbAccess.executeDelete(query, cld);
        }

        // if class is an extent, we have to delete all extent classes too
        String lastUsedTable = cld.getFullTableName();
        if (cld.isExtent())
        {
            Iterator extents = getDescriptorRepository().getAllConcreteSubclassDescriptors(cld).iterator();

            while (extents.hasNext())
            {
                ClassDescriptor extCld = (ClassDescriptor) extents.next();

                // read same table only once
                if (!extCld.getFullTableName().equals(lastUsedTable))
                {
                    lastUsedTable = extCld.getFullTableName();
                    this.dbAccess.executeDelete(query, extCld);
                }
            }
        }

    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**try to crash odmg and broker tx*/
public void YYYtestBrokerCrash()
{
    // get facade instance
    Implementation odmg = OJB.getInstance();
    Database db = odmg.newDatabase();
    PersistenceBroker broker = null;
    ClassDescriptor cld = null;
    String tablename = null;

    //open database
    try
    {
        db.open(databaseName, Database.OPEN_READ_WRITE);
    }
    catch (ODMGException ex)
    {
        fail("ODMGException: " + ex.getMessage());
    }
    try
    {
        Transaction tx = odmg.newTransaction();
        tx.begin();

        // retrieve an Article
        OQLQuery query = odmg.newOQLQuery();
        query.create("select anArticle from " + Article.class.getName() + " where articleId = $678");
        query.bind(new Integer(30));
        List results = (List) query.execute();
        Article a = (Article) results.get(0);

        // manipulate metadata
        broker = ((TransactionImpl) tx).getBroker();
        cld = broker.getClassDescriptor(Article.class);
        tablename = cld.getFullTableName();
        cld.setTableName("ELVIS");
        broker.getDescriptorRepository().setClassDescriptor(cld);

        //broker will crash as metadata is corrupt
        a.addToStock(5);
        tx.commit();
        fail("Can commit tx with corrupt metadata");
    }
    catch (Throwable t)
    {
        //ignore
    }
    finally
    {
        cld.setTableName(tablename);
        broker.getDescriptorRepository().setClassDescriptor(cld);
    }

}