/// <summary>
/// Initializes the table from a reader
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="origClass">The original class definition</param>
/// <param name="ignorePk">If true, will not convert the identity properties of the class definition to primary keys</param>
public void InitTable(IFdoReader reader, ClassDefinition origClass, bool ignorePk)
{
this.Columns.Clear();
this.TableName = reader.GetClassName();
string[] geometries = reader.GeometryProperties;
_geometryColumn = reader.DefaultGeometryProperty;
List<DataColumn> pk = new List<DataColumn>();
for (int i = 0; i < reader.FieldCount; i++)
{
string name = reader.GetName(i);
FdoPropertyType ptype = reader.GetFdoPropertyType(name);
if (ptype == FdoPropertyType.Raster)
{
//Raster's can't conceivably be previewed in tabular form, so omit it
}
else if (ptype == FdoPropertyType.Object)
{
// because the original code used an iterator over the reader.FieldCount
// it is a bit of a hack to get another definition of the class and check
// we are at the right property with a name comparison
// TODO: code review to see if this can be implemented better
FdoFeatureReader readerFeature = (FdoFeatureReader)reader;
ClassDefinition classDef = readerFeature.GetClassDefinition();
foreach (PropertyDefinition propertyDef in classDef.Properties)
{
// only looking for the right association
if ((PropertyType.PropertyType_ObjectProperty == propertyDef.PropertyType)
&& (propertyDef.Name.Equals(name)))
{
ObjectPropertyDefinition objectProp = (ObjectPropertyDefinition)propertyDef;
ClassDefinition classDefObject = objectProp.Class;
// TODO: this should be an iterative function?
foreach (PropertyDefinition propertyDefObject in classDefObject.Properties)
{
String nameObject = propertyDefObject.Name;
// TODO: find a better way to convert types
Type type = "".GetType();
// TODO: handle data and iterative associations and objects
if (PropertyType.PropertyType_DataProperty == propertyDefObject.PropertyType)
{
DataPropertyDefinition datapropertyDefObject = (DataPropertyDefinition)propertyDefObject;
DataType ptAssoc = datapropertyDefObject.DataType;
switch (ptAssoc)
{
case DataType.DataType_String:
type = "".GetType();
break;
}
DataColumn dc = this.Columns.Add(name + "." + nameObject, type);
}
else if (PropertyType.PropertyType_GeometricProperty == propertyDefObject.PropertyType)
{
type = typeof(FdoGeometry);
DataColumn dc = this.Columns.Add(name + "." + nameObject, type);
}
}
}
}
}
else if (ptype == FdoPropertyType.Association)
{
// because the original code used an iterator over the reader.FieldCount
// it is a bit of a hack to get another definition of the class and check
// we are at the right property with a name comparison
// TODO: code review to see if this can be implemented better
FdoFeatureReader readerFeature = (FdoFeatureReader)reader;
ClassDefinition classDef = readerFeature.GetClassDefinition();
foreach (PropertyDefinition propertyDef in classDef.Properties)
{
// only looking for the right association
if ((PropertyType.PropertyType_AssociationProperty == propertyDef.PropertyType)
&& (propertyDef.Name.Equals(name)))
{
AssociationPropertyDefinition assocProp = (AssociationPropertyDefinition)propertyDef;
ClassDefinition classDefAssoc = assocProp.AssociatedClass;
// TODO: this should be an iterative function?
foreach (PropertyDefinition propertyDefAssoc in classDefAssoc.Properties)
{
String nameAssoc = propertyDefAssoc.Name;
// TODO: find a better way to convert types
Type type = typeof(String);
// TODO: handle data and iterative associations and objects
if (PropertyType.PropertyType_DataProperty == propertyDefAssoc.PropertyType)
{
DataPropertyDefinition datapropertyDefAssoc = (DataPropertyDefinition)propertyDefAssoc;
DataType ptAssoc = datapropertyDefAssoc.DataType;
switch (ptAssoc)
{
case DataType.DataType_String:
type = typeof(String);
break;
}
DataColumn dc = this.Columns.Add(name + "." + nameAssoc, type);
}
else if (PropertyType.PropertyType_GeometricProperty == propertyDefAssoc.PropertyType)
{
type = typeof(FdoGeometry);
DataColumn dc = this.Columns.Add(name + "." + nameAssoc, type);
}
}
}
}
}
else
{
Type type = reader.GetFieldType(i);
if (Array.IndexOf<string>(geometries, name) >= 0)
{
type = typeof(FdoGeometry);
string assoc = reader.GetSpatialContextAssociation(name);
if (!string.IsNullOrEmpty(assoc))
this.RequestSpatialContext(this, assoc);
}
DataColumn dc = this.Columns.Add(name, type);
if (origClass != null)
{
//HACK: If this query is the result of the join, the returned Class Definition may have some
//fubar constraints applied to it. So use the original Class Definition
var idProps = origClass.IdentityProperties;
if (ptype != FdoPropertyType.Geometry && idProps.Contains(name))
{
pk.Add(dc);
}
}
else
{
if (ptype != FdoPropertyType.Geometry && reader.IsIdentity(name))
{
pk.Add(dc);
}
}
}
}
if (pk.Count > 0 && !ignorePk)
{
this.PrimaryKey = pk.ToArray();
}
}
void DoWork(object sender, DoWorkEventArgs e)
{
IFdoReader reader = null;
using (FdoFeatureService service = _connection.CreateFeatureService())
{
try
{
if (e.Argument is FeatureAggregateOptions)
{
reader = service.SelectAggregates((FeatureAggregateOptions)e.Argument);
}
else if (e.Argument is StandardQuery)
{
var stdArg = (e.Argument as StandardQuery);
reader = service.SelectFeatures(stdArg.query, stdArg.Limit, stdArg.UseExtendedSelect);
}
else if (e.Argument is string)
{
reader = service.ExecuteSQLQuery(e.Argument.ToString());
}
//Init the data grid view
FdoFeatureTable table = new FdoFeatureTable();
table.RequestSpatialContext += delegate(object o, string name)
{
SpatialContextInfo c = service.GetSpatialContext(name);
if (c != null)
{
table.AddSpatialContext(c);
}
};
ClassDefinition clsDef = null;
bool hasJoins = false;
if (e.Argument is StandardQuery)
{
var qry = ((StandardQuery)e.Argument).query;
clsDef = service.GetClassByName(qry.ClassName); //TODO: Should really qualify this, but our input parameters do not specify a schema
hasJoins = qry.JoinCriteria.Count > 0;
}
table.InitTable(reader, clsDef, hasJoins);
// need to store object class defn outside loop
ClassDefinition classDefObject = null;
ClassDefinition classDefAssoc = null;
while (reader.ReadNext() && !_queryWorker.CancellationPending)
{
//Pass processed feature to data grid view
FdoFeature feat = table.NewRow();
for (int i = 0; i < reader.FieldCount; i++)
{
string name = reader.GetName(i);
if (!reader.IsNull(name))
{
FdoPropertyType pt = reader.GetFdoPropertyType(name);
switch (pt)
{
case FdoPropertyType.Association:
// TODO: how to handle for non-StandardQuery
if (e.Argument is StandardQuery)
{
// because the original code used an iterator over the reader.FieldCount
// it is a bit of a hack to get another definition of the class and check
// we are at the right property with a name comparison
// TODO: code review to see if this can be implemented better
FdoFeatureReader readerFeature = (FdoFeatureReader)reader;
ClassDefinition classDef = readerFeature.GetClassDefinition();
foreach (PropertyDefinition propertyDef in classDef.Properties)
{
// only looking for the right association
if ((PropertyType.PropertyType_AssociationProperty == propertyDef.PropertyType) &&
(propertyDef.Name.Equals(name)))
{
AssociationPropertyDefinition assocProp = (AssociationPropertyDefinition)propertyDef;
ClassDefinition classAssoc = assocProp.AssociatedClass;
// get a reader from the association - nice!
IFeatureReader readerAssoc = readerFeature.GetFeatureObject(name);
if ((null != readerAssoc) && (readerAssoc.ReadNext()))
{
// TODO: this should be an iterative function
// the simple reassignment on each instance fails
// (classDefObject.Properties is always zero after first record)
// so have set classDefObject higher-up and re-use/
// - problem will occur if more than one association
// ClassDefinition classDefObject = readerObject.GetClassDefinition();
if (null == classDefAssoc)
{
classDefAssoc = readerAssoc.GetClassDefinition();
}
foreach (PropertyDefinition propertyDefAssoc in classDefAssoc.Properties)
{
String nameAssoc = propertyDefAssoc.Name;
// TODO: only "data" type handled at present
if (PropertyType.PropertyType_DataProperty == propertyDefAssoc.PropertyType)
{
DataPropertyDefinition datapropertyDefAssoc = (DataPropertyDefinition)propertyDefAssoc;
String szFullName = name + "." + nameAssoc;
DataType ptAssoc = datapropertyDefAssoc.DataType;
// TODO: handle all types
switch (ptAssoc)
{
case DataType.DataType_String:
feat[szFullName] = readerAssoc.GetString(nameAssoc);
break;
case DataType.DataType_Int16:
feat[szFullName] = readerAssoc.GetInt16(nameAssoc);
break;
case DataType.DataType_Int32:
feat[szFullName] = readerAssoc.GetInt32(nameAssoc);
break;
case DataType.DataType_Int64:
feat[szFullName] = readerAssoc.GetInt64(nameAssoc);
break;
}
}
}
readerAssoc.Close();
}
}
}
}
break;
case FdoPropertyType.BLOB:
feat[name] = reader.GetLOB(name).Data;
break;
case FdoPropertyType.Boolean:
feat[name] = reader.GetBoolean(name);
break;
case FdoPropertyType.Byte:
feat[name] = reader.GetByte(name);
break;
case FdoPropertyType.CLOB:
feat[name] = reader.GetLOB(name).Data;
break;
case FdoPropertyType.DateTime:
{
try
{
feat[name] = reader.GetDateTime(name);
}
catch //Unrepresentable dates
{
feat[name] = DBNull.Value;
}
}
break;
case FdoPropertyType.Decimal: //We should probably remove this as FDO coerces decimals to doubles (otherwise why is there not a GetDecimal() method in FdoIReader?)
{
double val = reader.GetDouble(name);
if (Double.IsNaN(val))
{
feat[name] = DBNull.Value;
}
else
{
feat[name] = Convert.ToDecimal(val);
}
}
break;
case FdoPropertyType.Double:
feat[name] = reader.GetDouble(name);
break;
case FdoPropertyType.Geometry:
{
try
{
byte[] fgf = reader.GetGeometry(name);
OSGeo.FDO.Geometry.IGeometry geom = service.GeometryFactory.CreateGeometryFromFgf(fgf);
var fg = new FdoGeometry(geom);
//OGR geometry trap
using (var env = fg.Envelope) { }
feat[name] = fg;
}
catch
{
feat[name] = DBNull.Value;
}
}
break;
case FdoPropertyType.Int16:
feat[name] = reader.GetInt16(name);
break;
case FdoPropertyType.Int32:
feat[name] = reader.GetInt32(name);
break;
case FdoPropertyType.Int64:
feat[name] = reader.GetInt64(name);
break;
case FdoPropertyType.Object:
// TODO: how to handle for non-StandardQuery
if (e.Argument is StandardQuery)
{
// because the original code used an iterator over the reader.FieldCount
// it is a bit of a hack to get another definition of the class and check
// we are at the right property with a name comparison
// TODO: code review to see if this can be implemented better
FdoFeatureReader readerFeature = (FdoFeatureReader)reader;
ClassDefinition classDef = readerFeature.GetClassDefinition();
foreach (PropertyDefinition propertyDef in classDef.Properties)
{
// only looking for the right object
if ((PropertyType.PropertyType_ObjectProperty == propertyDef.PropertyType) &&
(propertyDef.Name.Equals(name)))
{
ObjectPropertyDefinition assocProp = (ObjectPropertyDefinition)propertyDef;
ClassDefinition classAssoc = assocProp.Class;
// get a reader from the object - nice!
IFeatureReader readerObject = readerFeature.GetFeatureObject(name);
if ((null != readerObject) && (readerObject.ReadNext()))
{
// TODO: this should be an iterative function
// the simple reassignment on each instance fails
// (classDefObject.Properties is always zero after first record)
// so have set classDefObject higher-up and re-use/
// - problem will occur if more than one association
// ClassDefinition classDefObject = readerObject.GetClassDefinition();
if (null == classDefObject)
{
classDefObject = readerObject.GetClassDefinition();
}
foreach (PropertyDefinition propertyDefObject in classDefObject.Properties)
{
String nameObject = propertyDefObject.Name;
// TODO: only "data" type handled at present
if (PropertyType.PropertyType_DataProperty == propertyDefObject.PropertyType)
{
DataPropertyDefinition datapropertyDefObject = (DataPropertyDefinition)propertyDefObject;
String szFullName = name + "." + nameObject;
DataType ptAssoc = datapropertyDefObject.DataType;
// TODO: handle all types
switch (ptAssoc)
{
case DataType.DataType_String:
feat[szFullName] = readerObject.GetString(nameObject);
break;
case DataType.DataType_Int16:
feat[szFullName] = readerObject.GetInt16(nameObject);
break;
case DataType.DataType_Int32:
feat[szFullName] = readerObject.GetInt32(nameObject);
break;
case DataType.DataType_Int64:
feat[szFullName] = readerObject.GetInt64(nameObject);
break;
}
}
}
readerObject.Close();
readerObject = null;
}
}
}
}
break;
//case FdoPropertyType.Raster:
case FdoPropertyType.Single:
feat[name] = reader.GetSingle(name);
break;
case FdoPropertyType.String:
feat[name] = reader.GetString(name);
break;
}
}
else
{
feat[name] = DBNull.Value;
}
}
table.AddRow(feat);
if (table.Rows.Count % 50 == 0)
{
System.Threading.Thread.Sleep(50);
}
}
if (_queryWorker.CancellationPending)
{
e.Cancel = true;
_cancelResult = table;
}
else
{
e.Result = table;
}
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
}
/// <summary>
/// Initializes the table from a reader
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="origClass">The original class definition</param>
/// <param name="ignorePk">If true, will not convert the identity properties of the class definition to primary keys</param>
public void InitTable(IFdoReader reader, ClassDefinition origClass, bool ignorePk)
{
this.Columns.Clear();
this.TableName = reader.GetClassName();
string[] geometries = reader.GeometryProperties;
_geometryColumn = reader.DefaultGeometryProperty;
List <DataColumn> pk = new List <DataColumn>();
for (int i = 0; i < reader.FieldCount; i++)
{
string name = reader.GetName(i);
FdoPropertyType ptype = reader.GetFdoPropertyType(name);
if (ptype == FdoPropertyType.Raster)
{
//Raster's can't conceivably be previewed in tabular form, so omit it
}
else if (ptype == FdoPropertyType.Object)
{
// because the original code used an iterator over the reader.FieldCount
// it is a bit of a hack to get another definition of the class and check
// we are at the right property with a name comparison
// TODO: code review to see if this can be implemented better
FdoFeatureReader readerFeature = (FdoFeatureReader)reader;
ClassDefinition classDef = readerFeature.GetClassDefinition();
foreach (PropertyDefinition propertyDef in classDef.Properties)
{
// only looking for the right association
if ((PropertyType.PropertyType_ObjectProperty == propertyDef.PropertyType) &&
(propertyDef.Name.Equals(name)))
{
ObjectPropertyDefinition objectProp = (ObjectPropertyDefinition)propertyDef;
ClassDefinition classDefObject = objectProp.Class;
// TODO: this should be an iterative function?
foreach (PropertyDefinition propertyDefObject in classDefObject.Properties)
{
String nameObject = propertyDefObject.Name;
// TODO: find a better way to convert types
Type type = "".GetType();
// TODO: handle data and iterative associations and objects
if (PropertyType.PropertyType_DataProperty == propertyDefObject.PropertyType)
{
DataPropertyDefinition datapropertyDefObject = (DataPropertyDefinition)propertyDefObject;
DataType ptAssoc = datapropertyDefObject.DataType;
switch (ptAssoc)
{
case DataType.DataType_String:
type = "".GetType();
break;
}
DataColumn dc = this.Columns.Add(name + "." + nameObject, type);
}
else if (PropertyType.PropertyType_GeometricProperty == propertyDefObject.PropertyType)
{
type = typeof(FdoGeometry);
DataColumn dc = this.Columns.Add(name + "." + nameObject, type);
}
}
}
}
}
else if (ptype == FdoPropertyType.Association)
{
// because the original code used an iterator over the reader.FieldCount
// it is a bit of a hack to get another definition of the class and check
// we are at the right property with a name comparison
// TODO: code review to see if this can be implemented better
FdoFeatureReader readerFeature = (FdoFeatureReader)reader;
ClassDefinition classDef = readerFeature.GetClassDefinition();
foreach (PropertyDefinition propertyDef in classDef.Properties)
{
// only looking for the right association
if ((PropertyType.PropertyType_AssociationProperty == propertyDef.PropertyType) &&
(propertyDef.Name.Equals(name)))
{
AssociationPropertyDefinition assocProp = (AssociationPropertyDefinition)propertyDef;
ClassDefinition classDefAssoc = assocProp.AssociatedClass;
// TODO: this should be an iterative function?
foreach (PropertyDefinition propertyDefAssoc in classDefAssoc.Properties)
{
String nameAssoc = propertyDefAssoc.Name;
// TODO: find a better way to convert types
Type type = typeof(String);
// TODO: handle data and iterative associations and objects
if (PropertyType.PropertyType_DataProperty == propertyDefAssoc.PropertyType)
{
DataPropertyDefinition datapropertyDefAssoc = (DataPropertyDefinition)propertyDefAssoc;
DataType ptAssoc = datapropertyDefAssoc.DataType;
switch (ptAssoc)
{
case DataType.DataType_String:
type = typeof(String);
break;
}
DataColumn dc = this.Columns.Add(name + "." + nameAssoc, type);
}
else if (PropertyType.PropertyType_GeometricProperty == propertyDefAssoc.PropertyType)
{
type = typeof(FdoGeometry);
DataColumn dc = this.Columns.Add(name + "." + nameAssoc, type);
}
}
}
}
}
else
{
Type type = reader.GetFieldType(i);
if (Array.IndexOf <string>(geometries, name) >= 0)
{
type = typeof(FdoGeometry);
string assoc = reader.GetSpatialContextAssociation(name);
if (!string.IsNullOrEmpty(assoc))
{
this.RequestSpatialContext(this, assoc);
}
}
DataColumn dc = this.Columns.Add(name, type);
if (origClass != null)
{
//HACK: If this query is the result of the join, the returned Class Definition may have some
//fubar constraints applied to it. So use the original Class Definition
var idProps = origClass.IdentityProperties;
if (ptype != FdoPropertyType.Geometry && idProps.Contains(name))
{
pk.Add(dc);
}
}
else
{
if (ptype != FdoPropertyType.Geometry && reader.IsIdentity(name))
{
pk.Add(dc);
}
}
}
}
if (pk.Count > 0 && !ignorePk)
{
this.PrimaryKey = pk.ToArray();
}
}