private void FillUniqueValues()
{
if (_tc == null)
{
return;
}
lstUniqueValues.Items.Clear();
if (lstFields.SelectedItem == null)
{
return;
}
string colName = lstFields.SelectedItem.ToString();
colName = colName.Replace("[", String.Empty).Replace("]", String.Empty); // Joined Fields
IField field = _tc.FindField(colName);
if (field == null)
{
return;
}
List <string> list;
if (_values.TryGetValue(colName, out list))
{
foreach (string val in list)
{
if (field.type == FieldType.String)
{
lstUniqueValues.Items.Add("'" + val + "'");
}
else
{
lstUniqueValues.Items.Add(val);
}
}
}
else
{
foreach (DataRow row in _table.Table.Select("", colName))
{
string val = row[colName].ToString();
if (field.type == FieldType.String)
{
val = "'" + val + "'";
}
if (lstUniqueValues.Items.IndexOf(val) != -1)
{
continue;
}
lstUniqueValues.Items.Add(val);
}
}
}
public FormSelectFields(ITableClass tcFrom, ITableClass tcTo)
{
InitializeComponent();
if (tcFrom == null || tcTo == null ||
tcFrom.Fields == null || tcTo.Fields == null)
{
return;
}
foreach (IField field in tcFrom.Fields.ToEnumerable())
{
if (field == null ||
field.type == FieldType.ID || field.type == FieldType.Shape ||
tcTo.FindField(field.name) != null)
{
continue;
}
lstBox.Items.Add(new FieldItem(field), true);
}
}
public static bool ModifyFilter(IServiceMap map, ITableClass tClass, IQueryFilter filter)
{
if (filter == null || tClass == null)
{
return(false);
}
string subFields = filter.SubFields;
if (subFields != "*")
{
filter.SubFields = String.Empty;
foreach (string subField in subFields.Split(' '))
{
string fname = subField;
if (subFields.StartsWith(filter.fieldPrefix) &&
subFields.EndsWith(filter.fieldPostfix))
{
fname = fname.Substring(filter.fieldPrefix.Length, fname.Length - filter.fieldPrefix.Length - filter.fieldPostfix.Length);
}
if (tClass.Fields != null)
{
if (tClass.FindField(fname) != null ||
(tClass is IFeatureClass && ((IFeatureClass)tClass).ShapeFieldName == fname))
{
filter.AddField(fname);
}
}
}
}
try
{
XmlDocument xmlFilter = new XmlDocument();
string xml = Xml.ToXml(tClass, filter);
xmlFilter.LoadXml(xml);
XmlNodeList propertyNames = xmlFilter.SelectNodes("//PropertyName");
foreach (XmlNode propertyName in propertyNames)
{
if (propertyName.InnerText == MergedObjectIDName)
{
XmlNode literal = propertyName.ParentNode.SelectSingleNode("Literal");
if (literal == null)
{
return(false);
}
long mergedID;
if (!long.TryParse(literal.InnerText, out mergedID))
{
return(false);
}
int classID = GetClassID(map, tClass), propertyClassID = GetClassID(mergedID);
if (classID != propertyClassID)
{
propertyName.ParentNode.ParentNode.RemoveChild(propertyName.ParentNode);
continue;
}
propertyName.InnerText = tClass.IDFieldName;
literal.InnerText = GetObjectID(mergedID).ToString();
}
else if (tClass.Fields.FindField(propertyName.InnerText) == null)
{
propertyName.ParentNode.ParentNode.RemoveChild(
propertyName.ParentNode);
}
}
// keine Properties übgrig geblieben sind -> nicht abfraten...
if (propertyNames.Count > 0 && xmlFilter.SelectNodes("//PropertyName").Count == 0)
{
return(false);
}
IQueryFilter f = Xml.FromXml(tClass, xmlFilter.SelectSingleNode("Filter"));
// Prüfen, ob vom Filter noch was übrig bleibt...
if (!String.IsNullOrEmpty(filter.WhereClause) &&
String.IsNullOrEmpty(f.WhereClause))
{
return(false);
}
filter.WhereClause = f.WhereClause;
}
catch { return(false); }
return(true);
}
public SdeQueryInfo(ArcSdeConnection connection, ITableClass tc, IQueryFilter filter)
{
if (tc == null)
{
return;
}
try
{
if (filter is ISpatialFilter && ((ISpatialFilter)filter).Geometry != null && tc is IFeatureClass && tc.Dataset is SdeDataset)
{
SE_ENVELOPE maxExtent = new SE_ENVELOPE();
SE_COORDREF coordRef = ((SdeDataset)tc.Dataset).GetSeCoordRef(connection, tc.Name, ((IFeatureClass)tc).ShapeFieldName, ref maxExtent);
if (((SdeDataset)tc.Dataset).lastErrorMsg != "")
{
return;
}
_isSpatial = true;
_err_no = Wrapper92.SE_shape_create(coordRef, ref _shape);
((SdeDataset)tc.Dataset).FreeSeCoordRef(coordRef);
if (_err_no != 0)
{
return;
}
//IEnvelope env = ((ISpatialFilter)filter).Geometry.Envelope;
//SE_ENVELOPE seEnvelope = new SE_ENVELOPE();
//seEnvelope.minx = Math.Max(env.minx, maxExtent.minx);
//seEnvelope.miny = Math.Max(env.miny, maxExtent.miny);
//seEnvelope.maxx = Math.Min(env.maxx, maxExtent.maxx);
//seEnvelope.maxy = Math.Min(env.maxy, maxExtent.maxy);
//if (seEnvelope.minx == seEnvelope.maxx && seEnvelope.miny == seEnvelope.maxy)
//{
// /* fudge a rectangle so we have a valid one for generate_rectangle */
// /* FIXME: use the real shape for the query and set the filter_type
// to be an appropriate type */
// seEnvelope.minx = seEnvelope.minx - 0.001;
// seEnvelope.maxx = seEnvelope.maxx + 0.001;
// seEnvelope.miny = seEnvelope.miny - 0.001;
// seEnvelope.maxy = seEnvelope.maxy + 0.001;
//}
//_err_no = Wrapper92.SE_shape_generate_rectangle(ref seEnvelope, _shape);
_err_no = gView.SDEWrapper.Functions.SE_GenerateGeometry(_shape, ((ISpatialFilter)filter).Geometry, maxExtent);
if (_err_no != 0)
{
return;
}
_seFilter.shape = _shape;
/* set spatial constraint column and table */
_seFilter.table = tc.Name.PadRight(CONST.SE_QUALIFIED_TABLE_NAME, '\0');;
_seFilter.column = ((IFeatureClass)tc).ShapeFieldName.PadRight(CONST.SE_MAX_COLUMN_LEN, '\0');
/* set a couple of other spatial constraint properties */
_seFilter.method = (((ISpatialFilter)filter).SpatialRelation == spatialRelation.SpatialRelationEnvelopeIntersects) ? CONST.SM_ENVP_BY_GRID /*CONST.SM_AI*/ : CONST.SM_AI;
_seFilter.filter_type = CONST.SE_SHAPE_FILTER;
_seFilter.truth = true; // True;
}
_err_no = Wrapper92.SE_queryinfo_create(ref _queryInfo);
if (_err_no != 0)
{
return;
}
_err_no = Wrapper92.SE_queryinfo_set_tables(_queryInfo, 1, new string[] { tc.Name }, null);
if (_err_no != 0)
{
return;
}
string [] fields;
if (filter.SubFields == "" || filter.SubFields == "*" || filter.SubFields == null)
{
StringBuilder subFields = new StringBuilder();
foreach (IField field in tc.Fields.ToEnumerable())
{
if (subFields.Length != 0)
{
subFields.Append(" ");
}
subFields.Append(tc.Name + "." + field.name);
_queryFields.Add(field);
}
fields = subFields.ToString().Split(' ');
}
else
{
fields = filter.SubFields.Split(' ');
foreach (string fieldname in fields)
{
string fname = fieldname;
if (fieldname.ToLower().IndexOf("distinct(") == 0)
{
fname = fieldname.Substring(9, fieldname.IndexOf(")") - 9);
}
IField field = tc.FindField(fname);
if (field == null)
{
_errMsg = "Can't get Field " + fname;
Cleanup();
return;
}
_queryFields.Add(field);
}
}
_err_no = Wrapper92.SE_queryinfo_set_columns(_queryInfo, fields.Length, fields);
if (_err_no != 0)
{
return;
}
string where = "";
if (filter != null)
{
if (filter is IRowIDFilter)
{
where = ((IRowIDFilter)filter).RowIDWhereClause;
}
else
{
where = filter.WhereClause;
}
}
if (where != "")
{
_err_no = Wrapper92.SE_queryinfo_set_where_clause(_queryInfo, where);
if (_err_no != 0)
{
return;
}
}
_err_no = Wrapper92.SE_queryinfo_set_query_type(_queryInfo, CONST.SE_QUERYTYPE_JSFA);
if (_err_no != 0)
{
return;
}
}
catch (Exception ex)
{
_errMsg = "SeQueryInfo:" + ex.Message + "\n" + ex.StackTrace;
_err_no = -1;
}
finally
{
if (_err_no != 0)
{
_errMsg = Wrapper92.GetErrorMsg(new SE_CONNECTION(), _err_no);
Cleanup();
}
}
}
private static string ParseWFSFilterNode(ITableClass fc, XmlNode node, XmlNamespaceManager ns)
{
//if(fc==null)
// throw new ArgumentException("ParseWFSFilterNode: FeatureClass is null...");
if (node == null)
{
return(String.Empty);
}
string op = String.Empty;
switch (node.Name)
{
case "PropertyIsEqualTo":
op = "=";
break;
case "PropertyIsLike":
op = " like ";
break;
case "PropertyIsGreaterThan":
op = ">";
break;
case "PropertyIsGreaterThanOrEqualTo":
op = ">=";
break;
case "PropertyIsLessThan":
op = "<";
break;
case "PropertyIsLessThanOrEqualTo":
op = "<=";
break;
case "PropertyIsNotEqualTo":
op = "<>";
break;
default:
throw new Exception("Unknown operation: " + node.Name + ". Xml is case sensitive.");
}
XmlNodeList propertyName = (ns != null) ? node.SelectNodes("OGC:PropertyName", ns) : node.SelectNodes("PropertyName");
if (propertyName.Count > 1)
{
throw new Exception("More than one PropertyName in Property: " + node.OuterXml);
}
if (propertyName.Count == 0)
{
throw new Exception("No PropertyName in Property: " + node.OuterXml);
}
XmlNodeList Literal = (ns != null) ? node.SelectNodes("OGC:Literal", ns) : node.SelectNodes("Literal");
if (Literal.Count > 1)
{
throw new Exception("More than one Literal in Property: " + node.OuterXml);
}
if (Literal.Count == 0)
{
throw new Exception("No Literal in Property: " + node.OuterXml);
}
string fieldname = propertyName[0].InnerText;
string fieldvalue = Literal[0].InnerText;
if (fc != null)
{
IField field = fc.FindField(fieldname);
if (field == null)
{
throw new Exception("Type " + fc.Name + " do not has field " + fieldname);
}
switch (field.type)
{
case FieldType.String:
fieldvalue = "'" + fieldvalue + "'";
break;
case FieldType.Date:
fieldvalue = "'" + fieldvalue + "'";
break;
}
}
return(fieldname + op + fieldvalue);
}
