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

Example 6 with Type

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

the class MultiPointMappings method addMultiPointAttr.

public void addMultiPointAttr(AttributeDef multiPointAttr) {
    String bagOfPointsAttrName = null;
    String pointAttrName = null;
    // validate structure
    // create mapping
    Type multiPointTypeo = multiPointAttr.getDomain();
    if (!(multiPointTypeo instanceof CompositionType)) {
        throw new IllegalArgumentException("not a valid multipoint attribute " + multiPointAttr.getScopedName(null));
    } else {
        CompositionType multiPointType = (CompositionType) multiPointTypeo;
        Table multiPointStruct = multiPointType.getComponentType();
        Iterator<ViewableTransferElement> it = multiPointStruct.getAttributesAndRoles2();
        if (!it.hasNext()) {
            throw new IllegalArgumentException("not a valid multipoint structure " + multiPointStruct.getScopedName(null));
        }
        ViewableTransferElement prop = it.next();
        if (!(prop.obj instanceof AttributeDef)) {
            throw new IllegalArgumentException("not a valid multipoint structure " + multiPointStruct.getScopedName(null));
        }
        AttributeDef pointsAttr = (AttributeDef) prop.obj;
        bagOfPointsAttrName = pointsAttr.getName();
        Type pointsTypeo = pointsAttr.getDomain();
        if (!(pointsTypeo instanceof CompositionType)) {
            throw new IllegalArgumentException("not a valid multipoint structure " + multiPointStruct.getScopedName(null));
        } else {
            CompositionType pointsType = (CompositionType) pointsTypeo;
            Table pointStruct = pointsType.getComponentType();
            Iterator<ViewableTransferElement> it2 = pointStruct.getAttributesAndRoles2();
            if (!it2.hasNext()) {
                throw new IllegalArgumentException("not a valid point structure " + pointStruct.getScopedName(null));
            }
            ViewableTransferElement prop2 = it2.next();
            if (!(prop2.obj instanceof AttributeDef)) {
                throw new IllegalArgumentException("not a valid point structure " + pointStruct.getScopedName(null));
            }
            AttributeDef pointAttr = (AttributeDef) prop2.obj;
            Type pointType = pointAttr.getDomainResolvingAliases();
            if (!(pointType instanceof CoordType)) {
                throw new IllegalArgumentException("not a valid point structure " + pointStruct.getScopedName(null));
            }
            pointAttrName = pointAttr.getName();
        }
    }
    MultiPointMapping mapping = new MultiPointMapping(bagOfPointsAttrName, pointAttrName);
    mappings.put(multiPointAttr, mapping);
}

Example 7 with Type

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

the class FromIliRecordConverter method generateAttr.

public void generateAttr(DbTable dbTable, Viewable aclass, AttributeDef attr) throws Ili2dbException {
    Holder<DbColumn> dbCol = new Holder<DbColumn>();
    dbCol.value = null;
    Holder<Unit> unitDef = new Holder<Unit>();
    unitDef.value = null;
    Holder<Boolean> mText = new Holder<Boolean>();
    mText.value = false;
    ArrayList<DbColumn> dbColExts = new ArrayList<DbColumn>();
    Type type = attr.getDomainResolvingAll();
    if (createSimpleDbCol(dbTable, aclass, attr, type, dbCol, unitDef, mText, dbColExts)) {
    } else if (type instanceof SurfaceOrAreaType) {
        if (createItfLineTables) {
            dbCol.value = null;
        } else {
            DbColGeometry ret = new DbColGeometry();
            boolean curvePolygon = false;
            if (!strokeArcs) {
                curvePolygon = true;
            }
            ret.setType(curvePolygon ? DbColGeometry.CURVEPOLYGON : DbColGeometry.POLYGON);
            // get crs from ili
            setCrs(ret, attr);
            CoordType coord = (CoordType) ((SurfaceOrAreaType) type).getControlPointDomain().getType();
            ret.setDimension(coord.getDimensions().length);
            setBB(ret, coord, attr.getContainer().getScopedName(null) + "." + attr.getName());
            dbCol.value = ret;
        }
        if (createItfAreaRef) {
            if (type instanceof AreaType) {
                DbColGeometry ret = new DbColGeometry();
                String sqlName = getSqlAttrName(attr, dbTable.getName().getName(), null) + DbNames.ITF_MAINTABLE_GEOTABLEREF_COL_SUFFIX;
                ret.setName(sqlName);
                ret.setType(DbColGeometry.POINT);
                setNullable(aclass, attr, ret);
                // get crs from ili
                setCrs(ret, attr);
                // always 2 (even if defined as 3d in ili)
                ret.setDimension(2);
                CoordType coord = (CoordType) ((SurfaceOrAreaType) type).getControlPointDomain().getType();
                setBB(ret, coord, attr.getContainer().getScopedName(null) + "." + attr.getName());
                dbColExts.add(ret);
            }
        }
    } else if (type instanceof PolylineType) {
        String attrName = attr.getContainer().getScopedName(null) + "." + attr.getName();
        DbColGeometry ret = generatePolylineType((PolylineType) type, attrName);
        setCrs(ret, attr);
        dbCol.value = ret;
    } else if (type instanceof CoordType) {
        DbColGeometry ret = new DbColGeometry();
        ret.setType(DbColGeometry.POINT);
        // get crs from ili
        setCrs(ret, attr);
        CoordType coord = (CoordType) type;
        ret.setDimension(coord.getDimensions().length);
        setBB(ret, coord, attr.getContainer().getScopedName(null) + "." + attr.getName());
        dbCol.value = ret;
    } else if (type instanceof CompositionType) {
        // skip it
        if (!createGenericStructRef) {
            if (isChbaseCatalogueRef(td, attr) && (coalesceCatalogueRef || TrafoConfigNames.CATALOGUE_REF_TRAFO_COALESCE.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.CATALOGUE_REF_TRAFO)))) {
                DbColId ret = new DbColId();
                ret.setNotNull(false);
                ret.setPrimaryKey(false);
                if (createFk) {
                    ret.setReferencedTable(getSqlType(((ReferenceType) ((AttributeDef) ((CompositionType) type).getComponentType().getAttributes().next()).getDomain()).getReferred()));
                }
                if (createFkIdx) {
                    ret.setIndex(true);
                }
                trafoConfig.setAttrConfig(attr, TrafoConfigNames.CATALOGUE_REF_TRAFO, TrafoConfigNames.CATALOGUE_REF_TRAFO_COALESCE);
                dbCol.value = ret;
            } else if (Ili2cUtility.isMultiSurfaceAttr(td, attr) && (coalesceMultiSurface || TrafoConfigNames.MULTISURFACE_TRAFO_COALESCE.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.MULTISURFACE_TRAFO)))) {
                multiSurfaceAttrs.addMultiSurfaceAttr(attr);
                MultiSurfaceMapping attrMapping = multiSurfaceAttrs.getMapping(attr);
                DbColGeometry ret = new DbColGeometry();
                boolean curvePolygon = false;
                if (!strokeArcs) {
                    curvePolygon = true;
                }
                ret.setType(curvePolygon ? DbColGeometry.MULTISURFACE : DbColGeometry.MULTIPOLYGON);
                // get crs from ili
                AttributeDef surfaceAttr = (AttributeDef) ((CompositionType) ((AttributeDef) ((CompositionType) type).getComponentType().getElement(AttributeDef.class, attrMapping.getBagOfSurfacesAttrName())).getDomain()).getComponentType().getElement(AttributeDef.class, attrMapping.getSurfaceAttrName());
                setCrs(ret, surfaceAttr);
                SurfaceType surface = ((SurfaceType) surfaceAttr.getDomainResolvingAliases());
                CoordType coord = (CoordType) surface.getControlPointDomain().getType();
                ret.setDimension(coord.getDimensions().length);
                setBB(ret, coord, attr.getContainer().getScopedName(null) + "." + attr.getName());
                dbCol.value = ret;
                trafoConfig.setAttrConfig(attr, TrafoConfigNames.MULTISURFACE_TRAFO, TrafoConfigNames.MULTISURFACE_TRAFO_COALESCE);
            } else if (Ili2cUtility.isMultiLineAttr(td, attr) && (coalesceMultiLine || TrafoConfigNames.MULTILINE_TRAFO_COALESCE.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.MULTILINE_TRAFO)))) {
                multiLineAttrs.addMultiLineAttr(attr);
                MultiLineMapping attrMapping = multiLineAttrs.getMapping(attr);
                DbColGeometry ret = new DbColGeometry();
                boolean curvePolyline = false;
                if (!strokeArcs) {
                    curvePolyline = true;
                }
                ret.setType(curvePolyline ? DbColGeometry.MULTICURVE : DbColGeometry.MULTILINESTRING);
                // get crs from ili
                AttributeDef polylineAttr = (AttributeDef) ((CompositionType) ((AttributeDef) ((CompositionType) type).getComponentType().getElement(AttributeDef.class, attrMapping.getBagOfLinesAttrName())).getDomain()).getComponentType().getElement(AttributeDef.class, attrMapping.getLineAttrName());
                setCrs(ret, polylineAttr);
                PolylineType polylineType = ((PolylineType) polylineAttr.getDomainResolvingAliases());
                CoordType coord = (CoordType) polylineType.getControlPointDomain().getType();
                ret.setDimension(coord.getDimensions().length);
                setBB(ret, coord, attr.getContainer().getScopedName(null) + "." + attr.getName());
                dbCol.value = ret;
                trafoConfig.setAttrConfig(attr, TrafoConfigNames.MULTILINE_TRAFO, TrafoConfigNames.MULTILINE_TRAFO_COALESCE);
            } else if (Ili2cUtility.isMultiPointAttr(td, attr) && (coalesceMultiPoint || TrafoConfigNames.MULTIPOINT_TRAFO_COALESCE.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.MULTIPOINT_TRAFO)))) {
                multiPointAttrs.addMultiPointAttr(attr);
                MultiPointMapping attrMapping = multiPointAttrs.getMapping(attr);
                DbColGeometry ret = new DbColGeometry();
                ret.setType(DbColGeometry.MULTIPOINT);
                // get crs from ili
                AttributeDef coordAttr = (AttributeDef) ((CompositionType) ((AttributeDef) ((CompositionType) type).getComponentType().getElement(AttributeDef.class, attrMapping.getBagOfPointsAttrName())).getDomain()).getComponentType().getElement(AttributeDef.class, attrMapping.getPointAttrName());
                setCrs(ret, coordAttr);
                CoordType coord = (CoordType) (coordAttr.getDomainResolvingAliases());
                ret.setDimension(coord.getDimensions().length);
                setBB(ret, coord, attr.getContainer().getScopedName(null) + "." + attr.getName());
                dbCol.value = ret;
                trafoConfig.setAttrConfig(attr, TrafoConfigNames.MULTIPOINT_TRAFO, TrafoConfigNames.MULTIPOINT_TRAFO_COALESCE);
            } else if (Ili2cUtility.isArrayAttr(td, attr) && (coalesceArray || TrafoConfigNames.ARRAY_TRAFO_COALESCE.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.ARRAY_TRAFO)))) {
                arrayAttrs.addArrayAttr(attr);
                ArrayMapping attrMapping = arrayAttrs.getMapping(attr);
                AttributeDef localAttr = attrMapping.getValueAttr();
                Type localType = localAttr.getDomainResolvingAll();
                if (!createSimpleDbCol(dbTable, aclass, localAttr, localType, dbCol, unitDef, mText, dbColExts)) {
                    throw new IllegalStateException("unexpected attr type " + localAttr.getScopedName());
                }
                dbCol.value.setArraySize(DbColumn.UNLIMITED_ARRAY);
                trafoConfig.setAttrConfig(attr, TrafoConfigNames.ARRAY_TRAFO, TrafoConfigNames.ARRAY_TRAFO_COALESCE);
            } else if (isChbaseMultilingual(td, attr) && (expandMultilingual || TrafoConfigNames.MULTILINGUAL_TRAFO_EXPAND.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.MULTILINGUAL_TRAFO)))) {
                for (String sfx : DbNames.MULTILINGUAL_TXT_COL_SUFFIXS) {
                    DbColVarchar ret = new DbColVarchar();
                    ret.setName(getSqlAttrName(attr, dbTable.getName().getName(), null) + sfx);
                    ret.setSize(DbColVarchar.UNLIMITED);
                    ret.setNotNull(false);
                    ret.setPrimaryKey(false);
                    dbColExts.add(ret);
                }
                trafoConfig.setAttrConfig(attr, TrafoConfigNames.MULTILINGUAL_TRAFO, TrafoConfigNames.MULTILINGUAL_TRAFO_EXPAND);
            } else {
                // add reference col from struct ele to parent obj to struct table
                addParentRef(aclass, attr);
                dbCol.value = null;
            }
        } else {
            dbCol.value = null;
        }
    } else if (type instanceof ReferenceType) {
        ArrayList<ViewableWrapper> targetTables = getTargetTables(((ReferenceType) type).getReferred());
        for (ViewableWrapper targetTable : targetTables) {
            DbColId ret = new DbColId();
            ret.setName(ili2sqlName.mapIliAttributeDef(attr, dbTable.getName().getName(), targetTable.getSqlTablename(), targetTables.size() > 1));
            ret.setNotNull(false);
            ret.setPrimaryKey(false);
            if (createFk) {
                ret.setReferencedTable(targetTable.getSqlTable());
            }
            if (createFkIdx) {
                ret.setIndex(true);
            }
            dbColExts.add(ret);
        }
    } else {
        DbColVarchar ret = new DbColVarchar();
        ret.setSize(255);
        dbCol.value = ret;
    }
    if (type instanceof EnumerationType) {
        if (createEnumTxtCol) {
            DbColVarchar ret = new DbColVarchar();
            ret.setSize(255);
            ret.setName(getSqlAttrName(attr, dbTable.getName().getName(), null) + DbNames.ENUM_TXT_COL_SUFFIX);
            setNullable(aclass, attr, ret);
            dbColExts.add(ret);
        }
    }
    if (dbCol.value != null) {
        String sqlColName = getSqlAttrName(attr, dbTable.getName().getName(), null);
        setAttrDbColProps(aclass, attr, dbCol.value, sqlColName);
        String subType = null;
        Viewable attrClass = (Viewable) attr.getContainer();
        if (attrClass != aclass && attrClass.isExtending(aclass)) {
            subType = getSqlType(attrClass).getName();
        }
        if (unitDef.value != null) {
            String unitName = unitDef.value.getName();
            metaInfo.setColumnInfo(dbTable.getName().getName(), subType, sqlColName, DbExtMetaInfo.TAG_COL_UNIT, unitName);
        }
        if (mText.value) {
            metaInfo.setColumnInfo(dbTable.getName().getName(), subType, sqlColName, DbExtMetaInfo.TAG_COL_TEXTKIND, DbExtMetaInfo.TAG_COL_TEXTKIND_MTEXT);
        }
        if (dbCol.value instanceof DbColGeometry) {
            metaInfo.setColumnInfo(dbTable.getName().getName(), subType, sqlColName, DbExtMetaInfo.TAG_COL_C1_MIN, Double.toString(((DbColGeometry) dbCol.value).getMin1()));
            metaInfo.setColumnInfo(dbTable.getName().getName(), subType, sqlColName, DbExtMetaInfo.TAG_COL_C1_MAX, Double.toString(((DbColGeometry) dbCol.value).getMax1()));
            metaInfo.setColumnInfo(dbTable.getName().getName(), subType, sqlColName, DbExtMetaInfo.TAG_COL_C2_MIN, Double.toString(((DbColGeometry) dbCol.value).getMin2()));
            metaInfo.setColumnInfo(dbTable.getName().getName(), subType, sqlColName, DbExtMetaInfo.TAG_COL_C2_MAX, Double.toString(((DbColGeometry) dbCol.value).getMax2()));
            if (((DbColGeometry) dbCol.value).getDimension() == 3) {
                metaInfo.setColumnInfo(dbTable.getName().getName(), subType, sqlColName, DbExtMetaInfo.TAG_COL_C3_MIN, Double.toString(((DbColGeometry) dbCol.value).getMin3()));
                metaInfo.setColumnInfo(dbTable.getName().getName(), subType, sqlColName, DbExtMetaInfo.TAG_COL_C3_MAX, Double.toString(((DbColGeometry) dbCol.value).getMax3()));
            }
        }
        String dispName = attr.getMetaValues().getValue(IliMetaAttrNames.METAATTR_DISPNAME);
        if (dispName != null) {
            metaInfo.setColumnInfo(dbTable.getName().getName(), subType, sqlColName, DbExtMetaInfo.TAG_COL_DISPNAME, dispName);
        }
        customMapping.fixupAttribute(dbTable, dbCol.value, attr);
        dbTable.addColumn(dbCol.value);
    }
    for (DbColumn dbColExt : dbColExts) {
        customMapping.fixupAttribute(dbTable, dbColExt, attr);
        dbTable.addColumn(dbColExt);
    }
    if (dbCol.value == null && dbColExts.size() == 0) {
        customMapping.fixupAttribute(dbTable, null, attr);
    }
}

Example 8 with Type

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

the class FromXtfRecordConverter method createInsertStmt.

/**
 * creates an insert statement for a given viewable.
 * @param sqlTableName table name of viewable
 * @param aclass viewable
 * @return insert statement
 */
public String createInsertStmt(boolean isUpdate, Viewable iomClass, DbTableName sqlTableName, ViewableWrapper aclass, StructWrapper structEle) {
    StringBuffer ret = new StringBuffer();
    StringBuffer values = new StringBuffer();
    // WHERE some_column=some_value;
    if (isUpdate) {
        ret.append("UPDATE ");
    } else {
        ret.append("INSERT INTO ");
    }
    ret.append(sqlTableName.getQName());
    String sep = null;
    if (isUpdate) {
        sep = " SET ";
    } else {
        sep = " (";
    }
    // add T_Id
    if (!isUpdate) {
        ret.append(sep);
        ret.append(colT_ID);
        values.append("?");
        sep = ",";
    }
    // add T_basket
    if (createBasketCol) {
        ret.append(sep);
        ret.append(DbNames.T_BASKET_COL);
        if (isUpdate) {
            ret.append("=?");
        } else {
            values.append(",?");
        }
        sep = ",";
    }
    if (createDatasetCol) {
        ret.append(sep);
        ret.append(DbNames.T_DATASET_COL);
        if (isUpdate) {
            ret.append("=?");
        } else {
            values.append(",?");
        }
        sep = ",";
    }
    if (!aclass.isSecondaryTable()) {
        // if root, add type
        if (aclass.getExtending() == null) {
            if (createTypeDiscriminator || aclass.includesMultipleTypes()) {
                ret.append(sep);
                ret.append(DbNames.T_TYPE_COL);
                if (isUpdate) {
                    ret.append("=?");
                } else {
                    values.append(",?");
                }
                sep = ",";
            }
            // if Class
            if (!aclass.isStructure()) {
                if (!isUpdate) {
                    if (createIliTidCol || aclass.getOid() != null) {
                        ret.append(sep);
                        ret.append(DbNames.T_ILI_TID_COL);
                        values.append(",?");
                        sep = ",";
                    }
                }
            }
            // if STRUCTURE, add ref to parent
            if (aclass.isStructure()) {
                if (structEle == null) {
                // struct is extended by a class and current object is an instance of the class
                } else {
                    // current object is an instance of the structure
                    if (createGenericStructRef) {
                        ret.append(sep);
                        ret.append(DbNames.T_PARENT_ID_COL);
                        if (isUpdate) {
                            ret.append("=?");
                        } else {
                            values.append(",?");
                        }
                        sep = ",";
                        ret.append(sep);
                        ret.append(DbNames.T_PARENT_TYPE_COL);
                        if (isUpdate) {
                            ret.append("=?");
                        } else {
                            values.append(",?");
                        }
                        sep = ",";
                        // attribute name in parent class
                        ret.append(sep);
                        ret.append(DbNames.T_PARENT_ATTR_COL);
                        if (isUpdate) {
                            ret.append("=?");
                        } else {
                            values.append(",?");
                        }
                        sep = ",";
                    } else {
                        ret.append(sep);
                        Viewable parentViewable = getViewable(structEle.getParentSqlType());
                        ViewableWrapper parentTable = getViewableWrapperOfAbstractClass((Viewable) structEle.getParentAttr().getContainer(), parentViewable);
                        ret.append(ili2sqlName.mapIliAttributeDefReverse(structEle.getParentAttr(), sqlTableName.getName(), parentTable.getSqlTablename()));
                        if (isUpdate) {
                            ret.append("=?");
                        } else {
                            values.append(",?");
                        }
                        sep = ",";
                    }
                    // seqeunce (not null if LIST)
                    ret.append(sep);
                    ret.append(DbNames.T_SEQ_COL);
                    if (isUpdate) {
                        ret.append("=?");
                    } else {
                        values.append(",?");
                    }
                    sep = ",";
                }
            }
        }
    }
    HashSet attrs = getIomObjectAttrs(iomClass);
    Iterator iter = aclass.getAttrIterator();
    while (iter.hasNext()) {
        ViewableTransferElement obj = (ViewableTransferElement) iter.next();
        if (obj.obj instanceof AttributeDef) {
            AttributeDef attr = (AttributeDef) obj.obj;
            if (attrs.contains(attr)) {
                if (!attr.isTransient()) {
                    Type proxyType = attr.getDomain();
                    if (proxyType != null && (proxyType instanceof ObjectType)) {
                    // skip implicit particles (base-viewables) of views
                    } else {
                        sep = addAttrToInsertStmt(isUpdate, ret, values, sep, attr, sqlTableName.getName());
                    }
                }
            }
        }
        if (obj.obj instanceof RoleDef) {
            RoleDef role = (RoleDef) obj.obj;
            if (role.getExtending() == null) {
                if (attrs.contains(role)) {
                    ArrayList<ViewableWrapper> targetTables = getTargetTables(role.getDestination());
                    for (ViewableWrapper targetTable : targetTables) {
                        String roleName = ili2sqlName.mapIliRoleDef(role, sqlTableName.getName(), targetTable.getSqlTablename(), targetTables.size() > 1);
                        // a role of an embedded association?
                        if (obj.embedded) {
                            AssociationDef roleOwner = (AssociationDef) role.getContainer();
                            if (roleOwner.getDerivedFrom() == null) {
                                // TODO if(orderPos!=0){
                                ret.append(sep);
                                ret.append(roleName);
                                if (isUpdate) {
                                    ret.append("=?");
                                } else {
                                    values.append(",?");
                                }
                                sep = ",";
                            }
                        } else {
                            // TODO if(orderPos!=0){
                            ret.append(sep);
                            ret.append(roleName);
                            if (isUpdate) {
                                ret.append("=?");
                            } else {
                                values.append(",?");
                            }
                            sep = ",";
                        }
                    }
                }
            }
        }
    }
    // stdcols
    if (createStdCols) {
        ret.append(sep);
        ret.append(DbNames.T_LAST_CHANGE_COL);
        if (isUpdate) {
            ret.append("=?");
        } else {
            values.append(",?");
        }
        sep = ",";
        if (!isUpdate) {
            ret.append(sep);
            ret.append(DbNames.T_CREATE_DATE_COL);
            values.append(",?");
            sep = ",";
        }
        ret.append(sep);
        ret.append(DbNames.T_USER_COL);
        if (isUpdate) {
            ret.append("=?");
        } else {
            values.append(",?");
        }
        sep = ",";
    }
    if (isUpdate) {
        // WHERE some_column=some_value;
        // add T_Id
        ret.append(" WHERE ");
        ret.append(colT_ID);
        ret.append("=?");
    } else {
        ret.append(") VALUES (");
        ret.append(values);
        ret.append(")");
    }
    return ret.toString();
}

Example 9 with Type

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

the class TransferFromXtf method allReferencesKnownHelper.

private void allReferencesKnownHelper(IomObject iomObj, FixIomObjectExtRefs extref) {
    String tag = iomObj.getobjecttag();
    // EhiLogger.debug("tag "+tag);
    Object modelele = tag2class.get(tag);
    if (modelele == null) {
        return;
    }
    // ASSERT: an ordinary class/table
    Viewable aclass = (Viewable) modelele;
    Iterator iter = aclass.getAttributesAndRoles2();
    while (iter.hasNext()) {
        ViewableTransferElement obj = (ViewableTransferElement) iter.next();
        if (obj.obj instanceof AttributeDef) {
            AttributeDef attr = (AttributeDef) obj.obj;
            if (!attr.isTransient()) {
                Type proxyType = attr.getDomain();
                if (proxyType != null && (proxyType instanceof ObjectType)) {
                // skip implicit particles (base-viewables) of views
                } else {
                    allReferencesKnownHelper(iomObj, attr, extref);
                }
            }
        }
        if (obj.obj instanceof RoleDef) {
            RoleDef role = (RoleDef) obj.obj;
            if (role.getExtending() == null) {
                String roleName = role.getName();
                // a role of an embedded association?
                if (obj.embedded) {
                    AssociationDef roleOwner = (AssociationDef) role.getContainer();
                    if (roleOwner.getDerivedFrom() == null) {
                        // not just a link?
                        IomObject structvalue = iomObj.getattrobj(roleName, 0);
                        if (roleOwner.getAttributes().hasNext() || roleOwner.getLightweightAssociations().iterator().hasNext()) {
                        // TODO handle attributes of link
                        }
                        if (structvalue != null) {
                            String refoid = structvalue.getobjectrefoid();
                            Viewable targetClass = role.getDestination();
                            if (!oidPool.containsXtfid(Ili2cUtility.getRootViewable(targetClass).getScopedName(null), refoid)) {
                                extref.addFix(structvalue, targetClass);
                            }
                        }
                    }
                } else {
                    IomObject structvalue = iomObj.getattrobj(roleName, 0);
                    String refoid = structvalue.getobjectrefoid();
                    Viewable targetClass = role.getDestination();
                    if (!oidPool.containsXtfid(Ili2cUtility.getRootViewable(targetClass).getScopedName(null), refoid)) {
                        extref.addFix(structvalue, targetClass);
                    }
                }
            }
        }
    }
}

Example 10 with Type

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

the class FromIliRecordConverter method generateTable.

public void generateTable(ViewableWrapper def, int pass) throws Ili2dbException {
    if (!def.isSecondaryTable()) {
        surfaceAttrs = new ArrayList<AttributeDef>();
    }
    // EhiLogger.debug("viewable "+def);
    if (pass == 1) {
        DbTableName sqlName = new DbTableName(schema.getName(), def.getSqlTablename());
        DbTable dbTable = new DbTable();
        dbTable.setName(sqlName);
        schema.addTable(dbTable);
        return;
    }
    // second pass; add columns
    DbTableName sqlName = new DbTableName(schema.getName(), def.getSqlTablename());
    DbTable dbTable = schema.findTable(sqlName);
    ViewableWrapper base = def.getExtending();
    {
        StringBuffer cmt = new StringBuffer();
        String cmtSep = "";
        if (!def.isSecondaryTable()) {
            dbTable.setIliName(def.getViewable().getScopedName(null));
            if (def.getViewable().getDocumentation() != null) {
                cmt.append(cmtSep + def.getViewable().getDocumentation());
                cmtSep = nl;
            }
            cmt.append(cmtSep + "@iliname " + def.getViewable().getScopedName(null));
            cmtSep = nl;
        }
        if (cmt.length() > 0) {
            dbTable.setComment(cmt.toString());
        }
    }
    if (deleteExistingData) {
        dbTable.setDeleteDataIfTableExists(true);
    }
    if (base == null && !def.isSecondaryTable()) {
        dbTable.setRequiresSequence(true);
    }
    String baseRef = "";
    DbColId dbColId = addKeyCol(dbTable);
    if (base != null) {
        dbColId.setScriptComment("REFERENCES " + base.getViewable().getScopedName(null));
        if (createFk) {
            dbColId.setReferencedTable(getSqlType(base.getViewable()));
        }
    } else if (def.isSecondaryTable()) {
        if (createFk) {
            dbColId.setReferencedTable(new DbTableName(schema.getName(), def.getMainTable().getSqlTablename()));
        }
    }
    if (createBasketCol) {
        // add basketCol
        DbColId t_basket = new DbColId();
        t_basket.setName(DbNames.T_BASKET_COL);
        t_basket.setNotNull(true);
        t_basket.setScriptComment("REFERENCES " + DbNames.BASKETS_TAB);
        if (createFk) {
            t_basket.setReferencedTable(new DbTableName(schema.getName(), DbNames.BASKETS_TAB));
        }
        if (createFkIdx) {
            t_basket.setIndex(true);
        }
        dbTable.addColumn(t_basket);
    }
    if (createDatasetCol) {
        DbColVarchar t_dsName = new DbColVarchar();
        t_dsName.setName(DbNames.T_DATASET_COL);
        t_dsName.setSize(DbNames.DATASETNAME_COL_SIZE);
        t_dsName.setNotNull(true);
        t_dsName.setIndex(true);
        dbTable.addColumn(t_dsName);
    }
    DbColumn dbCol;
    if (base == null && !def.isSecondaryTable()) {
        if (createTypeDiscriminator || def.includesMultipleTypes()) {
            dbCol = createSqlTypeCol(DbNames.T_TYPE_COL);
            dbTable.addColumn(dbCol);
        }
        // if CLASS
        if (!def.isStructure()) {
            if (createIliTidCol || def.getOid() != null) {
                addIliTidCol(dbTable, def.getOid());
            }
        }
        // if STRUCTURE, add ref to parent
        if (def.isStructure()) {
            if (createGenericStructRef) {
                // add parentid
                DbColId dbParentId = new DbColId();
                dbParentId.setName(DbNames.T_PARENT_ID_COL);
                dbParentId.setNotNull(true);
                dbParentId.setPrimaryKey(false);
                dbTable.addColumn(dbParentId);
                // add parent_type
                dbCol = createSqlTypeCol(DbNames.T_PARENT_TYPE_COL);
                dbTable.addColumn(dbCol);
                // add parent_attr
                dbCol = createSqlTypeCol(DbNames.T_PARENT_ATTR_COL);
                dbTable.addColumn(dbCol);
            } else {
            // add reference to parent for each structAttr when generating structAttr
            }
            // add sequence attr
            DbColId dbSeq = new DbColId();
            dbSeq.setName(DbNames.T_SEQ_COL);
            // dbSeq.setNotNull(true); // must be optional for cases where struct is exdended by a class
            dbSeq.setPrimaryKey(false);
            dbTable.addColumn(dbSeq);
        }
    }
    // body
    Iterator<ViewableTransferElement> iter = def.getAttrIterator();
    while (iter.hasNext()) {
        ViewableTransferElement obj = iter.next();
        if (obj.obj instanceof AttributeDef) {
            AttributeDef attr = (AttributeDef) obj.obj;
            if (attr.getExtending() == null) {
                try {
                    if (createItfLineTables && attr.getDomainResolvingAll() instanceof SurfaceOrAreaType) {
                        surfaceAttrs.add(attr);
                    }
                    if (!attr.isTransient()) {
                        Type proxyType = attr.getDomain();
                        if (proxyType != null && (proxyType instanceof ObjectType)) {
                        // skip implicit particles (base-viewables) of views
                        } else {
                            generateAttr(dbTable, def.getViewable(), attr);
                        }
                    }
                } catch (Exception ex) {
                    throw new Ili2dbException(attr.getContainer().getScopedName(null) + "." + attr.getName(), ex);
                }
            } else {
                if (attr.isDomainBoolean()) {
                } else if (createEnumColAsItfCode && attr.getDomainResolvingAll() instanceof EnumerationType) {
                    throw new Ili2dbException("EXTENDED attributes with type enumeration not supported");
                }
            }
        }
        if (obj.obj instanceof RoleDef) {
            RoleDef role = (RoleDef) obj.obj;
            if (role.getExtending() == null) {
                // not an embedded role and roledef not defined in a lightweight association?
                if (!obj.embedded && !def.isAssocLightweight()) {
                    ArrayList<ViewableWrapper> targetTables = getTargetTables(role.getDestination());
                    for (ViewableWrapper targetTable : targetTables) {
                        dbColId = new DbColId();
                        DbTableName targetSqlTableName = targetTable.getSqlTable();
                        String roleSqlName = ili2sqlName.mapIliRoleDef(role, sqlName.getName(), targetSqlTableName.getName(), targetTables.size() > 1);
                        dbColId.setName(roleSqlName);
                        boolean notNull = false;
                        if (!sqlEnableNull) {
                            if (targetTables.size() > 1) {
                                // multiple alternative FK columns
                                notNull = false;
                            } else {
                                notNull = true;
                            }
                        }
                        dbColId.setNotNull(notNull);
                        dbColId.setPrimaryKey(false);
                        if (createFk) {
                            dbColId.setReferencedTable(targetSqlTableName);
                        }
                        if (createFkIdx) {
                            dbColId.setIndex(true);
                        }
                        String cmt = role.getDocumentation();
                        if (cmt != null && cmt.length() > 0) {
                            dbColId.setComment(cmt);
                        }
                        dbTable.addColumn(dbColId);
                        // handle ordered
                        if (role.isOrdered()) {
                            // add seqeunce attr
                            DbColId dbSeq = new DbColId();
                            dbSeq.setName(roleSqlName + "_" + DbNames.T_SEQ_COL);
                            dbSeq.setNotNull(notNull);
                            dbSeq.setPrimaryKey(false);
                            dbTable.addColumn(dbSeq);
                        }
                    }
                }
                // a role of an embedded association?
                if (obj.embedded) {
                    AssociationDef roleOwner = (AssociationDef) role.getContainer();
                    if (roleOwner.getDerivedFrom() == null) {
                        // role is oppend;
                        ArrayList<ViewableWrapper> targetTables = getTargetTables(role.getDestination());
                        for (ViewableWrapper targetTable : targetTables) {
                            dbColId = new DbColId();
                            DbTableName targetSqlTableName = targetTable.getSqlTable();
                            String roleSqlName = ili2sqlName.mapIliRoleDef(role, sqlName.getName(), targetSqlTableName.getName(), targetTables.size() > 1);
                            dbColId.setName(roleSqlName);
                            boolean notNull = false;
                            if (!sqlEnableNull) {
                                if (targetTables.size() > 1) {
                                    // multiple alternative FK columns
                                    notNull = false;
                                } else if (role.getOppEnd().getDestination() != def.getViewable()) {
                                    // other subtypes in of def don't have this FK
                                    notNull = false;
                                } else {
                                    if (role.getCardinality().getMinimum() == 0) {
                                        notNull = false;
                                    } else {
                                        notNull = true;
                                    }
                                }
                            }
                            dbColId.setNotNull(notNull);
                            dbColId.setPrimaryKey(false);
                            if (createFk) {
                                dbColId.setReferencedTable(targetSqlTableName);
                            }
                            if (createFkIdx) {
                                dbColId.setIndex(true);
                            }
                            String cmt = role.getDocumentation();
                            if (cmt != null && cmt.length() > 0) {
                                dbColId.setComment(cmt);
                            }
                            customMapping.fixupEmbeddedLink(dbTable, dbColId, roleOwner, role, targetSqlTableName, colT_ID);
                            dbTable.addColumn(dbColId);
                            // handle ordered
                            if (role.getOppEnd().isOrdered()) {
                                // add seqeunce attr
                                DbColId dbSeq = new DbColId();
                                dbSeq.setName(roleSqlName + "_" + DbNames.T_SEQ_COL);
                                dbSeq.setNotNull(notNull);
                                dbSeq.setPrimaryKey(false);
                                dbTable.addColumn(dbSeq);
                            }
                        }
                    }
                }
            }
        }
    }
    if (createStdCols) {
        addStdCol(dbTable);
    }
    if (createUnique && !def.isStructure()) {
        // check if UNIQUE mappable
        HashSet wrapperCols = getWrapperCols(def.getAttrv());
        Viewable aclass = def.getViewable();
        Iterator it = aclass.iterator();
        while (it.hasNext()) {
            Object cnstro = it.next();
            if (cnstro instanceof UniquenessConstraint) {
                UniquenessConstraint cnstr = (UniquenessConstraint) cnstro;
                HashSet attrs = getUniqueAttrs(cnstr, wrapperCols);
                // mappable?
                if (attrs != null) {
                    DbIndex dbIndex = new DbIndex();
                    dbIndex.setPrimary(false);
                    dbIndex.setUnique(true);
                    for (Object attro : attrs) {
                        String attrSqlName = null;
                        if (attro instanceof AttributeDef) {
                            attrSqlName = ili2sqlName.mapIliAttributeDef((AttributeDef) attro, def.getSqlTablename(), null);
                        } else if (attro instanceof RoleDef) {
                            RoleDef role = (RoleDef) attro;
                            DbTableName targetSqlTableName = getSqlType(role.getDestination());
                            attrSqlName = ili2sqlName.mapIliRoleDef(role, def.getSqlTablename(), targetSqlTableName.getName());
                        } else {
                            throw new IllegalStateException("unexpected attr " + attro);
                        }
                        DbColumn idxCol = dbTable.getColumn(attrSqlName);
                        dbIndex.addAttr(idxCol);
                    }
                    dbTable.addIndex(dbIndex);
                }
            }
        }
    }
    if (!def.isSecondaryTable()) {
        customMapping.fixupViewable(dbTable, def.getViewable());
    }
}