import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
static Table createTableModel(DatabaseChannel channel, DbEntity dbEntity) {

        Column[] columns = new Column[dbEntity.getAttributes().size()];
        int i = 0;
        for (DbAttribute a : dbEntity.getAttributes()) {
            columns[i++] = new Column(Objects.requireNonNull(a.getName()), a.getType());
        }

        // ensure predictable column order .. DbEntity's attributes are presumably already sorted, but just in case
        Arrays.sort(columns, (c1, c2) -> c1.getName().compareTo(c2.getName()));

        return Table.builder(channel, dbEntity.getFullyQualifiedName())
                .columns(columns)
                .quoteSqlIdentifiers(dbEntity.getDataMap().isQuotingSQLIdentifiers())
                .build();
    }
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
static Table[] tablesInInsertOrder(BQRuntime runtime, Collection<DbEntity> dbEntities) {

        // note: do not obtain sorter from Cayenne DI. It is not a singleton and will come
        // uninitialized
        ServerRuntime serverRuntime = runtime.getInstance(ServerRuntime.class);
        EntitySorter sorter = serverRuntime.getDataDomain().getEntitySorter();

        List<DbEntity> list = new ArrayList<>(dbEntities);
        sorter.sortDbEntities(list, false);

        DatabaseChannel channel = DatabaseChannel.get(runtime);

        Table[] tables = new Table[list.size()];
        for (int i = 0; i < tables.length; i++) {
            tables[i] = createTableModel(channel, list.get(i));
        }
        return tables;
    }
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
static Stream<DbEntity> getRelatedDbEntities(EntityResolver resolver, Class<?> entityType, Property<?> relationship) {
    ObjEntity entity = resolver.getObjEntity(entityType);

    if (entity == null) {
        throw new IllegalArgumentException("Not a Cayenne entity class: " + entityType.getName());
    }

    ObjRelationship objRelationship = entity.getRelationship(relationship.getName());

    if (objRelationship == null) {
        throw new IllegalArgumentException("No relationship '" + relationship.getName() + "' in entity " + entityType.getName());
    }

    List<DbRelationship> path = objRelationship.getDbRelationships();
    if (path.size() < 2) {
        return Stream.empty();
    }

    return path.subList(1, path.size()).stream().map(DbRelationship::getSourceEntity);
}
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
private boolean checkCreateFull(DataNode dataNode) throws SQLException {
    Map<String, Boolean> nameTables = getNameTablesInDB(dataNode);
    Collection<DbEntity> entities = dataNode.getEntityResolver().getDbEntities();
    for (DbEntity entity : entities) {
        if (nameTables.get(entity.getName()) != null) {
            return false;
        }
    }

    generateFull(dataNode);
    return true;
}
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
public DatabaseEntityAdapter(final DbEntity databaseEntity)
{
    // Must be assigned before property binding.
    this.databaseEntity = databaseEntity;

    try
    {
        nameProperty = bindString(DATAASE_ENTITY_NAME);
    }
    catch (final NoSuchMethodException e)
    {
        throw new RuntimeException("Fix the builder.", e);
    }
}
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
@Deprecated // Unused?
    public void display(final DbEntity dbEntity)
    {
        LOGGER.debug("trying to display: " + dbEntity);
//        attributesTableView.setItems(FXCollections.observableArrayList(objEntity.getAttributes()));
//        objectEntityClassTabViewController.display(objEntity);
//        objEntity.getAttributes()
    }
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
/**
 * Return the database primary key column name for the given data object.
 *
 * @param dataObjectClass the class of the data object
 * @return the primary key column name
 */
protected String getPkName(Class dataObjectClass) {
    Validate.notNull(dataObjectClass, "Null dataObjectClass parameter.");

    ObjEntity objEntity =
            getDataContext().getEntityResolver().lookupObjEntity(dataObjectClass);

    if (objEntity == null) {
        throw new CayenneRuntimeException("Unmapped DataObject Class: "
                + dataObjectClass.getName());
    }

    DbEntity dbEntity = objEntity.getDbEntity();
    if (dbEntity == null) {
        throw new CayenneRuntimeException("No DbEntity for ObjEntity: "
                + objEntity.getName());
    }

    List pkAttributes = dbEntity.getPrimaryKey();
    if (pkAttributes.size() != 1) {
        throw new CayenneRuntimeException("PK contains "
                + pkAttributes.size()
                + " columns, expected 1.");
    }

    DbAttribute attr = (DbAttribute) pkAttributes.get(0);

    return attr.getName();
}
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
public CayenneTestDataManager build() {

        Set<DbEntity> mergedEntities = mergeEntities();

        return new CayenneTestDataManager(
                runtime.getInstance(ServerRuntime.class).getDataDomain(),
                runtime.getInstance(CayenneTableManager.class),
                deleteData,
                refreshCayenneCaches,
                CayenneModelUtils.tablesInInsertOrder(runtime, mergedEntities));
    }
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
private Set<DbEntity> mergeEntities() {
    if(dbEntityGraphRoots.isEmpty()) {
        return dbEntities;
    }

    Set<DbEntity> merged  = ModelDependencyResolver.resolve(dbEntityGraphRoots);
    merged.addAll(dbEntities);
    return merged;
}
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
static DbEntity getDbEntity(EntityResolver resolver, Class<?> entityType) {
    ObjEntity entity = resolver.getObjEntity(entityType);

    if (entity == null) {
        throw new IllegalArgumentException("Not a Cayenne entity class: " + entityType.getName());
    }

    if (entity.getDbEntityName() == null) {
        throw new IllegalArgumentException("Cayenne entity class is not mapped to a DbEntity: " + entityType.getName());
    }

    return entity.getDbEntity();
}
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
public Table getTable(String name) {

        return tables.computeIfAbsent(name, n -> {
            DbEntity entity = resolver.getDbEntity(n);
            if (entity == null) {
                throw new IllegalArgumentException("Unknown DbEntity: " + n);
            }

            return CayenneModelUtils.createTableModel(channel, entity);
        });
    }
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
/**
 * @return true if all PK columns are represented in {@code keys}
 */
private boolean isPrimaryKey(DbEntity entity, Collection<String> keys) {
    Collection<DbAttribute> pks = entity.getPrimaryKeys();
    for (DbAttribute pk : pks) {
        if (!keys.contains(pk.getName())) {
            return false;
        }
    }
    return true;
}
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
public DatabaseEntityTreeViewModel(final DbEntity dbEntity)
{
    this.dbEntity = dbEntity;
}
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
public DbEntity getValue()
{
    return dbEntity;
}
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
static Set<DbEntity> resolve(Collection<DbEntity> entities) {
    Set<DbEntity> resolved = new HashSet<>();
    entities.forEach(e -> resolve(resolved, e));
    return resolved;
}
 

import org.apache.cayenne.map.DbEntity; //导入依赖的package包/类
static private void resolveDependent(Set<DbEntity> resolved, DbRelationship relationship) {
    if (relationship.isFromPK() && !relationship.isToMasterPK()) {
        resolve(resolved, relationship.getTargetEntity());
    }
}