Examples with Element ch.interlis.ili2c.metamodel.Element used on opensource projects

Example 11 with Element

use of ch.interlis.ili2c.metamodel.Element in project ili2db by claeis.

the class Ili2db method runUpdate.

public static void runUpdate(Config config, String appHome, int function) throws Ili2dbException {
    ch.ehi.basics.logging.FileListener logfile = null;
    if (config.getLogfile() != null) {
        logfile = new FileLogger(new java.io.File(config.getLogfile()));
        EhiLogger.getInstance().addListener(logfile);
    }
    StdLogger logStderr = new StdLogger(config.getLogfile());
    EhiLogger.getInstance().addListener(logStderr);
    EhiLogger.getInstance().removeListener(StdListener.getInstance());
    try {
        boolean connectionFromExtern = config.getJdbcConnection() != null;
        logGeneralInfo(config);
        // String zipfilename=null;
        java.util.zip.ZipEntry zipXtfEntry = null;
        java.util.zip.ZipFile zipFile = null;
        String inputFilename = config.getXtffile();
        if (function == Config.FC_DELETE) {
            if (config.getDatasetName() == null) {
                throw new Ili2dbException("no datasetName given");
            }
        } else {
            if (inputFilename == null) {
                throw new Ili2dbException("no xtf-file given");
            }
            if (ch.ehi.basics.view.GenericFileFilter.getFileExtension(inputFilename).toLowerCase().equals("zip")) {
                try {
                    zipFile = new java.util.zip.ZipFile(inputFilename);
                } catch (IOException ex) {
                    throw new Ili2dbException(ex);
                }
                java.util.Enumeration filei = zipFile.entries();
                while (filei.hasMoreElements()) {
                    java.util.zip.ZipEntry zipEntry = (java.util.zip.ZipEntry) filei.nextElement();
                    String ext = ch.ehi.basics.view.GenericFileFilter.getFileExtension(zipEntry.getName()).toLowerCase();
                    if (ext != null && (ext.equals("xml") || ext.equals("xtf") || ext.equals("itf"))) {
                        zipXtfEntry = zipEntry;
                        break;
                    }
                }
                if (zipXtfEntry == null) {
                    throw new Ili2dbException("no xtf/itf-file in zip-archive " + zipFile.getName());
                }
            }
        }
        String modeldir = config.getModeldir();
        if (modeldir == null) {
            throw new Ili2dbException("no modeldir given");
        }
        EhiLogger.traceState("modeldir <" + modeldir + ">");
        ch.interlis.ili2c.config.Configuration modelv = new ch.interlis.ili2c.config.Configuration();
        if (function != Config.FC_DELETE) {
            String models = config.getModels();
            if (models == null) {
                throw new Ili2dbException("no models given");
            }
            EhiLogger.traceState("models <" + models + ">");
            String[] modelnames = getModelNames(models);
            for (int modeli = 0; modeli < modelnames.length; modeli++) {
                String m = modelnames[modeli];
                if (m.equals(XTF)) {
                    // read modelname from xtf-file
                    if (zipXtfEntry != null) {
                        try {
                            java.io.InputStream in = zipFile.getInputStream(zipXtfEntry);
                            m = getModelFromXtf(in, zipXtfEntry.getName());
                        } catch (java.io.IOException ex) {
                            throw new Ili2dbException(ex);
                        }
                    } else {
                        m = getModelFromXtf(inputFilename);
                    }
                }
                if (m != null) {
                    modelv.addFileEntry(new ch.interlis.ili2c.config.FileEntry(m, ch.interlis.ili2c.config.FileEntryKind.ILIMODELFILE));
                }
            }
        }
        String dburl = config.getDburl();
        String dbusr = config.getDbusr();
        String dbpwd = config.getDbpwd();
        if (!connectionFromExtern && dburl == null) {
            throw new Ili2dbException("no dburl given");
        }
        if (dbusr == null) {
            // EhiLogger.logError("no dbusr given");
            // return;
            dbusr = "";
        }
        if (dbpwd == null) {
            // EhiLogger.logError("no dbpwd given");
            // return;
            dbpwd = "";
        }
        String dbschema = config.getDbschema();
        if (dbschema != null) {
            EhiLogger.logState("dbschema <" + dbschema + ">");
        }
        String geometryConverter = config.getGeometryConverter();
        if (geometryConverter == null) {
            throw new Ili2dbException("no geoemtry converter given");
        }
        String ddlGenerator = config.getDdlGenerator();
        if (ddlGenerator == null) {
            throw new Ili2dbException("no DDL generator given");
        }
        String idGenerator = config.getIdGenerator();
        if (idGenerator == null) {
            throw new Ili2dbException("no ID generator given");
        }
        if (!connectionFromExtern) {
            String jdbcDriver = config.getJdbcDriver();
            if (jdbcDriver == null) {
                throw new Ili2dbException("no JDBC driver given");
            }
            try {
                Class.forName(jdbcDriver);
            } catch (Exception ex) {
                throw new Ili2dbException("failed to load JDBC driver", ex);
            }
        }
        CustomMapping customMapping = getCustomMappingStrategy(config);
        // open db connection
        Connection conn = null;
        String url = dburl;
        ch.ehi.basics.logging.ErrorTracker errs = null;
        try {
            try {
                if (connectionFromExtern) {
                    conn = config.getJdbcConnection();
                } else {
                    conn = connect(url, dbusr, dbpwd, config, customMapping);
                }
                customMapping.postConnect(conn, config);
            } catch (SQLException ex) {
                throw new Ili2dbException("failed to get db connection", ex);
            }
            logDBVersion(conn);
            if (!connectionFromExtern) {
                // switch off auto-commit
                try {
                    conn.setAutoCommit(false);
                } catch (SQLException ex) {
                    throw new Ili2dbException("failed to switch off auto-commit", ex);
                }
            }
            // run pre-script
            if (config.getPreScript() != null) {
                try {
                    DbUtility.executeSqlScript(conn, new java.io.FileReader(config.getPreScript()));
                    EhiLogger.logState("run update pre-script...");
                } catch (FileNotFoundException e) {
                    throw new Ili2dbException("update pre-script statements failed", e);
                }
            }
            // create db schema
            if (function == Config.FC_IMPORT) {
                if (config.getDbschema() != null) {
                    if (!DbUtility.schemaExists(conn, config.getDbschema())) {
                        DbUtility.createSchema(conn, config.getDbschema());
                    }
                }
            }
            if (function == Config.FC_DELETE) {
                boolean createBasketCol = config.BASKET_HANDLING_READWRITE.equals(config.getBasketHandling());
                if (!createBasketCol) {
                    throw new Ili2dbException("delete requires column " + DbNames.T_BASKET_COL);
                }
                String datasetName = config.getDatasetName();
                // map datasetName to modelnames
                Long datasetId = getDatasetId(datasetName, conn, config);
                if (datasetId == null) {
                    throw new Ili2dbException("dataset <" + datasetName + "> doesn't exist");
                }
                getBasketSqlIdsFromDatasetId(datasetId, modelv, conn, config);
            }
            if (function == Config.FC_IMPORT) {
                String datasetName = config.getDatasetName();
                if (datasetName != null) {
                    if (DbUtility.tableExists(conn, new DbTableName(config.getDbschema(), DbNames.DATASETS_TAB))) {
                        Long datasetId = getDatasetId(datasetName, conn, config);
                        if (datasetId != null) {
                            throw new Ili2dbException("dataset <" + datasetName + "> already exists");
                        }
                    }
                    boolean createBasketCol = config.BASKET_HANDLING_READWRITE.equals(config.getBasketHandling());
                    if (!createBasketCol) {
                        throw new Ili2dbException("import with dataset name requires column " + DbNames.T_BASKET_COL);
                    }
                }
            }
            if (modelv.getSizeFileEntry() == 0) {
                throw new Ili2dbException("no models given");
            }
            // compile required ili files
            setupIli2cPathmap(config, appHome, inputFilename, conn);
            Ili2cMetaAttrs ili2cMetaAttrs = new Ili2cMetaAttrs();
            ch.interlis.ili2c.config.Configuration ili2cConfig = null;
            try {
                ili2cConfig = (ch.interlis.ili2c.config.Configuration) modelv.clone();
            } catch (CloneNotSupportedException e1) {
                throw new Ili2dbException(e1);
            }
            setupIli2cMetaAttrs(ili2cMetaAttrs, config, ili2cConfig);
            EhiLogger.logState("compile models...");
            ili2cConfig.setAutoCompleteModelList(true);
            ili2cConfig.setGenerateWarnings(false);
            TransferDescription td = ch.interlis.ili2c.Main.runCompiler(ili2cConfig, config, ili2cMetaAttrs);
            if (td == null) {
                throw new Ili2dbException("compiler failed");
            }
            // read mapping file
            NameMapping mapping = new NameMapping(config);
            if (DbUtility.tableExists(conn, new DbTableName(config.getDbschema(), DbNames.CLASSNAME_TAB))) {
                // read mapping from db
                mapping.readTableMappingTable(conn, config.getDbschema());
            }
            if (DbUtility.tableExists(conn, new DbTableName(config.getDbschema(), DbNames.ATTRNAME_TAB))) {
                // read mapping from db
                mapping.readAttrMappingTable(conn, config.getDbschema());
            }
            TrafoConfig trafoConfig = new TrafoConfig();
            trafoConfig.readTrafoConfig(conn, config.getDbschema());
            ModelElementSelector ms = new ModelElementSelector();
            ArrayList<String> modelNames = new ArrayList<String>();
            for (int modeli = 0; modeli < modelv.getSizeFileEntry(); modeli++) {
                if (modelv.getFileEntry(modeli).getKind() == ch.interlis.ili2c.config.FileEntryKind.ILIMODELFILE) {
                    String m = modelv.getFileEntry(modeli).getFilename();
                    modelNames.add(m);
                }
            }
            // use models explicitly given by user --models, --topics and/or as read from transferfile
            java.util.List<Element> eles = ms.getModelElements(modelNames, td, td.getIli1Format() != null && config.getDoItfLineTables(), Config.CREATE_ENUM_DEFS_MULTI.equals(config.getCreateEnumDefs()), config);
            Viewable2TableMapping class2wrapper = Viewable2TableMapper.getClass2TableMapping(config, trafoConfig, eles, mapping);
            Generator gen = null;
            try {
                gen = (Generator) Class.forName(ddlGenerator).newInstance();
            } catch (Exception ex) {
                throw new Ili2dbException("failed to load/create DDL generator", ex);
            }
            DbIdGen idGen = null;
            try {
                idGen = (DbIdGen) Class.forName(idGenerator).newInstance();
            } catch (Exception ex) {
                throw new Ili2dbException("failed to load/create ID generator", ex);
            }
            idGen.init(config.getDbschema(), config);
            SqlColumnConverter geomConverter = null;
            try {
                geomConverter = (SqlColumnConverter) Class.forName(geometryConverter).newInstance();
            } catch (Exception ex) {
                throw new Ili2dbException("failed to load/create geometry converter", ex);
            }
            geomConverter.setup(conn, config);
            idGen.initDb(conn, dbusr);
            idGen.initDbDefs(gen);
            // create table structure
            if (function == Config.FC_IMPORT) {
                EhiLogger.logState("create table structure...");
                try {
                    TransferFromIli trsfFromIli = new TransferFromIli();
                    // map ili-classes to sql-tables
                    DbSchema schema;
                    try {
                        schema = trsfFromIli.doit(td, eles, mapping, config, idGen, trafoConfig, class2wrapper, customMapping);
                    } catch (Ili2dbException e) {
                        throw new Ili2dbException("mapping of ili-classes to sql-tables failed", e);
                    }
                    if (schema == null) {
                        return;
                    }
                    trsfFromIli.addBasketsTable(schema);
                    trsfFromIli.addImportsTable(schema);
                    TransferFromIli.addInheritanceTable(schema, Integer.parseInt(config.getMaxSqlNameLength()));
                    TransferFromIli.addSettingsTable(schema);
                    TransferFromIli.addTrafoConfigTable(schema);
                    TransferFromIli.addModelsTable(schema, config);
                    trsfFromIli.addEnumTable(schema);
                    TransferFromIli.addTableMappingTable(schema);
                    TransferFromIli.addAttrMappingTable(schema);
                    DbExtMetaInfo.addMetaInfoTables(schema);
                    idGen.addMappingTable(schema);
                    if (config.getCreateMetaInfo()) {
                        MetaAttrUtility.addMetaAttributesTable(schema);
                    }
                    GeneratorDriver drv = new GeneratorDriver(gen);
                    drv.visitSchema(config, schema);
                    // create script requested by user?
                    String createscript = config.getCreatescript();
                    if (createscript != null && (gen instanceof GeneratorJdbc)) {
                        writeScript(createscript, ((GeneratorJdbc) gen).iteratorCreateLines());
                    }
                    // drop script requested by user?
                    String dropscript = config.getDropscript();
                    if (dropscript != null && (gen instanceof GeneratorJdbc)) {
                        writeScript(dropscript, ((GeneratorJdbc) gen).iteratorDropLines());
                    }
                    // update mapping table
                    mapping.updateTableMappingTable(conn, config.getDbschema());
                    mapping.updateAttrMappingTable(conn, config.getDbschema());
                    trafoConfig.updateTrafoConfig(conn, config.getDbschema());
                    // update inheritance table
                    trsfFromIli.updateInheritanceTable(conn, config.getDbschema());
                    // update enumerations table
                    trsfFromIli.updateEnumTable(conn);
                    trsfFromIli.updateMetaInfoTables(conn);
                    TransferFromIli.addModels(conn, td, config.getDbschema());
                    if (!config.isConfigReadFromDb()) {
                        TransferFromIli.updateSettings(conn, config, config.getDbschema());
                    }
                } catch (java.io.IOException ex) {
                    throw new Ili2dbException(ex);
                }
            }
            // process xtf files
            EhiLogger.logState("process data file...");
            Map<Long, BasketStat> stat = new HashMap<Long, BasketStat>();
            errs = new ch.ehi.basics.logging.ErrorTracker();
            EhiLogger.getInstance().addListener(errs);
            if (zipXtfEntry != null) {
                IoxReader ioxReader = null;
                java.io.InputStream in = null;
                try {
                    EhiLogger.logState("data <" + inputFilename + ":" + zipXtfEntry.getName() + ">");
                    in = zipFile.getInputStream(zipXtfEntry);
                    if (isItfFilename(zipXtfEntry.getName())) {
                        if (config.getDoItfLineTables()) {
                            ioxReader = new ItfReader(in);
                            ((ItfReader) ioxReader).setModel(td);
                        } else {
                            ioxReader = new ItfReader2(in, config.isSkipGeometryErrors());
                            ((ItfReader2) ioxReader).setModel(td);
                        }
                    } else {
                        ioxReader = new XtfReader(in);
                    }
                    transferFromXtf(conn, ioxReader, function, mapping, td, dbusr, geomConverter, idGen, config, stat, trafoConfig, class2wrapper);
                } catch (IOException ex) {
                    throw new Ili2dbException(ex);
                } catch (IoxException ex) {
                    throw new Ili2dbException(ex);
                } finally {
                    if (ioxReader != null) {
                        try {
                            ioxReader.close();
                        } catch (IoxException e) {
                            throw new Ili2dbException(e);
                        }
                        ioxReader = null;
                    }
                    if (in != null) {
                        try {
                            in.close();
                        } catch (IOException e) {
                            throw new Ili2dbException(e);
                        }
                        in = null;
                    }
                }
                // save attachments
                String attachmentKey = config.getAttachmentKey();
                String attachmentsBase = config.getAttachmentsPath();
                if (attachmentsBase != null) {
                    java.io.File basePath = new java.io.File(attachmentsBase, attachmentKey);
                    java.util.Enumeration filei = zipFile.entries();
                    while (filei.hasMoreElements()) {
                        java.util.zip.ZipEntry zipEntry = (java.util.zip.ZipEntry) filei.nextElement();
                        if (!zipXtfEntry.getName().equals(zipEntry.getName())) {
                            // save file
                            java.io.File destFile = new java.io.File(basePath, zipEntry.getName());
                            java.io.File parent = destFile.getAbsoluteFile().getParentFile();
                            if (!parent.exists()) {
                                if (!parent.mkdirs()) {
                                    throw new Ili2dbException("failed to create " + parent.getAbsolutePath());
                                }
                            }
                            try {
                                copyStream(destFile, zipFile.getInputStream(zipEntry));
                            } catch (IOException ex) {
                                throw new Ili2dbException("failed to save attachment " + zipEntry.getName(), ex);
                            }
                        }
                    }
                }
            } else {
                IoxReader ioxReader = null;
                try {
                    if (function != config.FC_DELETE) {
                        EhiLogger.logState("data <" + inputFilename + ">");
                        if (isItfFilename(inputFilename)) {
                            config.setValue(ch.interlis.iox_j.validator.Validator.CONFIG_DO_ITF_OIDPERTABLE, ch.interlis.iox_j.validator.Validator.CONFIG_DO_ITF_OIDPERTABLE_DO);
                            if (config.getDoItfLineTables()) {
                                ioxReader = new ItfReader(new java.io.File(inputFilename));
                                ((ItfReader) ioxReader).setModel(td);
                                ((ItfReader) ioxReader).setBidPrefix(config.getDatasetName());
                            } else {
                                ioxReader = new ItfReader2(new java.io.File(inputFilename), config.isSkipGeometryErrors());
                                ((ItfReader2) ioxReader).setModel(td);
                                ((ItfReader2) ioxReader).setBidPrefix(config.getDatasetName());
                            }
                        } else {
                            ioxReader = new XtfReader(new java.io.File(inputFilename));
                        }
                    }
                    transferFromXtf(conn, ioxReader, function, mapping, td, dbusr, geomConverter, idGen, config, stat, trafoConfig, class2wrapper);
                } catch (IoxException e) {
                    throw new Ili2dbException(e);
                } finally {
                    if (ioxReader != null) {
                        try {
                            ioxReader.close();
                        } catch (IoxException e) {
                            throw new Ili2dbException(e);
                        }
                        ioxReader = null;
                    }
                }
            }
            // import meta-attributes from .toml file
            if (config.getIliMetaAttrsFile() != null) {
                if (config.getCreateMetaInfo()) {
                    try {
                        EhiLogger.logState("run import meta-attributes from toml file");
                        MetaAttrUtility.addMetaAttrsFromToml(td, new java.io.FileReader(config.getIliMetaAttrsFile()));
                    } catch (FileNotFoundException e) {
                        throw new Ili2dbException("import meta-attributes failed", e);
                    }
                } else {
                    throw new Ili2dbException("import meta-attributes requires --createMetaInfo option");
                }
            }
            if (config.getCreateMetaInfo()) {
                // update meta-attributes table
                MetaAttrUtility.updateMetaAttributesTable(conn, config.getDbschema(), td);
                // set elements' meta-attributes
                MetaAttrUtility.addMetaAttrsFromDb(td, conn, config.getDbschema());
            }
            // run post-script
            if (config.getPostScript() != null) {
                try {
                    DbUtility.executeSqlScript(conn, new java.io.FileReader(config.getPostScript()));
                    EhiLogger.logState("run update post-script...");
                } catch (FileNotFoundException e) {
                    throw new Ili2dbException("update post-script statements failed", e);
                }
            }
            if (errs.hasSeenErrors()) {
                if (!connectionFromExtern) {
                    try {
                        conn.rollback();
                    } catch (SQLException e) {
                        EhiLogger.logError("rollback failed", e);
                    }
                }
                throw new Ili2dbException("...import failed");
            } else {
                if (!connectionFromExtern) {
                    try {
                        conn.commit();
                    } catch (SQLException e) {
                        EhiLogger.logError("commit failed", e);
                        throw new Ili2dbException("...import failed");
                    }
                }
                logStatistics(td.getIli1Format() != null, stat);
                EhiLogger.logState("...import done");
            }
        } finally {
            if (!connectionFromExtern) {
                if (conn != null) {
                    try {
                        conn.close();
                    } catch (java.sql.SQLException ex) {
                        EhiLogger.logError(ex);
                    } finally {
                        config.setJdbcConnection(null);
                        conn = null;
                    }
                }
            }
            if (errs != null) {
                EhiLogger.getInstance().removeListener(errs);
                errs = null;
            }
        }
    } catch (Ili2dbException ex) {
        if (logfile != null) {
            logfile.logEvent(new StdLogEvent(LogEvent.ERROR, null, ex, null));
        }
        throw ex;
    } catch (java.lang.RuntimeException ex) {
        if (logfile != null) {
            logfile.logEvent(new StdLogEvent(LogEvent.ERROR, null, ex, null));
        }
        throw ex;
    } finally {
        if (logfile != null) {
            EhiLogger.getInstance().removeListener(logfile);
            logfile.close();
            logfile = null;
        }
        if (logStderr != null) {
            EhiLogger.getInstance().addListener(StdListener.getInstance());
            EhiLogger.getInstance().removeListener(logStderr);
        }
    }
}

Example 12 with Element

use of ch.interlis.ili2c.metamodel.Element in project ili2db by claeis.

the class Viewable2TableMapper method doSmartOff.

private void doSmartOff(List<Element> eles) {
    /*
		 * Alle Klassen mit NewClass-Strategie abbilden
		 */
    for (Element ele : eles) {
        if (!(ele instanceof Viewable)) {
        // not a Viewable; skip it
        } else {
            // a Viewable
            Viewable aclass = (Viewable) ele;
            if (trafoConfig.getViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO) == null) {
                // newClass
                trafoConfig.setViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO, TrafoConfigNames.INHERITANCE_TRAFO_NEWCLASS);
            }
            String sqlTablename = nameMapping.mapIliClassDef(aclass);
            EhiLogger.traceState("viewable " + aclass.getScopedName(null) + " " + trafoConfig.getViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO) + ", " + sqlTablename);
        }
    }
}

Example 13 with Element

use of ch.interlis.ili2c.metamodel.Element in project ili2db by claeis.

the class Viewable2TableMapper method doSmart2.

private void doSmart2(List<Element> eles) {
    /*
		 * Alle abstrakten Klassen werden mit einer
		 * SubClass-Strategie abgebildet. 
		 * Alle konkreten Klassen werden mit einer NewAndSubClass-Strategie 
		 * abgebildet.
		 */
    for (Element ele : eles) {
        if (!(ele instanceof Viewable)) {
        // not a Viewable; skip it
        } else {
            // a Viewable
            Viewable aclass = (Viewable) ele;
            if (trafoConfig.getViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO) == null) {
                if (aclass.isAbstract()) {
                    // subClass
                    trafoConfig.setViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO, TrafoConfigNames.INHERITANCE_TRAFO_SUBCLASS);
                } else {
                    // newAndSubClass
                    trafoConfig.setViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO, TrafoConfigNames.INHERITANCE_TRAFO_NEWANDSUBCLASS);
                }
            }
            String sqlTablename = nameMapping.mapIliClassDef(aclass);
            EhiLogger.traceState("viewable " + aclass.getScopedName(null) + " " + trafoConfig.getViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO) + ", " + sqlTablename);
        }
    }
}

Example 14 with Element

use of ch.interlis.ili2c.metamodel.Element in project ili2db by claeis.

the class Viewable2TableMapper method doSmart1.

private void doSmart1(List<Element> eles) {
    /*
		 * Fuer Klassen, die referenziert werden und deren Basisklassen nicht mit
		 * einer NewClass-Strategie abgebildet werden, wird die
		 * NewClass-Strategie verwendet. Abstrakte Klassen werden mit einer
		 * SubClass-Strategie abgebildet. Konkrete Klassen, ohne Basisklasse
		 * oder deren direkte Basisklassen mit einer SubClass-Strategie
		 * abgebildet werden, werden mit einer NewClass-Strategie abgebildet.
		 * Alle anderen Klassen werden mit einer SuperClass-Strategie
		 * abgebildet.
		 */
    for (Element ele : eles) {
        if (!(ele instanceof Viewable)) {
        // not a Viewable; skip it
        } else {
            // a Viewable
            Viewable aclass = (Viewable) ele;
            if (trafoConfig.getViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO) == null) {
                if (isReferenced(aclass) && noBaseIsNewClass(trafoConfig, aclass)) {
                    // newClass
                    trafoConfig.setViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO, TrafoConfigNames.INHERITANCE_TRAFO_NEWCLASS);
                } else if (aclass.isAbstract()) {
                    // subClass
                    trafoConfig.setViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO, TrafoConfigNames.INHERITANCE_TRAFO_SUBCLASS);
                } else {
                    Viewable base = (Viewable) aclass.getExtending();
                    if (base == null || TrafoConfigNames.INHERITANCE_TRAFO_SUBCLASS.equals(trafoConfig.getViewableConfig(base, TrafoConfigNames.INHERITANCE_TRAFO))) {
                        // newClass
                        trafoConfig.setViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO, TrafoConfigNames.INHERITANCE_TRAFO_NEWCLASS);
                    } else {
                        // superClass
                        trafoConfig.setViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO, TrafoConfigNames.INHERITANCE_TRAFO_SUPERCLASS);
                    }
                }
            }
            String sqlTablename = nameMapping.mapIliClassDef(aclass);
            EhiLogger.traceState("viewable " + aclass.getScopedName(null) + " " + trafoConfig.getViewableConfig(aclass, TrafoConfigNames.INHERITANCE_TRAFO) + ", " + sqlTablename);
        }
    }
}