A FDO-friendly DataTable
Inheritance: System.Data.DataTable, IEnumerable
示例#1
0
        /// <summary>
        /// Clones this table
        /// </summary>
        /// <returns></returns>
        public new FdoFeatureTable Clone()
        {
            FdoFeatureTable tbl = ((FdoFeatureTable)(base.Clone()));

            tbl.InitVars();
            return(tbl);
        }
        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();
                }
            }
        }
        private void DeleteFeatures(FdoFeatureTable table, FdoFeature[] features)
        {
            string filter = GenerateFilter(features);
            if (string.IsNullOrEmpty(filter))
            {
                _view.ShowError("Unable to generate a delete filter. Possibly this result set has no unique identifiers or this result set was produced from a SQL query. If this result set is produced from a standard query, make sure that *ALL* identity properties are selected");
                return;
            }

            int expectedCount = features.Length;
            using (FdoFeatureService service = _connection.CreateFeatureService())
            {
                //Deleting is based on a very simple premise, the filter should produce the
                //same number of affected results when selecting and deleting.
                //
                //In our case, the filter should affect exactly the expected number of results when selecting and deleting.
                long count = service.GetFeatureCount(table.TableName, filter, true);
                if (expectedCount == count)
                {
                    int deleted = service.DeleteFeatures(table.TableName, filter, true);
                    if (expectedCount == deleted)
                    {
                        foreach (FdoFeature feat in features)
                        {
                            table.Rows.Remove(feat);
                        }
                        _view.ShowMessage("Delete Feature", "Feature Deleted");
                    }
                }
                else if (count > expectedCount)
                {
                    _view.ShowError("Delete operation would delete more than the expected number of features (" + expectedCount + ")");
                }
                else if (count == 0)
                {
                    _view.ShowError("Delete operation would not delete any features");
                }
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="FdoFeatureTableInputOperation"/> class.
 /// </summary>
 /// <param name="table">The table.</param>
 public FdoFeatureTableInputOperation(FdoFeatureTable table)
 {
     _table = table;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="TableToFlatFile"/> class.
 /// </summary>
 /// <param name="table">The table.</param>
 /// <param name="file">The file.</param>
 /// <param name="reportFrequency">The report frequency.</param>
 public TableToFlatFile(FdoFeatureTable table, string file, int reportFrequency)
     : this(table, file)
 {
     _ReportFrequency = reportFrequency;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="TableToFlatFile"/> class.
 /// </summary>
 /// <param name="table">The table.</param>
 /// <param name="file">The file.</param>
 public TableToFlatFile(FdoFeatureTable table, string file)
 {
     _table = table;
     _outputFile = file;
 }
示例#7
0
        private static void SaveQueryResult(FdoFeatureTable table, string file)
        {
            if (!string.IsNullOrEmpty(file))
            {
                //Ask for class name
                if (string.IsNullOrEmpty(table.TableName))
                {
                    string name = MessageService.ShowInputBox(ResourceService.GetString("TITLE_SAVE_QUERY_AS"), ResourceService.GetString("MSG_SAVE_QUERY_AS"), "QueryResult");
                    while (name != null && name.Trim() == string.Empty)
                        name = MessageService.ShowInputBox(ResourceService.GetString("TITLE_SAVE_QUERY_AS"), ResourceService.GetString("MSG_SAVE_QUERY_AS"), "QueryResult");

                    if (name == null)
                        return;

                    table.TableName = name;
                }

                using (TableToFlatFile proc = new TableToFlatFile(table, file))
                {
                    EtlProcessCtl ctl = new EtlProcessCtl(proc);
                    Workbench.Instance.ShowContent(ctl, ViewRegion.Dialog);
                }
            }
        }