private string GenerateFilter(FdoFeature feat)
        {
            FdoFeatureTable table = feat.Table;

            if (table.PrimaryKey.Length > 0)
            {
                List <string> filters = new List <string>();
                foreach (DataColumn col in table.PrimaryKey)
                {
                    DataType dt = ExpressUtility.GetFdoDataTypeFromClrType(col.DataType);
                    string   f  = string.Empty;
                    if (dt == DataType.DataType_DateTime || dt == DataType.DataType_String)
                    {
                        f = col.ColumnName + " = '" + feat[col] + "'";
                    }
                    else
                    {
                        f = col.ColumnName + " = " + feat[col];
                    }

                    filters.Add(f);
                }
                return("(" + string.Join(" AND ", filters.ToArray()) + ")");
            }
            return(null);
        }
Пример #2
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);
                }
            }
        }
        internal string GenerateFilter(FdoFeature[] features)
        {
            if (features == null || features.Length == 0)
            {
                return(null);
            }

            FdoFeatureTable table = features[0].Table;

            //All features in array must originate from the same table
            for (int i = 1; i < features.Length; i++)
            {
                if (features[i].Table != table)
                {
                    return(null);
                }
            }

            List <string> filter = new List <string>();

            foreach (FdoFeature feat in features)
            {
                filter.Add(GenerateFilter(feat));
            }

            return(string.Join(" OR ", filter.ToArray()));
        }
Пример #4
0
        private void saveSQLite_Click(object sender, EventArgs e)
        {
            FdoFeatureTable table = this.ResultTable;

            if (table == null || table.Rows.Count == 0)
            {
                this.ShowError(ResourceService.GetString("ERR_NO_RESULT_TABLE_TO_SAVE"));
                return;
            }
            string file = FileService.SaveFile(ResourceService.GetString("TITLE_SAVE_QUERY_RESULT"), ResourceService.GetString("FILTER_SQLITE"));

            SaveQueryResult(table, file);
        }
        void RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            _view.SetBusyCursor(false);
            _timer.Stop();
            _view.CancelEnabled  = false;
            _view.ClearEnabled   = true;
            _view.ExecuteEnabled = true;

            if (e.Error != null)
            {
                _view.DisplayError(e.Error);
            }
            else
            {
                FdoFeatureTable result = null;
                if (e.Cancelled)
                {
                    result = _cancelResult;
                }
                else
                {
                    result = e.Result as FdoFeatureTable;
                }

                if (result != null)
                {
                    _view.ResultTable = result;
                    if (e.Cancelled)
                    {
                        _view.StatusMessage = string.Format("Query cancelled. Returned {0} results", result.Rows.Count);
                    }
                    else
                    {
                        _view.StatusMessage = string.Format("Returned {0} results", result.Rows.Count);
                    }
                }
                else //No result table
                {
                    if (e.Cancelled)
                    {
                        _view.StatusMessage = "Query cancelled";
                    }
                    else
                    {
                        _view.StatusMessage = string.Format("0 results");
                    }
                }
            }
        }
        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");
                }
            }
        }
Пример #7
0
 /// <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;
 }
Пример #8
0
 /// <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;
 }
        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 a new instance of the <see cref="FdoFeatureTableInputOperation"/> class.
 /// </summary>
 /// <param name="table">The table.</param>
 public FdoFeatureTableInputOperation(FdoFeatureTable table)
 {
     _table = table;
 }