internal void TestUpdate()
 {
     using (FdoFeatureService service = _conn.CreateFeatureService())
     {
         long count = service.GetFeatureCount(_className, _view.Filter, true);
         _view.ShowMessage(null, count + " feature(s) would be updated");
     }
 }
        internal void DoUpdate(FdoFeature feat)
        {
            FeatureQueryOptions query = null;

            switch (_view.SelectedQueryMode)
            {
            case QueryMode.Aggregate:
            {
                query = (_view.QueryView as IFdoAggregateQueryView).QueryObject;
            }
            break;

            case QueryMode.Standard:
            {
                query = (_view.QueryView as IFdoStandardQueryView).QueryObject;
            }
            break;
            }
            if (query != null)
            {
                string filter = GenerateFilter(feat);
                if (string.IsNullOrEmpty(filter))
                {
                    _view.ShowError("Unable to generate an update filter. Possibly this result set has no unique identifiers or this result set was produced from a SQL query");
                    return;
                }
                using (FdoFeatureService service = _connection.CreateFeatureService())
                {
                    //Update is based on a very simple premise, the filter should produce the
                    //same number of affected results when selecting and updating.
                    //
                    //In our case, the filter should affect exactly one result when selecting and updating.
                    long count = service.GetFeatureCount(feat.Table.TableName, filter, true);
                    if (1 == count)
                    {
                        Workbench         wb  = Workbench.Instance;
                        FdoUpdateScaffold ctl = new FdoUpdateScaffold(feat, _connection, filter);
                        wb.ShowContent(ctl, ViewRegion.Dialog);
                    }
                }
            }
            else
            {
                _view.ShowError("Could not determine the feature class name from the result set");
            }
        }
        public long GetFeatureCount()
        {
            IFdoStandardQueryView qv = _view.QueryView as IFdoStandardQueryView;

            if (qv == null)
            {
                return(0);
            }

            ClassDefinition classDef = qv.SelectedClassDefinition;
            var             query    = qv.QueryObject;

            //Can't count joins (yet)
            if (query.JoinCriteria.Count > 0)
            {
                return(0);
            }

            return(_service.GetFeatureCount(classDef, query.Filter, false));
        }
        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");
                }
            }
        }