C# QueryFilter类代码示例

        public int AddAreaFieldToFeatureClass(String feature_class, String field_name)
        {
            try
            {

                IGPUtilities ipUtils = new GPUtilities();
                IFeatureClass ipFeatureClass;

                // Open FC
                try
                {
                    ipFeatureClass = ipUtils.OpenFeatureClassFromString(feature_class);
                }
                catch(Exception)
                {
                    return -1;
                }

                // Find field
                int fieldIndex;
                try
                {
                    fieldIndex = ipFeatureClass.FindField(field_name);
                }
                catch(Exception)
                {
                    return -2;
                }

                // Set up query and filter
                IQueryFilter ipFilter = new QueryFilter();
                IFeatureCursor ipCursor;
                IFeature ipRow;
                IGeometry ipShape;

                // Open cursor on feature class
                ipCursor = ipFeatureClass.Update(ipFilter, false);

                for (ipRow = ipCursor.NextFeature();
                     ipRow != null;
                     ipRow = ipCursor.NextFeature())
                {
                    ipShape = ipRow.ShapeCopy;
                    if (ipShape.GeometryType != esriGeometryType.esriGeometryPolygon)
                        return -3;

                    IArea ipArea = ipShape as IArea;
                    double area = ipArea.Area;
                    ipRow.Value[fieldIndex] = area;

                    ipRow.Store();
                }

                return 0;
            }
            catch (Exception)
            {
                return -4;
            }
        }

 public bool Delete(UUID ownerID, string friend)
 {
     QueryFilter filter = new QueryFilter();
     filter.andFilters["PrincipalID"] = ownerID;
     filter.andFilters["Friend"] = friend;
     return GD.Delete(m_realm, filter);
 }

        public FriendInfo[] GetFriends(UUID principalID)
        {
            List<FriendInfo> infos = new List<FriendInfo>();

            QueryTables tables = new QueryTables();
            tables.AddTable(m_realm, "my");
            tables.AddTable(m_realm, "his", JoinType.Inner,
                            new[,] {{"my.Friend", "his.PrincipalID"}, {"my.PrincipalID", "his.Friend"}});
            QueryFilter filter = new QueryFilter();
            filter.andFilters["my.PrincipalID"] = principalID;
            List<string> query = GD.Query(new string[]
                                              {
                                                  "my.Friend",
                                                  "my.Flags",
                                                  "his.Flags"
                                              }, tables, filter, null, null, null);

            //These are used to get the other flags below
            for (int i = 0; i < query.Count; i += 3)
            {
                FriendInfo info = new FriendInfo
                                      {
                                          PrincipalID = principalID,
                                          Friend = query[i],
                                          MyFlags = int.Parse(query[i + 1]),
                                          TheirFlags = int.Parse(query[i + 2])
                                      };
                infos.Add(info);
            }
            return infos.ToArray();
        }

 public bool Delete(UUID id, bool ignoreFlags)
 {
     try
     {
         if (!ignoreFlags)
         {
             AssetBase asset = GetAsset(id, false);
             if (asset == null)
                 return false;
             if ((int) (asset.Flags & AssetFlags.Maptile) != 0 || //Depriated, use Deletable instead
                 (int) (asset.Flags & AssetFlags.Deletable) != 0)
                 ignoreFlags = true;
         }
         if (ignoreFlags)
         {
             QueryFilter filter = new QueryFilter();
             filter.andFilters["id"] = id;
             m_Gd.Delete("assets", filter);
         }
     }
     catch (Exception e)
     {
         if (MainConsole.Instance != null)
             MainConsole.Instance.Error("[LocalAssetDatabase] Error while deleting asset " + e);
     }
     return true;
 }

        public bool FolderExists(UUID folderID)
        {
            QueryFilter filter = new QueryFilter();
            filter.andFilters["folderID"] = folderID;

            return GD.Query(new string[] {"folderID"}, m_foldersrealm, filter, null, null, null).Count > 0;
        }

        public IEnumerable<Vector3> FindPath(Vector3 start, Vector3 end, QueryFilter filter, bool hardFail)
        {
            if (!LoadAppropriateTiles(start, end))
                throw new Exception("Correct tiles were not loaded!");

            //LoadAllTiles();

            float[] extents = new[] { 0.5f, 0.5f, 0.5f };
            PolygonReference startRef, endRef;

            float[] transformedStart = start.ToFloatArray();
            float[] transformedEnd = end.ToFloatArray();

            RecastManaged.Helper.Transform(ref transformedStart);
            RecastManaged.Helper.Transform(ref transformedEnd);

            while ((startRef = DetourMesh.FindNearestPolygon(transformedStart, extents, filter)).PolyIndex == 0)
            {
                if (extents[0] > 100.0f)
                    throw new Exception("Extents got too huge");

                extents[0] += 0.5f;
                extents[1] += 0.5f;
                extents[2] += 0.5f;
            }

            extents = new[] { 0.5f, 0.5f, 0.5f };
            while ((endRef = DetourMesh.FindNearestPolygon(transformedEnd, extents, filter)).PolyIndex == 0)
            {
                if (extents[0] > 100.0f)
                    throw new Exception("Extents got too huge");

                extents[0] += 0.5f;
                extents[1] += 0.5f;
                extents[2] += 0.5f;
            }
            var path = DetourMesh.FindPath(startRef, endRef, transformedStart, transformedEnd, filter);

            if (path.Length <= 0)
                return null;

            // if the last poly in the path is not the end poly, a path was not found
            if (hardFail && path[path.Length - 1].PolyIndex != endRef.PolyIndex)
                return null;

            StraightPathFlags[] flags;
            PolygonReference[] straightPathRefs;
            var straightPath = DetourMesh.FindStraightPath(transformedStart, transformedEnd, path, out flags, out straightPathRefs);

            RecastManaged.Helper.InverseTransform(ref straightPath);

            List<Vector3> ret = new List<Vector3>(straightPath.Length / 3);
            for (int i = 0; i < straightPath.Length / 3; i++)
                ret.Add(new Vector3(straightPath[i * 3 + 0], straightPath[i * 3 + 1], straightPath[i * 3 + 2]));

            //for (int i = 0; i < straightPath.Length / 3; i++)
            //    yield return new Vector3(straightPath[i * 3 + 0], straightPath[i * 3 + 1], straightPath[i * 3 + 2]);

            return ret;
        }

 public ViewerStatsMessage GetBySession(UUID sessionID)
 {
     QueryFilter filter = new QueryFilter();
     filter.andFilters.Add("session_id", sessionID);
     List<string> results = GD.Query(new string[1] {"*"}, m_realm, filter, null, null, null);
     return BuildSession(results, 0);
 }

        public UserInfo Get(string userID, bool checkOnlineStatus, out bool onlineStatusChanged)
        {
            onlineStatusChanged = false;

            QueryFilter filter = new QueryFilter();
            filter.andFilters["UserID"] = userID;
            List<string> query = GD.Query(new string[1] {"*"}, m_realm, filter, null, null, null);

            if (query.Count == 0)
            {
                return null;
            }
            UserInfo user = ParseQuery(query)[0];

            //Check LastSeen
            DateTime timeLastSeen = Util.ToDateTime(int.Parse(query[2]));
            DateTime timeNow = DateTime.Now.ToUniversalTime();
            if (checkOnlineStatus && m_checkLastSeen && user.IsOnline && (timeLastSeen.AddHours(1) < timeNow))
            {
                MainConsole.Instance.Warn("[UserInfoService]: Found a user (" + user.UserID +
                                          ") that was not seen within the last hour " +
                                          "(since " + timeLastSeen.ToLocalTime().ToString() + ", time elapsed " +
                                          (timeNow - timeLastSeen).Days + " days, " + (timeNow - timeLastSeen).Hours +
                                          " hours)! Logging them out.");
                user.IsOnline = false;
                Set(user);
                onlineStatusChanged = true;
            }
            return user;
        }

        public bool AddClassified(Classified classified)
        {
            object remoteValue = DoRemote(classified);
            if (remoteValue != null || m_doRemoteOnly)
                return remoteValue != null && (bool) remoteValue;

            if (GetUserProfile(classified.CreatorUUID) == null)
                return false;
            string keywords = classified.Description;
            if (keywords.Length > 512)
                keywords = keywords.Substring(keywords.Length - 512, 512);
            //It might be updating, delete the old
            QueryFilter filter = new QueryFilter();
            filter.andFilters["ClassifiedUUID"] = classified.ClassifiedUUID;
            GD.Delete("userclassifieds", filter);
            List<object> values = new List<object>
                                      {
                                          classified.Name,
                                          classified.Category,
                                          classified.SimName,
                                          classified.CreatorUUID,
                                          classified.ScopeID,
                                          classified.ClassifiedUUID,
                                          OSDParser.SerializeJsonString(classified.ToOSD()),
                                          classified.PriceForListing,
                                          keywords
                                      };
            return GD.Insert("userclassifieds", values.ToArray());
        }

        /// <summary>
        /// Gets the number of Abuse reports.
        /// </summary>
        /// <returns>The report count.</returns>
        public int AbuseReportCount()
        {
            QueryFilter filter = new QueryFilter ();
            var reports = GD.Query (new string[1] { "count(*)" }, m_abuseReportsTable, filter, null, null, null);
            if ((reports == null) || (reports.Count == 0))
                return 0;

            return int.Parse (reports [0]);
        }

        public virtual bool DeleteFolders(string field, string val, bool safe)
        {
            QueryFilter filter = new QueryFilter();
            filter.andFilters[field] = val;
            if (safe)
                filter.orMultiFilters["type"] = new List<object>() { "-1", "47" };

            return GD.Delete(m_foldersrealm, filter);
        }

        public Query(QueryScope scope, QueryFilter filter)
        {
            if (scope == null)
                this.scope = new QueryScope(ObjectTypes.AllExcFolders);
            else
                this.scope = scope;

            this.filter = filter;  // null is OK
        }

        public List<string> FindLSLData(string token, string key)
        {
            object remoteValue = DoRemote(token, key);
            if (remoteValue != null || m_doRemoteOnly)
                return (List<string>) remoteValue;

            QueryFilter filter = new QueryFilter();
            filter.andFilters["Token"] = token;
            filter.andFilters["KeySetting"] = key;
            return GD.Query(new string[1] {"*"}, "lslgenericdata", filter, null, null, null);
        }

 public SchedulerItem Get(string id)
 {
     if (id != "")
     {
         QueryFilter filter = new QueryFilter();
         filter.andFilters["id"] = id;
         List<string> results = m_Gd.Query(theFields, "scheduler", filter, null, null, null);
         return LoadFromList(results);
     }
     return null;
 }

 public bool DeleteAccount(UUID userID, bool archiveInformation)
 {
     if (archiveInformation)
     {
         return GD.Update(m_realm, new Dictionary<string, object> {{"UserLevel", -2}}, null,
                          new QueryFilter {andFilters = new Dictionary<string, object> {{"PrincipalID", userID}}},
                          null, null);
     }
     QueryFilter filter = new QueryFilter();
     filter.andFilters.Add("PrincipalID", userID);
     return GD.Delete(m_realm, filter);
 }