English

How To: Display table records based on feature entity type

Summary

The script below allows a selection of table records associated with the selected entity types. The user will be prompted to select one or many entity types available in the selected table.

SDE stores entity types for shapes in a layer's F table. The F table has a one-to-one correlation with the business table and contains the shape itself, the entity type for each shape, and SE_ROW_ID, which is accessible directly through DBAccess. The entity type is represented numerically and can be one of the following 11 options:

NIL_SHAPE 0
POINT_SHAPE 1
LINE_SHAPE 2
SIMPLE_LINE_SHAPE 4
AREA_SHAPE 8
SHAPE_CLASS_MASK 255
SHAPE_MULTI_PART_MASK 256
MULTI_POINT_SHAPE 257
MULTI_LINE_SHAPE 258
MULTI_SIMPLE_LINE_SHAPE 260
MULTI_AREA_SHAPE 264

Procedure

  1. Open a new script window.

    A. Activate the Project window.
    B. Click the Scripts icon.
    C. Click New.

  2. Copy the code into the new script window.

    Code:
    '--SCRIPT ENT_SEL.AVE
    '
    ' make the connection and get the fields from the table
    ' server: abbey, user: avtest, table: REXXSTATES
    ' THE USER WILL NEED to CHANGE THE CONNECTION STRING AND tableNAME ONLY
    ' THE tableNAME MUST BE CAPITALIZED
    '
    THECONNECTION = sdeconnection.make("abbey","","avtest","avtest")
    THETABNAME = "REXXSTATES"
    thetable = sdetable.make(theconnection, "avtest."+thetabname)
    theflds = thetable.getfields
    '
    ' make the querydef, clone it, and add the SE_ROW_ID field to the select
    columns which
    ' specifies the unique feature id for each shape in the SDE layer
    qd1 = querydef.make(theconnection)
    qd = qd1.clone
    qd.setfromtables({"avtest."+thetabname})
    se_id = "SE_ROW_ID"
    theflds.add(se_id)
    qd.setselectcolumns(theflds)
    qd.setwhereclause("")
    '
    ' query the LAYERS table owned by the sde admin
    qd3 = querydef.make(theconnection)
    qd2 = qd3.clone
    qd2.setfromtables({"sde.layers"})
    qd2.setselectcolumns({"layers.LAYER_ID", "layers.table_NAME"})
    qd2.setwhereclause("table_NAME = '"+thetabname+"'")
    '
    ' create a list that contains the layer id for the selected table
    lvlist = list.make
    rs2 = qd2.openrecordset
    layfld = rs2.findfield("LAYER_ID")
    while (rs2.next)
    lv = rs2.getvalue(layfld).clone
    lvlist.add(lv)
    end
    rs2.close
    '
    ' query the F table for the selected table to get the entity types
    qd5 = querydef.make(theconnection)
    qd4 = qd5.clone
    ftablename = "F"+ lvlist.get(0).asstring
    qd4.setfromtables({ftablename})
    qd4.setselectcolumns({"ENTITY"})
    qd4.setwhereclause("")
    '
    ' get the entity codes... see dictionary below for reference
    entlist1 = list.make
    rs3 = qd4.openrecordset
    entfld = rs3.findfield("ENTITY")
    while (rs3.next)
    ev = rs3.getvalue(entfld).clone
    entlist1.add(ev)
    end
    rs3.close
    entlist1.removeduplicates
    '
    ' create dictionary to associate entity codes with appropriate text
    thedict = dictionary.make(24)
    thedict.add(0, {"NIL"})
    thedict.add(1, {"POINT"})
    thedict.add(2, {"LINE"})
    thedict.add(4, {"SIMPLE LINE"})
    thedict.add(8, {"POLYGON"})
    thedict.add(255, {"MASK"})
    thedict.add(256, {"MULTI MASK"})
    thedict.add(257, {"MULTI POINT"})
    thedict.add(258, {"MULTI LINE"})
    thedict.add(260, {"MULTI SIMPLE LINE"})
    thedict.add(264, {"MULTI POLYGON"})
    thedict.add("NIL", {0})
    thedict.add("POINT", {1})
    thedict.add("LINE", {2})
    thedict.add("SIMPLE LINE", {4})
    thedict.add("POLYGON", {8})
    thedict.add("MASK", {255})
    thedict.add("MULTI MASK", {256})
    thedict.add("MULTI POINT", {257})
    thedict.add("MULTI LINE", {258})
    thedict.add("MULTI SIMPLE LINE", {260})
    thedict.add("MULTI POLYGON", {264})
    '
    ' get values from dictionary
    msglist = list.make
    for each et in entlist1
    ev = thedict.get(et).get(0).clone
    msglist.add(ev)
    end

    thekeys = msgbox.multilistasstring(msglist, "Select feature types","SDE")

    thesellist = list.make
    for each ll in thekeys
    dv = thedict.get(ll).get(0).clone
    thesellist.add(dv)
    end
    '
    ' query the F table and put all the unique feature ids that are associated
    with
    ' the selected entity type into a list
    loglist = list.make
    qd7 = querydef.make(theconnection)
    qd6 = qd7.clone
    ftablename1 = "F"+ lv.asstring
    qd6.setfromtables({ftablename1})
    qd6.setselectcolumns({"FID","ENTITY"})
    qd6.setwhereclause("")

    rs4 = qd6.openrecordset
    entfld1 = rs4.findfield("ENTITY")
    shpidfld1 = rs4.findfield("FID")
    while (rs4.next)
    shv = rs4.getvalue(shpidfld1).clone
    ev11 = rs4.getvalue(entfld1).clone
    if (thesellist.findbyvalue(ev11) >= 0) then
    loglist.add(shv)
    else
    end
    end
    rs4.close
    '
    ' create a log file (selection file), you will write selected features to
    this
    file
    alogname = sdelog.makelogname(theconnection)
    alogfile = sdelog.make(theconnection, alogname, "avtest."+thetabname,
    #SDELOG_MODE_CREATE)
    '
    ' open the recordset and step through it, select features based on selected
    entity type
    rs = qd.openrecordset
    theidfld = rs.findfield("SE_ROW_ID")
    while (rs.next)
    v = rs.getvalue(theidfld).clone
    if (loglist.findbyvalue(v) >= 0) then
    id = rs.getvalue(theidfld).clone
    alogfile.addfeature(id)
    else
    end
    end
    rs.close
    qd.setsrcdest(alogfile, nil, false)
    thetable = dbtable.make(qd)
    thetable.getwin.open
    av.purgeobjects
    '-- END OF SCRIPT

  3. Compile the script by clicking the compile button.
    [O-Image] Script compile button
  4. Run the script by clicking the run button.
    [O-Image] Run compiled script button
    Note:
    Using the GetClass.GetClassName request on each shape will only return polygon, polyline, or multipoint and may not accurately represent the features. For example, annotation is multipoint with GetClass.GetClassName but is actually stored as a line in SDE.

Related Information