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

Example 1 with SurfaceType

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

the class ToXtfRecordConverter method addAttrValue.

public int addAttrValue(java.sql.ResultSet rs, int valuei, long sqlid, Iom_jObject iomObj, AttributeDef attr, ArrayList<StructWrapper> structQueue, ViewableWrapper table, FixIomObjectRefs fixref) throws SQLException {
    if (attr.getExtending() == null) {
        String attrName = attr.getName();
        String sqlAttrName = ili2sqlName.mapIliAttributeDef(attr, table.getSqlTablename(), null);
        if (attr.isDomainBoolean()) {
            boolean value = rs.getBoolean(valuei);
            valuei++;
            if (!rs.wasNull()) {
                if (value) {
                    iomObj.setattrvalue(attrName, "true");
                } else {
                    iomObj.setattrvalue(attrName, "false");
                }
            }
        } else if (attr.isDomainIli1Date()) {
            java.sql.Date value = rs.getDate(valuei);
            valuei++;
            if (!rs.wasNull()) {
                java.text.SimpleDateFormat fmt = new java.text.SimpleDateFormat("yyyyMMdd");
                GregorianCalendar date = new GregorianCalendar();
                date.setGregorianChange(PURE_GREGORIAN_CALENDAR);
                fmt.setCalendar(date);
                iomObj.setattrvalue(attrName, fmt.format(value));
            }
        } else if (attr.isDomainIli2Date()) {
            java.sql.Date value = rs.getDate(valuei);
            valuei++;
            if (!rs.wasNull()) {
                java.text.SimpleDateFormat fmt = new java.text.SimpleDateFormat("yyyy-MM-dd");
                GregorianCalendar date = new GregorianCalendar();
                date.setGregorianChange(PURE_GREGORIAN_CALENDAR);
                fmt.setCalendar(date);
                iomObj.setattrvalue(attrName, fmt.format(value));
            }
        } else if (attr.isDomainIli2Time()) {
            java.sql.Time value = rs.getTime(valuei);
            valuei++;
            if (!rs.wasNull()) {
                java.text.SimpleDateFormat fmt = new java.text.SimpleDateFormat("HH:mm:ss.SSS");
                iomObj.setattrvalue(attrName, fmt.format(value));
            }
        } else if (attr.isDomainIli2DateTime()) {
            java.sql.Timestamp value = rs.getTimestamp(valuei);
            valuei++;
            if (!rs.wasNull()) {
                // with timezone: yyyy-MM-dd'T'HH:mm:ss.SSSZ
                java.text.SimpleDateFormat fmt = new java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");
                GregorianCalendar date = new GregorianCalendar();
                date.setGregorianChange(PURE_GREGORIAN_CALENDAR);
                fmt.setCalendar(date);
                iomObj.setattrvalue(attrName, fmt.format(value));
            }
        } else {
            Type type = attr.getDomainResolvingAliases();
            if (type instanceof CompositionType) {
                if (TrafoConfigNames.CATALOGUE_REF_TRAFO_COALESCE.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.CATALOGUE_REF_TRAFO))) {
                    Table catalogueReferenceTyp = ((CompositionType) type).getComponentType();
                    long value = rs.getLong(valuei);
                    valuei++;
                    if (!rs.wasNull()) {
                        IomObject catref = iomObj.addattrobj(attrName, catalogueReferenceTyp.getScopedName(null));
                        IomObject ref = catref.addattrobj(IliNames.CHBASE1_CATALOGUEREFERENCE_REFERENCE, "REF");
                        mapSqlid2Xtfid(fixref, value, ref, ((ReferenceType) ((AttributeDef) catalogueReferenceTyp.getAttributes().next()).getDomain()).getReferred());
                    }
                } else if (TrafoConfigNames.MULTISURFACE_TRAFO_COALESCE.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.MULTISURFACE_TRAFO))) {
                    MultiSurfaceMapping attrMapping = multiSurfaceAttrs.getMapping(attr);
                    Table multiSurfaceType = ((CompositionType) type).getComponentType();
                    Table surfaceStructureType = ((CompositionType) ((AttributeDef) multiSurfaceType.getElement(AttributeDef.class, attrMapping.getBagOfSurfacesAttrName())).getDomain()).getComponentType();
                    String multiSurfaceQname = multiSurfaceType.getScopedName(null);
                    String surfaceStructureQname = surfaceStructureType.getScopedName(null);
                    SurfaceType surface = ((SurfaceType) ((AttributeDef) surfaceStructureType.getElement(AttributeDef.class, attrMapping.getSurfaceAttrName())).getDomainResolvingAliases());
                    CoordType coord = (CoordType) surface.getControlPointDomain().getType();
                    boolean is3D = coord.getDimensions().length == 3;
                    Object geomobj = rs.getObject(valuei);
                    valuei++;
                    if (!rs.wasNull()) {
                        try {
                            IomObject iomMultiSurface = geomConv.toIomMultiSurface(geomobj, sqlAttrName, is3D);
                            IomObject iomChbaseMultiSurface = new Iom_jObject(multiSurfaceQname, null);
                            int surfacec = iomMultiSurface.getattrvaluecount("surface");
                            for (int surfacei = 0; surfacei < surfacec; surfacei++) {
                                IomObject iomSurface = iomMultiSurface.getattrobj("surface", surfacei);
                                IomObject iomChbaseSurfaceStructure = iomChbaseMultiSurface.addattrobj(attrMapping.getBagOfSurfacesAttrName(), surfaceStructureQname);
                                IomObject iomSurfaceClone = new ch.interlis.iom_j.Iom_jObject("MULTISURFACE", null);
                                iomSurfaceClone.addattrobj("surface", iomSurface);
                                iomChbaseSurfaceStructure.addattrobj(attrMapping.getSurfaceAttrName(), iomSurfaceClone);
                            }
                            iomObj.addattrobj(attrName, iomChbaseMultiSurface);
                        } catch (ConverterException ex) {
                            EhiLogger.logError("Object " + sqlid + ": failed to convert surface/area", ex);
                        }
                    }
                } else if (TrafoConfigNames.MULTILINE_TRAFO_COALESCE.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.MULTILINE_TRAFO))) {
                    MultiLineMapping attrMapping = multiLineAttrs.getMapping(attr);
                    Table multiLineType = ((CompositionType) type).getComponentType();
                    Table lineStructureType = ((CompositionType) ((AttributeDef) multiLineType.getElement(AttributeDef.class, attrMapping.getBagOfLinesAttrName())).getDomain()).getComponentType();
                    String multiLineQname = multiLineType.getScopedName(null);
                    String lineStructureQname = lineStructureType.getScopedName(null);
                    PolylineType surface = ((PolylineType) ((AttributeDef) lineStructureType.getElement(AttributeDef.class, attrMapping.getLineAttrName())).getDomainResolvingAliases());
                    CoordType coord = (CoordType) surface.getControlPointDomain().getType();
                    boolean is3D = coord.getDimensions().length == 3;
                    Object geomobj = rs.getObject(valuei);
                    valuei++;
                    if (!rs.wasNull()) {
                        try {
                            IomObject iomMultiPolygon = geomConv.toIomMultiPolyline(geomobj, sqlAttrName, is3D);
                            IomObject iomChbaseMultiLine = new Iom_jObject(multiLineQname, null);
                            int linec = iomMultiPolygon.getattrvaluecount(Wkb2iox.ATTR_POLYLINE);
                            for (int linei = 0; linei < linec; linei++) {
                                IomObject iomPolygon = iomMultiPolygon.getattrobj(Wkb2iox.ATTR_POLYLINE, linei);
                                IomObject iomChbaseSurfaceStructure = iomChbaseMultiLine.addattrobj(attrMapping.getBagOfLinesAttrName(), lineStructureQname);
                                iomChbaseSurfaceStructure.addattrobj(attrMapping.getLineAttrName(), iomPolygon);
                            }
                            iomObj.addattrobj(attrName, iomChbaseMultiLine);
                        } catch (ConverterException ex) {
                            EhiLogger.logError("Object " + sqlid + ": failed to convert polyline", ex);
                        }
                    }
                } else if (TrafoConfigNames.MULTIPOINT_TRAFO_COALESCE.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.MULTIPOINT_TRAFO))) {
                    MultiPointMapping attrMapping = multiPointAttrs.getMapping(attr);
                    Table multiPointType = ((CompositionType) type).getComponentType();
                    Table pointStructureType = ((CompositionType) ((AttributeDef) multiPointType.getElement(AttributeDef.class, attrMapping.getBagOfPointsAttrName())).getDomain()).getComponentType();
                    String multiPointQname = multiPointType.getScopedName(null);
                    String pointStructureQname = pointStructureType.getScopedName(null);
                    CoordType coord = ((CoordType) ((AttributeDef) pointStructureType.getElement(AttributeDef.class, attrMapping.getPointAttrName())).getDomainResolvingAliases());
                    boolean is3D = coord.getDimensions().length == 3;
                    Object geomobj = rs.getObject(valuei);
                    valuei++;
                    if (!rs.wasNull()) {
                        try {
                            IomObject iomMultiPoint = geomConv.toIomMultiCoord(geomobj, sqlAttrName, is3D);
                            IomObject iomChbaseMultiPoint = new Iom_jObject(multiPointQname, null);
                            int pointc = iomMultiPoint.getattrvaluecount(Wkb2iox.ATTR_COORD);
                            for (int pointi = 0; pointi < pointc; pointi++) {
                                IomObject iomPoint = iomMultiPoint.getattrobj(Wkb2iox.ATTR_COORD, pointi);
                                IomObject iomChbasePointStructure = iomChbaseMultiPoint.addattrobj(attrMapping.getBagOfPointsAttrName(), pointStructureQname);
                                iomChbasePointStructure.addattrobj(attrMapping.getPointAttrName(), iomPoint);
                            }
                            iomObj.addattrobj(attrName, iomChbaseMultiPoint);
                        } catch (ConverterException ex) {
                            EhiLogger.logError("Object " + sqlid + ": failed to convert coord", ex);
                        }
                    }
                } else if (TrafoConfigNames.ARRAY_TRAFO_COALESCE.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.ARRAY_TRAFO))) {
                    ArrayMapping attrMapping = arrayAttrs.getMapping(attr);
                    Object dbValue = rs.getObject(valuei);
                    valuei++;
                    if (!rs.wasNull()) {
                        try {
                            Table valueStructType = ((CompositionType) type).getComponentType();
                            String valueStructQname = valueStructType.getScopedName(null);
                            String[] iomArray = geomConv.toIomArray(attrMapping.getValueAttr(), dbValue, enumTypes);
                            for (int elei = 0; elei < iomArray.length; elei++) {
                                IomObject iomValueStruct = new Iom_jObject(valueStructQname, null);
                                iomValueStruct.setattrvalue(attrMapping.getValueAttr().getName(), iomArray[elei]);
                                iomObj.addattrobj(attrName, iomValueStruct);
                            }
                        } catch (ConverterException ex) {
                            EhiLogger.logError("Object " + sqlid + ": failed to convert array", ex);
                        }
                    }
                } else if (TrafoConfigNames.MULTILINGUAL_TRAFO_EXPAND.equals(trafoConfig.getAttrConfig(attr, TrafoConfigNames.MULTILINGUAL_TRAFO))) {
                    IomObject iomMulti = null;
                    Table multilingualTextType = ((CompositionType) type).getComponentType();
                    String multilingualTextQname = multilingualTextType.getScopedName(null);
                    String localizedTextQname = ((CompositionType) ((AttributeDef) multilingualTextType.getAttributes().next()).getDomain()).getComponentType().getScopedName(null);
                    for (String sfx : DbNames.MULTILINGUAL_TXT_COL_SUFFIXS) {
                        String value = rs.getString(valuei);
                        valuei++;
                        if (!rs.wasNull()) {
                            if (iomMulti == null) {
                                iomMulti = new Iom_jObject(multilingualTextQname, null);
                            }
                            IomObject iomTxt = iomMulti.addattrobj(IliNames.CHBASE1_LOCALISEDTEXT, localizedTextQname);
                            iomTxt.setattrvalue(IliNames.CHBASE1_LOCALISEDTEXT_LANGUAGE, sfx.length() == 0 ? null : sfx.substring(LEN_LANG_PREFIX));
                            iomTxt.setattrvalue(IliNames.CHBASE1_LOCALISEDTEXT_TEXT, value);
                        }
                    }
                    if (iomMulti != null) {
                        iomObj.addattrobj(attrName, iomMulti);
                    }
                } else {
                    // enque iomObj as parent
                    structQueue.add(new StructWrapper(sqlid, attr, iomObj, table));
                }
            } else if (type instanceof PolylineType) {
                Object geomobj = rs.getObject(valuei);
                valuei++;
                if (!rs.wasNull()) {
                    try {
                        boolean is3D = ((CoordType) ((PolylineType) type).getControlPointDomain().getType()).getDimensions().length == 3;
                        IomObject polyline = geomConv.toIomPolyline(geomobj, sqlAttrName, is3D);
                        iomObj.addattrobj(attrName, polyline);
                    } catch (ConverterException ex) {
                        EhiLogger.logError("Object " + sqlid + ": failed to convert polyline", ex);
                    }
                }
            } else if (type instanceof SurfaceOrAreaType) {
                if (createItfLineTables) {
                } else {
                    Object geomobj = rs.getObject(valuei);
                    valuei++;
                    if (!rs.wasNull()) {
                        try {
                            boolean is3D = ((CoordType) ((SurfaceOrAreaType) type).getControlPointDomain().getType()).getDimensions().length == 3;
                            IomObject surface = geomConv.toIomSurface(geomobj, sqlAttrName, is3D);
                            iomObj.addattrobj(attrName, surface);
                        } catch (ConverterException ex) {
                            EhiLogger.logError("Object " + sqlid + ": failed to convert surface/area", ex);
                        }
                    }
                }
                if (createItfAreaRef) {
                    if (type instanceof AreaType) {
                        Object geomobj = rs.getObject(valuei);
                        valuei++;
                        if (!rs.wasNull()) {
                            try {
                                boolean is3D = false;
                                IomObject coord = geomConv.toIomCoord(geomobj, sqlAttrName, is3D);
                                iomObj.addattrobj(attrName, coord);
                            } catch (ConverterException ex) {
                                EhiLogger.logError("Object " + sqlid + ": failed to convert coord", ex);
                            }
                        }
                    }
                }
            } else if (type instanceof CoordType) {
                Object geomobj = rs.getObject(valuei);
                valuei++;
                if (!rs.wasNull()) {
                    try {
                        boolean is3D = ((CoordType) type).getDimensions().length == 3;
                        IomObject coord = geomConv.toIomCoord(geomobj, sqlAttrName, is3D);
                        iomObj.addattrobj(attrName, coord);
                    } catch (ConverterException ex) {
                        EhiLogger.logError("Object " + sqlid + ": failed to convert coord", ex);
                    }
                }
            } else if (type instanceof EnumerationType) {
                if (createEnumColAsItfCode) {
                    int value = rs.getInt(valuei);
                    valuei++;
                    if (!rs.wasNull()) {
                        iomObj.setattrvalue(attrName, mapItfCode2XtfCode((EnumerationType) type, value));
                    }
                } else {
                    String value = rs.getString(valuei);
                    valuei++;
                    if (!rs.wasNull()) {
                        iomObj.setattrvalue(attrName, value);
                    }
                }
            } else if (type instanceof ReferenceType) {
                ArrayList<ViewableWrapper> targetTables = getTargetTables(((ReferenceType) type).getReferred());
                boolean refAlreadyDefined = false;
                for (ViewableWrapper targetTable : targetTables) {
                    long value = rs.getLong(valuei);
                    valuei++;
                    if (!rs.wasNull()) {
                        if (refAlreadyDefined) {
                            sqlAttrName = ili2sqlName.mapIliAttributeDef(attr, table.getSqlTablename(), targetTable.getSqlTablename(), targetTables.size() > 1);
                            EhiLogger.logAdaption("Table " + table.getSqlTablename() + "(id " + sqlid + ") more than one value for refattr " + attrName + "; value of " + sqlAttrName + " ignored");
                        } else {
                            IomObject ref = iomObj.addattrobj(attrName, "REF");
                            mapSqlid2Xtfid(fixref, value, ref, ((ReferenceType) type).getReferred());
                            refAlreadyDefined = true;
                        }
                    }
                }
            } else if (type instanceof BlackboxType) {
                if (((BlackboxType) type).getKind() == BlackboxType.eXML) {
                    Object obj = rs.getObject(valuei);
                    valuei++;
                    if (!rs.wasNull()) {
                        try {
                            iomObj.setattrvalue(attrName, geomConv.toIomXml(obj));
                        } catch (ConverterException ex) {
                            EhiLogger.logError("Object " + sqlid + ": failed to convert blackbox xml", ex);
                        }
                    }
                } else {
                    Object obj = rs.getObject(valuei);
                    valuei++;
                    if (!rs.wasNull()) {
                        try {
                            iomObj.setattrvalue(attrName, geomConv.toIomBlob(obj));
                        } catch (ConverterException ex) {
                            EhiLogger.logError("Object " + sqlid + ": failed to convert blackbox binary", ex);
                        }
                    }
                }
            } else {
                String value = rs.getString(valuei);
                valuei++;
                if (!rs.wasNull()) {
                    iomObj.setattrvalue(attrName, value);
                }
            }
        }
    }
    return valuei;
}

Example 2 with SurfaceType

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

the class TransferToXtf method createItfLineTableQueryStmt.

private String createItfLineTableQueryStmt(AttributeDef attr, Long basketSqlId, SqlColumnConverter conv) {
    StringBuffer ret = new StringBuffer();
    ret.append("SELECT r0." + colT_ID);
    if (writeIliTid) {
        ret.append(", r0." + DbNames.T_ILI_TID_COL);
    }
    String sep = ",";
    SurfaceOrAreaType type = (SurfaceOrAreaType) attr.getDomainResolvingAliases();
    String sqlTabName = ili2sqlName.mapGeometryAsTable(attr);
    // geomAttr
    ret.append(sep);
    sep = ",";
    ret.append(conv.getSelectValueWrapperPolyline(ili2sqlName.getSqlColNameItfLineTableGeomAttr(attr, sqlTabName)));
    // is it of type SURFACE?
    if (type instanceof SurfaceType) {
        // -> mainTable
        ret.append(sep);
        sep = ",";
        ret.append(ili2sqlName.getSqlColNameItfLineTableRefAttr(attr, sqlTabName));
    }
    Table lineAttrTable = type.getLineAttributeStructure();
    if (lineAttrTable != null) {
        Iterator attri = lineAttrTable.getAttributes();
        while (attri.hasNext()) {
            AttributeDef lineattr = (AttributeDef) attri.next();
            sep = recConv.addAttrToQueryStmt(ret, sep, null, lineattr, sqlTabName);
        }
    }
    ret.append(" FROM ");
    if (schema != null) {
        sqlTabName = schema + "." + sqlTabName;
    }
    ret.append(sqlTabName);
    ret.append(" r0");
    if (basketSqlId != null) {
        ret.append(" WHERE r0." + DbNames.T_BASKET_COL + "=?");
    }
    return ret.toString();
}

Example 3 with SurfaceType

use of ch.interlis.ili2c.metamodel.SurfaceType 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 4 with SurfaceType

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

the class TransferFromIli method generateItfLineTable.

private void generateItfLineTable(AttributeDef attr, int pass) throws Ili2dbException {
    if (pass == 1) {
        DbTableName sqlName = getSqlTableNameItfLineTable(attr);
        DbTable dbTable = new DbTable();
        dbTable.setName(sqlName);
        dbTable.setIliName(attr.getContainer().getScopedName(null) + "." + attr.getName());
        schema.addTable(dbTable);
        return;
    }
    // second pass; add columns
    DbTableName sqlName = getSqlTableNameItfLineTable(attr);
    DbTable dbTable = schema.findTable(sqlName);
    StringBuffer cmt = new StringBuffer();
    String cmtSep = "";
    if (attr.getDocumentation() != null) {
        cmt.append(cmtSep + attr.getDocumentation());
        cmtSep = nl;
    }
    cmt.append(cmtSep + "@iliname " + attr.getContainer().getScopedName(null) + "." + attr.getName());
    cmtSep = nl;
    if (cmt.length() > 0) {
        dbTable.setComment(cmt.toString());
    }
    if (deleteExistingData) {
        dbTable.setDeleteDataIfTableExists(true);
    }
    dbTable.setRequiresSequence(true);
    DbColId dbColId = recConv.addKeyCol(dbTable);
    if (createIliTidCol) {
        recConv.addIliTidCol(dbTable, null);
    }
    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);
    }
    SurfaceOrAreaType type = (SurfaceOrAreaType) attr.getDomainResolvingAll();
    DbColGeometry dbCol = recConv.generatePolylineType(type, attr.getContainer().getScopedName(null) + "." + attr.getName());
    recConv.setCrs(dbCol, attr);
    dbCol.setName(ili2sqlName.getSqlColNameItfLineTableGeomAttr(attr, sqlName.getName()));
    dbCol.setNotNull(true);
    dbTable.addColumn(dbCol);
    if (type instanceof SurfaceType) {
        dbColId = new DbColId();
        dbColId.setName(ili2sqlName.getSqlColNameItfLineTableRefAttr(attr, sqlName.getName()));
        dbColId.setNotNull(true);
        dbColId.setPrimaryKey(false);
        dbColId.setScriptComment("REFERENCES " + recConv.getSqlType((Viewable) attr.getContainer()));
        if (createFk) {
            dbColId.setReferencedTable(recConv.getSqlType((Viewable) attr.getContainer()));
        }
        if (createFkIdx) {
            dbColId.setIndex(true);
        }
        dbTable.addColumn(dbColId);
    }
    Table lineAttrTable = type.getLineAttributeStructure();
    if (lineAttrTable != null) {
        Iterator attri = lineAttrTable.getAttributes();
        while (attri.hasNext()) {
            AttributeDef lineattr = (AttributeDef) attri.next();
            recConv.generateAttr(dbTable, lineAttrTable, lineattr);
        }
    }
    if (createStdCols) {
        AbstractRecordConverter.addStdCol(dbTable);
    }
}

Example 5 with SurfaceType

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

the class TransferFromXtf method writeItfLineTableObject.

private void writeItfLineTableObject(String datasetName, long basketSqlId, IomObject iomObj, AttributeDef attrDef) throws java.sql.SQLException, ConverterException {
    SurfaceOrAreaType type = (SurfaceOrAreaType) attrDef.getDomainResolvingAliases();
    String geomAttrName = ch.interlis.iom_j.itf.ModelUtilities.getHelperTableGeomAttrName(attrDef);
    String refAttrName = null;
    if (type instanceof SurfaceType) {
        refAttrName = ch.interlis.iom_j.itf.ModelUtilities.getHelperTableMainTableRef(attrDef);
    }
    Table lineAttrTable = type.getLineAttributeStructure();
    // map oid of transfer file to a sql id
    String idTag = attrDef.getContainer().getScopedName(null) + "." + attrDef.getName();
    long sqlId = oidPool.createObjSqlId(idTag, idTag, iomObj.getobjectoid());
    String sqlTableName = getSqlTableNameItfLineTable(attrDef).getQName();
    String insert = createItfLineTableInsertStmt(attrDef);
    EhiLogger.traceBackendCmd(insert);
    PreparedStatement ps = conn.prepareStatement(insert);
    try {
        int valuei = 1;
        ps.setLong(valuei, sqlId);
        valuei++;
        if (createBasketCol) {
            ps.setLong(valuei, basketSqlId);
            valuei++;
        }
        if (createDatasetCol) {
            ps.setString(valuei, datasetName);
            valuei++;
        }
        if (readIliTid) {
            // import TID from transfer file
            ps.setString(valuei, iomObj.getobjectoid());
            valuei++;
        }
        IomObject value = iomObj.getattrobj(geomAttrName, 0);
        if (value != null) {
            boolean is3D = ((CoordType) (type).getControlPointDomain().getType()).getDimensions().length == 3;
            ps.setObject(valuei, geomConv.fromIomPolyline(value, recConv.getSrsid(attrDef), is3D, recConv.getP(type)));
        } else {
            geomConv.setPolylineNull(ps, valuei);
        }
        valuei++;
        if (type instanceof SurfaceType) {
            IomObject structvalue = iomObj.getattrobj(refAttrName, 0);
            String refoid = structvalue.getobjectrefoid();
            long refsqlId = oidPool.getObjSqlId(attrDef.getContainer().getScopedName(null), refoid);
            ps.setLong(valuei, refsqlId);
            valuei++;
        }
        if (lineAttrTable != null) {
            Iterator attri = lineAttrTable.getAttributes();
            while (attri.hasNext()) {
                AttributeDef lineattr = (AttributeDef) attri.next();
                valuei = recConv.addAttrValue(iomObj, ili2sqlName.mapGeometryAsTable(attrDef), sqlId, sqlTableName, ps, valuei, lineattr, null);
            }
        }
        if (createStdCols) {
            // T_LastChange
            ps.setTimestamp(valuei, today);
            valuei++;
            // T_CreateDate
            ps.setTimestamp(valuei, today);
            valuei++;
            // T_User
            ps.setString(valuei, dbusr);
            valuei++;
        }
        ps.executeUpdate();
    } finally {
        ps.close();
    }
}