Ejemplo n.º 1
0
        /// <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();
                    }
                }
            }
        }
Ejemplo n.º 3
0
        /// <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();
            }
        }