Arcengine查询翻页

于 2020-12-24 10:55:20 发布
阅读量307 收藏 1
点赞数
分类专栏： arcengine C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43224584/article/details/111611096
版权

*** Arcengine提供了IQueryFilterDefinition3的方法进行查询分页，但是这个方法是有版本要求的，我知道10.1和10.2版本没有这个接口，10.3和10.4版本没了解过，10.5版本以上是有的。但是用10.1版本怎么做翻页呢？我这里提供了两个思路：***
方法一：

//调转事件
  /// <summary>
        /// 跳转到第一页
        /// </summary>
        private void ToFirstPage()
        {
            _currentPageIndex = 1;
            GetAttribute(FirstDataOID, FirstDataOID + PageMaxSize, PageMaxSize, FirstDataOID, LastDataOID, false, true);
        }

        /// <summary>
        /// 上一页
        /// </summary>
        private void ToPreviousPage()
        {
            if (_currentPageIndex > 1)
            {
                _currentPageIndex--;
            }
            GetAttribute(_pageFirstOID, _pageLastOID, PageMaxSize, FirstDataOID, LastDataOID, false, false);
        }

        /// <summary>
        /// 下一页
        /// </summary>
        private void ToNextPage()
        {
            if (_currentPageIndex < _pageCount)
            {
                _currentPageIndex++;
                GetAttribute(_pageFirstOID, _pageLastOID, PageMaxSize, FirstDataOID, LastDataOID, true, false);
            }
        }

        /// <summary>
        /// 跳转到最后一页
        /// </summary>
        private void ToLastPage()
        {
            _currentPageIndex = _pageCount;
            GetPageFirstDataOID(_featureLayer.FeatureClass, _currentPageIndex, PageMaxSize, FirstDataOID, LastDataOID);
            GetAttribute(_pageFirstOID, _pageFirstOID + PageMaxSize, PageMaxSize, FirstDataOID, LastDataOID, true, true);
        }

  //二分法获取每一页的第一个OID，测试了10w+的数据，大概需要10s
  /// <summary>
        /// 获取跳转页的PageFirstOID
        /// </summary>
        /// <param name="featureClass"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageMaxSize"></param>
        private void GetPageFirstDataOID(IFeatureClass featureClass, int pageIndex, int pageMaxSize, int firstDataOID, int lastDataOID)
        {
            try
            {
                if (null != featureClass)
                {

                    //二分法获取翻页的pageFirstOID
                    int previousDataCount = (pageIndex - 1) * pageMaxSize + 1;
                    int thisPageFirstDataOID = (pageIndex - 1) * pageMaxSize;
                    int thisPageLastDataOID = lastDataOID;
                    int thisMiddleDataOID = (int)Math.Floor((thisPageFirstDataOID + thisPageLastDataOID) * 1.0 / 2);

                    IQueryFilter queryFilter = new QueryFilter();
                    IDataset dataset = _featureLayer.FeatureClass as IDataset;
                    IWorkspaceName workSpaceName = ((IDatasetName)dataset.FullName).WorkspaceName;
                    int _thisPageDataCount = 0;

                    //对GDB和shape文件分别处理
                    while (_thisPageDataCount != previousDataCount)
                    {
                        if (workSpaceName.WorkspaceFactoryProgID.IndexOf("FileGDBWorkspaceFactory") > -1)
                        {
                            queryFilter.WhereClause = $" {featureClass.OIDFieldName} between {firstDataOID} and {thisMiddleDataOID} ORDER BY {featureClass.OIDFieldName} ";
                        }
                        else if (workSpaceName.WorkspaceFactoryProgID.IndexOf("ShapefileWorkspaceFactory") > -1)
                        {
                            queryFilter.WhereClause = "\"" + $"{featureClass.OIDFieldName}" + "\"" + $" >= {firstDataOID} AND " + "\"" + $"{featureClass.OIDFieldName}" + "\"" + $" <= {thisMiddleDataOID} ORDER BY " + "\"" + $"{featureClass.OIDFieldName}" + "\"";
                        }
                        _thisPageDataCount = _featureLayer.FeatureClass.FeatureCount(queryFilter);
                        if (_thisPageDataCount > previousDataCount)
                        {

                            if (thisPageLastDataOID - thisPageFirstDataOID == 1)
                            {
                                thisPageLastDataOID = thisPageFirstDataOID;
                            }
                            else
                            {
                                thisPageLastDataOID = thisMiddleDataOID;
                            }
                        }
                        else if (_thisPageDataCount < previousDataCount)
                        {
                            if (thisPageLastDataOID - thisPageFirstDataOID == 1)
                            {
                                thisPageFirstDataOID = thisPageLastDataOID;
                            }
                            else
                            {
                                thisPageFirstDataOID = thisMiddleDataOID;
                            }
                        }
                        else
                        {
                            _pageFirstOID = thisMiddleDataOID;//_pageFirstOID 是全局变量
                        }
                        thisMiddleDataOID = (int)Math.Floor((thisPageFirstDataOID + thisPageLastDataOID) * 1.0 / 2);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("翻页失败", "错误提示：", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

//根据每一页第一个OID遍历数据，每次OID加上pageMaxSize，直到两个OID之间数据大于pageMaxSize时，遍历只取其中pageMaxSize个数据，记录pageLastOID
   /// <summary>
        /// 获取属性表数据
        /// <param name="pageFirstOID">当前页最小OID</param>  
        /// <param name="pageLastOID">当前页最大OID</param> 
        /// <param name="pageMaxSize">页面大小</param>  
        /// <param name="firstDataOID">所有数据最小OID</param>  
        /// <param name="lastDataOID">所有数据最大OID</param>  
        /// <param name="downFlag">是否向下查询</param>  
        /// <param name="firstOrLastFlag">是否是第一页或者最后一页</param>
        /// </summary>
        private void GetAttribute(int pageFirstOID, int pageLastOID, int pageMaxSize, int firstDataOID, int lastDataOID, bool downFlag, bool firstOrLastFlag)
        {
            DataTable dataTable = new DataTable();
            if (null != _featureLayer.FeatureClass)
            {
                ITable lyrtable = (ITable)_featureLayer;
                IQueryFilter queryFilter = new QueryFilter();
                IDataset dataset = _featureLayer.FeatureClass as IDataset;
                IWorkspaceName workSpaceName = ((IDatasetName)dataset.FullName).WorkspaceName;
                if (downFlag)
                {
                    int _thisPageDataCount = 0;
                    if (!firstOrLastFlag && pageLastOID < lastDataOID)
                    {
                        pageFirstOID = pageLastOID + 1;
                    }
                    if (workSpaceName.WorkspaceFactoryProgID.IndexOf("FileGDBWorkspaceFactory") > -1)
                    {
                        while (_thisPageDataCount < pageMaxSize && pageLastOID < lastDataOID)
                        {
                            queryFilter.WhereClause = $"{lyrtable.OIDFieldName} between {pageFirstOID} and {pageLastOID + pageMaxSize} ORDER BY {lyrtable.OIDFieldName}";
                            _thisPageDataCount = _featureLayer.FeatureClass.FeatureCount(queryFilter);
                            pageLastOID = pageLastOID + pageMaxSize;
                        }
                    }
                    else if (workSpaceName.WorkspaceFactoryProgID.IndexOf("ShapefileWorkspaceFactory") > -1)
                    {
                        while (_thisPageDataCount < pageMaxSize && pageLastOID < lastDataOID)
                        {
                            queryFilter.WhereClause = "\"" + $"{lyrtable.OIDFieldName}" + "\"" + $" >= {pageFirstOID} AND " + "\"" + $"{lyrtable.OIDFieldName}" + "\"" + $" <= { pageLastOID + pageMaxSize} ORDER BY " + "\"" + $"{lyrtable.OIDFieldName}" + "\"";
                            _thisPageDataCount = _featureLayer.FeatureClass.FeatureCount(queryFilter);
                            pageLastOID = pageLastOID + pageMaxSize;
                        }
                    }
                }
                else
                {
                    int _thisPageDataCount = 0;
                    if (!firstOrLastFlag && pageFirstOID > firstDataOID)
                    {
                        pageLastOID = pageFirstOID - 1;
                    }
                    if (workSpaceName.WorkspaceFactoryProgID.IndexOf("FileGDBWorkspaceFactory") > -1)
                    {
                        while (_thisPageDataCount < pageMaxSize && pageFirstOID > firstDataOID)
                        {
                            queryFilter.WhereClause = $" {lyrtable.OIDFieldName} between {pageFirstOID - pageMaxSize} and {pageLastOID} ORDER BY {lyrtable.OIDFieldName} ";
                            _thisPageDataCount = _featureLayer.FeatureClass.FeatureCount(queryFilter);
                            pageFirstOID = pageFirstOID - pageMaxSize;
                        }
                    }
                    else if (workSpaceName.WorkspaceFactoryProgID.IndexOf("ShapefileWorkspaceFactory") > -1)
                    {
                        while (_thisPageDataCount < pageMaxSize && pageLastOID < lastDataOID)
                        {
                            queryFilter.WhereClause = "\"" + $"{lyrtable.OIDFieldName}" + "\"" + $" >= {pageFirstOID - pageMaxSize} AND " + "\"" + $"{lyrtable.OIDFieldName}" + "\"" + $" <= {pageLastOID} ORDER BY " + "\"" + $"{lyrtable.OIDFieldName}" + "\"";
                            _thisPageDataCount = _featureLayer.FeatureClass.FeatureCount(queryFilter);
                            pageFirstOID = pageFirstOID - pageMaxSize;
                        }
                    }
                }
                dataTable = ToDataTable(lyrtable, _featureLayer.FeatureClass.Fields, _dataCount, pageFirstOID, pageLastOID, pageMaxSize, firstDataOID, lastDataOID, downFlag, firstOrLastFlag);//获取数据
                _attributeTableData = dataTable;
                RaisePropertyChanged(nameof(AttributeTableData));
            }
        }
        
        /// <summary>  
        /// 将ITable转换为DataTable  
        /// </summary>  
        /// <param name="mTable">数据</param>  
        /// <param name="fields">字段</param>  
        /// <param name="pageDataCount">总数据个数</param>  
        /// <param name="pageFirstOID">当前一页最小OID</param>  
        /// <param name="pageLastOID">当前页最大OID</param>  
        /// <param name="pageMaxSize">页面大小</param>  
        /// <param name="firstDataOID">所有数据最小OID</param>  
        /// <param name="lastDataOID">所有数据最大OID</param>  
        /// <param name="downFlag">是否向下查询</param>  
        /// <param name="firstOrLastFlag">是否是第一页或者最后一页</param>  
        /// <returns></returns>  
        public DataTable ToDataTable(ITable lyrtable, IFields fields, int pageDataCount, int pageFirstOID, int pageLastOID, int pageMaxSize, int firstDataOID, int lastDataOID, bool downFlag, bool firstOrLastFlag)
        {
            DataTable pTable = new DataTable();
            string queryFilterSubFilds = "";
            string geometryType = GetEsriGeometryType(((IFeatureLayer)lyrtable).FeatureClass.ShapeType);
            for (int i = 0; i < fields.FieldCount; i++)
            {
                pTable.Columns.Add(fields.get_Field(i).Name);
                if (fields.get_Field(i).Name.ToLower() != ((IFeatureLayer)lyrtable).FeatureClass.ShapeFieldName.ToLower())
                {
                    queryFilterSubFilds += fields.get_Field(i).Name + ",";
                }
            }
            if (queryFilterSubFilds.Length > 0)
            {
                queryFilterSubFilds = queryFilterSubFilds.Substring(0, queryFilterSubFilds.Length - 1);
            }
            try
            {
                IQueryFilter queryFilter = new QueryFilter();
                queryFilter.SubFields = queryFilterSubFilds;
                IDataset dataset = lyrtable as IDataset;
                IWorkspaceName workSpaceName = ((IDatasetName)dataset.FullName).WorkspaceName;
                if (workSpaceName.WorkspaceFactoryProgID.IndexOf("FileGDBWorkspaceFactory") > -1)
                {
                    queryFilter.WhereClause = $" {lyrtable.OIDFieldName} between {pageFirstOID} and {pageLastOID} ORDER BY {lyrtable.OIDFieldName} ";
                }
                else if (workSpaceName.WorkspaceFactoryProgID.IndexOf("ShapefileWorkspaceFactory") > -1)
                {
                    queryFilter.WhereClause = "\"" + $"{lyrtable.OIDFieldName}" + "\"" + $" >= {pageFirstOID} AND " + "\"" + $"{lyrtable.OIDFieldName}" + "\"" + $" <= {pageLastOID} ORDER BY " + "\"" + $"{lyrtable.OIDFieldName}" + "\"";

                }

                ICursor pCursor = lyrtable.Search(queryFilter, true);
                IRow pRrow = pCursor.NextRow();
                int pRrowSize = pageMaxSize;
                int OIDIndex = -1;

                //获取OIDindex和当前页第一个值的OID
                if (pRrow != null)
                {
                    for (int i = 0; i < pRrow.Fields.FieldCount; i++)
                    {
                        if (lyrtable.Fields.Field[i].Name == lyrtable.OIDFieldName)
                        {
                            OIDIndex = i;
                            break;
                        }
                    }
                    _pageFirstOID = Convert.ToInt32(pRrow.OID);
                }

                //遍历数据，获得Table
                while (pRrow != null && pRrowSize > 0)
                {
                    DataRow pRow = pTable.NewRow();
                    string[] StrRow = new string[pRrow.Fields.FieldCount];
                    for (int i = 0; i < pRrow.Fields.FieldCount; i++)
                    {
                        if (pRrow.Fields.Field[i].Name.ToLower() != ((IFeatureLayer)lyrtable).FeatureClass.ShapeFieldName.ToLower())
                        {
                            StrRow[i] = pRrow.get_Value(i).ToString();
                        }
                        else
                        {
                            StrRow[i] = geometryType;
                        }
                    }
                    pRow.ItemArray = StrRow;
                    pTable.Rows.Add(pRow);
                    pRrow = pCursor.NextRow();
                    --pRrowSize;
                    if (pRrowSize <= 0 || pRrow == null)//获取当前页最后一个值的OID
                    {
                        _pageLastOID = Convert.ToInt32(pRow[OIDIndex]);
                    }
                }
                return pTable;
            }
            catch (Exception ex)
            {
                return pTable;
            }
        }

方法二：

//翻页
  /// <summary>
        /// 跳转到第一页
        /// </summary>
        private void ToFirstPage()
        {
            _currentPageIndex = 1;
            ChangePage(_currentPageIndex - 1);
        }
   /// <summary>
        /// 上一页
        /// </summary>
        private void ToPreviousPage()
        {
            if (_currentPageIndex > 1)
            {
                _currentPageIndex--;
                ChangePage(_currentPageIndex - 1);
            }
        }

        /// <summary>
        /// 下一页
        /// </summary>
        private void ToNextPage()
        {
            if (_currentPageIndex < _pageCount)
            {
                _currentPageIndex++;
                ChangePage(_currentPageIndex - 1);
            }
        }

        /// <summary>
        /// 跳转到最后一页
        /// </summary>
        private void ToLastPage()
        {
            _currentPageIndex = _pageCount;
            ChangePage(_currentPageIndex - 1);
        }

//先找到每一页的第一个OBJECTID储存起来。测试list只存一个OBJECTID字段时能储存1.2亿条，与OBJECTID字段的复杂度有关，如果只存每一页的OBJECTID是够用了（数据量大也可以做两层list嵌套，这里不做考虑）
   private void GetUniqueValue(IFeatureClass pFeatureClass, string fieldName)
        {
            OIDListArry = new List<string>();
            int fieldIndex = pFeatureClass.Fields.FindField(fieldName);

            // 属性过滤器 
            IQueryFilter pQueryFilter = new QueryFilter();
            pQueryFilter.AddField(fieldName);

            // 要素游标
            IFeatureCursor pFeatureCursor = pFeatureClass.Search(pQueryFilter, true);
            IFeature pFeature = pFeatureCursor.NextFeature();
            int pageSizeCount = 1;
            try
            {
                while (pFeature != null)
                {
                    if (pageSizeCount % PageMaxSize == 1)
                    {
                        OIDListArry.Add(pFeature.Value[fieldIndex].ToString());
                        pageSizeCount = 1;
                    }
                    pageSizeCount++;
                    pFeature = pFeatureCursor.NextFeature();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("数据溢出!", "错误提示：", MessageBoxButton.OK, MessageBoxImage.Warning);
            }
            // 释放游标
            System.Runtime.InteropServices.Marshal.ReleaseComObject(pFeatureCursor);
        }
        
        //取得当前页firstOID和lastOID（lastOID为下一页firstOID-1，可能不存在，但是我们这里只是需要取到包含有pageSizeMax个数据的这个范围就行了）
  public void ChangePage(int pageIndex)
        {
            if (null != _featureLayer.FeatureClass)
            {
                DataTable pTable = new DataTable();
                string queryFilterSubFilds = "";
                string geometryType = GetEsriGeometryType(_featureLayer.FeatureClass.ShapeType);
                IFields fields = _featureLayer.FeatureClass.Fields;
                for (int i = 0; i < fields.FieldCount; i++)
                {
                    pTable.Columns.Add(fields.get_Field(i).Name);
                    if (fields.get_Field(i).Name.ToLower() != _featureLayer.FeatureClass.ShapeFieldName.ToLower())
                    {
                        queryFilterSubFilds += fields.get_Field(i).Name + ",";
                    }
                }
                if (queryFilterSubFilds.Length > 0)
                {
                    queryFilterSubFilds = queryFilterSubFilds.Substring(0, queryFilterSubFilds.Length - 1);
                }
                try
                {
                    IQueryFilter queryFilter = new QueryFilter();
                    queryFilter.SubFields = queryFilterSubFilds;
                    IDataset dataset = _featureLayer as IDataset;
                    IWorkspaceName workSpaceName = ((IDatasetName)dataset.FullName).WorkspaceName;

                    int firtOID = Convert.ToInt32(OIDListArry[pageIndex]);
                    int lastOID = firtOID + PageMaxSize;
                    if (pageIndex < (OIDListArry.Count - 1))
                    {
                        lastOID = Convert.ToInt32(OIDListArry[pageIndex + 1]) - 1;
                    }
                    else
                    {
                        lastOID = 0;
                    }

                    if (workSpaceName.WorkspaceFactoryProgID.IndexOf("FileGDBWorkspaceFactory") > -1)
                    {
                        queryFilter.WhereClause = $" {_featureLayer.FeatureClass.OIDFieldName} >= {firtOID} " + (lastOID == 0 ? "" : $" and {_featureLayer.FeatureClass.OIDFieldName} <= {lastOID} ") + $" ORDER BY {_featureLayer.FeatureClass.OIDFieldName} ";
                    }
                    else if (workSpaceName.WorkspaceFactoryProgID.IndexOf("ShapefileWorkspaceFactory") > -1)
                    {
                        queryFilter.WhereClause = "\"" + $"{_featureLayer.FeatureClass.OIDFieldName}" + "\"" + $" >= {firtOID} " + (lastOID == 0 ? "" : " AND\"" + $"{_featureLayer.FeatureClass.OIDFieldName}" + "\"" + $" <= {lastOID} ") + $" ORDER BY " + "\"" + $"{_featureLayer.FeatureClass.OIDFieldName}" + "\"";
                    }

                    ICursor pCursor = _featureLayer.FeatureClass.Search(queryFilter, true) as ICursor;
                    IRow pRrow = pCursor.NextRow();

                    //获取目标数据集对应源数据集索引字典
                    Dictionary<int, TargetFieldsModel> targetsource = new Dictionary<int, TargetFieldsModel>();
                    for (int i = 0; i < fields.FieldCount; i++)
                    {
                        IField tField = fields.get_Field(i);
                        targetsource.Add(i, new TargetFieldsModel { Name = tField.Name, TargetType = tField.Type });
                    }

                    //遍历数据，获得Table
                    while (pRrow != null)
                    {
                        DataRow pRow = pTable.NewRow();
                        string[] StrRow = new string[pRrow.Fields.FieldCount];
                        foreach (KeyValuePair<int, TargetFieldsModel> keyValue in targetsource)
                        {
                            if (keyValue.Value.Name.ToLower() != _featureLayer.FeatureClass.ShapeFieldName.ToLower())
                            {
                                StrRow[keyValue.Key] = pRrow.Value[keyValue.Key].ToString();
                            }
                            else
                            {
                                StrRow[keyValue.Key] = geometryType;
                            }
                        }
                        pRow.ItemArray = StrRow;
                        pTable.Rows.Add(pRow);
                        pRrow = pCursor.NextRow();
                    }
                }
                catch (Exception ex)
                {

                }
                _attributeTableData = pTable;
                RaisePropertyChanged(nameof(AttributeTableData));
            }
        }

10w+数据测试方法二比方法一效率跟高！

鸽子fly
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ArGIS Engine专题（3）之矢量栅格属性表（分页异步加载，解决大数据量加载一种方式）
wokao253615105的专栏
10-10 345
对于数据量小时，直接一次性显示所有数据完全没有问题，然而在实际应用中往往数据量都较大，尤其是GIS空间数据，有时甚至可以达到百万级、千万级，如果没有好的设计逻辑，往往会出现假死、无响应、反应超级慢，甚至会出现内存不足，而直接闪退，在用户体验上极差。 为了解决大数据量加载问题，本文将采用分页、异步加载的方式来实现。 目录 一、实现属性数据分页 （1）arcengine提供了IQueryFilterDefinition3可以实现分页 （2）直接通过IQueryFilter结合ITable查询检索 二
Arcgis 10.5安装包
08-30
Esri公司的产品，在GIS行业内被广泛使用，最新版为10.6
ArcEngine查看数据量较大属性表的解决方案（解决HRESULT:0x8004160A）
weixin_41607453的博客
10-18 610
在之前的博文“ArcEngine做一个“仿”ArcMap中的属性表”中，如果遇到数据量较大（万级以上）的数据就会出现查询很慢甚至内存溢出的问题，这对于一个实际应用的系统肯定是不允许的。好在ao中提供了定义过滤查询的接口：IQueryFilterDefinition3 在接口文档中对这个接口的说明是这样的： Provides access to query filter definition properties. 定义过滤条件主要要用到IQueryFilterDefinition3接口中PostfixC
IQueryFilter与ISpatialFilter接口的使用
漓涂
05-07 3889
在ArcGIS二次开发中，IQueryFilter和ISpatialFilter是最常用的查询接口。 一、IQueryFilter接口 IQueryFilter接口用于属性查询。该接口提供了1个方法和3个属性。如AddField方法用于向输出字段集中添加一个字段，OutputSpatialReference属性用于获取给定字段的输出几何图形的空间参考，SubFie...
ArcEngine实现要素属性表分页查询
HerryDong的博客
01-16 1284
用过ArcGIS的同志应该都知道它的属性表分页功能，如下图所示： 这次我也照葫芦画瓢，自己做了一个ArcEngine + DevExpress的分页Demo，效果如下图所示： MainForm.cs代码： using System; using System.Collections.Generic; using System.ComponentModel; using System.Data;...
ArcEngine空间查询统计
07-09
ArcEngine二次开发代码，调试可运行，可实现属性查询、空间查询和统计功能！供初学者练习使用.........
SQL-attribute-query.rar_Arcengine查询_arcengine
09-24
vc,C#,Arcengine SQL属性查询,select,from ,where
ArcEngine开发教程大全
06-20
ArcEngine开发教程大全
C# arcEngine 属性查询
10-12
arcengine开发属性查询功能和属性及表连接
ArcEngine连接SDE总结.docx
05-22
数据库、ArcCatalog空间数据源正常访问，数据库设置没问题时，ArcEngine连接SDE时报"ORA-12560: TNS: 协议适配器错误"的解决办法;ArcEngine连接SDE总结;ArcSDE：C#打开SDE数据库的几种方式总结
ElasticSearch对象化
qq_35978993的博客
05-03 373
这里写自定义目录标题ElasticSearch对象化引入jar包配置文件工厂类RestHighLevelClient启动类注解@EsCommonFilter@DateFormat@ExcludeField@FieldType@Fuzzy@QueryFilter@TimeMax @TimeMin增删改查接口层BaseService与坐标有关的 GeoPointBaseService实现层BaseIm...
Query注解的用法
weixin_44098139的博客
01-04 1409
@Query注解的用法(Spring Data JPA) 参考文章：http://www.tuicool.com/articles/jQJBNv   1. 一个使用@Query注解的简单例子 @Query(value = "select name,author,price from Book b where b.price&gt;?1 and b.price&lt;?2") List&l...
ArcEngine查询统计IQueryFilter、ISpatialFilter、IQueryDef 、WHEREclauses（转载）
myfatenight的博客
01-14 980
用ArcEngine的接口做过查询统计的同学应该知道，由于ArcEngine并没有完整支持SQL，所以做简单的查询还好，稍微复杂一点就开始捉襟见肘了。  现在总结一下几种查询的方法：  1.IQueryFilter、ISpatialFilter接口。  这是最常见的，把参数设置进去，然后调用IFeatureClass或者ITable的Search方法就行。可以转为IQueryFilterDefin...
ArcEngine查询统计IQueryFilter、ISpatialFilter、IQueryDef 、WHEREclauses
sRhee的博客
01-11 6931
用ArcEngine的接口做过查询统计的同学应该知道，由于ArcEngine并没有完整支持SQL，所以做简单的查询还好，稍微复杂一点就开始捉襟见肘了。 现在总结一下几种查询的方法： 1.IQueryFilter、ISpatialFilter接口。 这是最常见的，把参数设置进去，然后调用IFeatureClass或者ITable的Search方法就行。可以转为IQueryFilterDefini
ArcEngine 读取大数据量的IFeatureClass或ITable分页进行显示
kone666
04-01 1989
ArcEngine已经实现打开属性表功能，但是如果记录达到上万条的话，就非常慢，影响用户体验。 IQueryFilterDefinition3接口可以一次查询几百条数据，然后下次可以接着往下获取记录。 参考代码：IQueryFilterDefinition3 queryFilterDef = (IQueryFilterDefinition3)queryFilter; i...
ArcEngine 数据查询、数据操作总结
热门推荐
爱莫能助
12-06 1万+
数据查询查询地理数据库表查询geodatabase对象的三种常见的接口是IQueryFilter、ISpatialFilter、IQueryDef接口。每个接口都有不同的功能,如下表所示: Requirement IQueryFilter ISpatialFilter IQueryDef Apply attribute constraints（支持属性约束） True Tr
ArcEngine查询统计(IQueryFilter), 表连接查询
kone666
07-04 3492
一、 用ArcEngine的接口做过查询统计的同学应该知道，由于ArcEngine并没有完整支持SQL，所以做简单的查询还好，稍微复杂一点就开始捉襟见肘了。 现在总结一下几种查询的方法： 1.IQueryFilter、ISpatialFilter接口。 这是最常见的，把参数设置进去，然后调用IFeatureClass或者ITable的Search方法就行。可以转为IQueryFilte
基于ArcEngine实现分组统计面积的功能
hsg77的专栏
05-09 3907
基于ArcEngine实现分组统计面积的功能IQueryFilter qf=new QueryFilterClass();               qf.subfield="qsdwdm,qsxz,dlbm,sum(mj) as mj,sum(tkmj) as tkmj"               qf .whereclause="";      (IQueryFilterDefin
IFeatureLayerDefinition接口查询要素图层方法汇总
love_you_zz的博客
07-06 1463
IFeatureLayerDefinition接口查询图层方法
arcengine空间查询
最新发布
05-19
在ArcEngine中，空间查询主要有两种方式：基于属性查询和基于空间关系查询。 基于属性查询是根据要素所包含的属性字段进行查询，例如查询某个城市中所有人口大于10万的县区。可以通过构建查询表达式来实现，具体...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值