建立索引

最新推荐文章于 2022-08-05 16:58:36 发布
最新推荐文章于 2022-08-05 16:58:36 发布
阅读量521 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiushidt/article/details/51996083
版权 

     private void createIndex(int width,int height,string savePath){
            IFeatureLayer featLayer = axMapControl1.get_Layer(0) as IFeatureLayer;
            List<IField> listfield = new List<IField>();
            for (int i = 0; i < featLayer.FeatureClass.Fields.FieldCount; i++)
            {
                listfield.Add(featLayer.FeatureClass.Fields.Field[i]);
            }
            IField selectField = featLayer.featureclass.fileds.get_field(0);
            IFeatureClass fclass = featLayer.FeatureClass;
            IFeatureCursor fc = fclass.Search(null, false);
            IFeature feat = fc.NextFeature();

            List<IFeature> listFeatures = new List<IFeature>();
            while (feat != null)
            {
                listFeatures.Add(feat);
                feat = fc.NextFeature();
            }
            string layername = ((IDataset)fclass).Name;

            LayerSpatialIndex lsi = new LayerSpatialIndex();
            lsi.LayerName = layername;
            //lsi.LayerField = selectField.Name;
            lsi.LayerFields = listfield.ConvertAll(o => o.Name);

            IEnvelope env = null;
            listFeatures.ForEach(o =>
            {
                if (env == null)
                {
                    env = o.Extent.Envelope;
                }
                else
                {
                    env.Union(o.Extent.Envelope);
                }
            });
            double upperleftX = env.UpperLeft.X;
            double upperleftY = env.UpperLeft.Y;
            double lowerrightX = env.LowerRight.X;
            double lowerrightY = env.LowerRight.Y;


            lsi.UpperLeftX = upperleftX;
            lsi.UpperLeftY = upperleftY;
            lsi.LowerRightX = lowerrightX;
            lsi.LowerRightY = lowerrightY;

            lsi.listIndexes = new List<ValueIndex>();
            int userType = 1;
            if (listFeatures.Count < 255)
            {
                userType = 1;
            }
            else if (listFeatures.Count < 65535)
            {
                userType = 2;
            }
            else if (listFeatures.Count < 4294967295)
            {
                userType = 4;
            }
            lsi.DataType = userType;


            for (int i = 0; i < listFeatures.Count; i++)
            {
                ValueIndex vi = new ValueIndex();
                vi.Value = new List<string>();
                for (int j = 0; j < listfield.Count; j++)
                {
                    vi.Value.Add(listFeatures[i].get_Value(j).ToString());
                }

                vi.index = i + 2;
                lsi.listIndexes.Add(vi);
            }
            double dX = (lowerrightX - upperleftX) / width;
            double dY = (upperleftY - lowerrightY) / height;

            int preferindex = -1;
            IRelationalOperator perferro = null;

            PixelFormat pf = PixelFormat.Format32bppRgb;
            //if(userType == typeof(ushort))
            //{
            //    pf = PixelFormat.Format16bppGrayScale;
            //}
            //else if(userType == typeof(uint))
            //{
            //    pf = PixelFormat.Format32bppRgb;
            //}
            Random r = new Random();
            List<Color> listColors = listFeatures.ConvertAll<Color>(o => Color.FromArgb(255, Color.FromArgb(r.Next())));
            listColors.Add(Color.FromArgb(255, Color.FromArgb(r.Next())));
            listColors.Add(Color.FromArgb(255, Color.FromArgb(r.Next())));

            Bitmap bmp = new Bitmap(width, height, pf);
            byte[] bt = new byte[width * height];
            DateTime dt1 = DateTime.Now;
            for (int i = 0; i < bt.Length; i++)
            {
                bt[i] = 0;
            }
            try
            {
                for (int i = 0; i < listFeatures.Count; i++)
                {
                    IFeature ifeat = listFeatures[i];


                    IPolygon poly = ifeat.Shape as IPolygon;


                    IGeometryCollection gc = poly as IGeometryCollection;
                    for (int j = 0; j < gc.GeometryCount; j++)
                    {
                        IRing ring = gc.Geometry[j] as IRing;
                        ISegmentCollection sc = ring as ISegmentCollection;
                        for (int k = 0; k < sc.SegmentCount; k++)
                        {
                            DrawBound(sc.Segment[k], upperleftX, lowerrightY, dX, dY, width, height, bt, bmp, listColors[1]);
                        }
                    }
                }
            }
            catch(Exception ex)
            {
            }

            for (int i = 0; i < height; i++)
            {
                int offset = i * width;
                for (int j = 0; j < width; j++)
                {
                    //current
                    if (bt[offset + j] == 1)
                    {
                        continue;
                    }
                    else 
                    {
                        if (j > 0)
                        {
                            if (bt[offset + j - 1] != 1)
                            {
                                bt[offset + j] = bt[offset + j - 1];
                                bmp.SetPixel(j, i, listColors[bt[offset + j - 1]]);
                                continue;
                            }
                        }

                        if (i > 0)
                        {
                            int offset2 = (i - 1) * width;
                            if (bt[offset2 + j] != 1)
                            {
                                bt[offset + j] = bt[offset2 + j];
                                bmp.SetPixel(j, i, listColors[bt[offset2 + j]]);
                                continue;
                            }

                            int start = j;
                            int end = j;

                            while (end < width && bt[offset + end] == 0)
                            {
                                end++;
                            }
                            end--;

                            byte findvalue = 0;
                            bool bFind = false ;
                            for (int m = start; m <= end; m++)
                            {
                                if (bt[offset2 + m] != 1)
                                {
                                    findvalue = bt[offset2 + m];
                                    bFind = true;
                                    break;
                                }
                            }
                            if (bFind)
                            {
                                for (int m = start; m <= end; m++)
                                {
                                    bt[offset + m] = findvalue;
                                    bmp.SetPixel(m, i, listColors[findvalue]);
                                }
                                continue;
                            }
                        }

                        IEnvelope tempenv = new EnvelopeClass();
                        tempenv.XMin = upperleftX + dX * j;
                        tempenv.XMax = tempenv.XMin + dX;
                        tempenv.YMin = lowerrightY + dY * (height-1-i);
                        tempenv.YMax = tempenv.YMin + dY;
                        bool find = false;
                        for (int m = 0; m < listFeatures.Count; m++)
                        {
                            //if (m == preferindex)
                            //{
                            //    continue;
                            //}
                            IRelationalOperator ro = listFeatures[m].Shape as IRelationalOperator;
                            int sit = GetSit(ro, tempenv, m);
                            if (sit > 0)
                            {
                                bmp.SetPixel(j, i, listColors[sit]);
                                bt[i * width + j] = (byte)sit;
                               
                                find = true;
                                break;
                            }
                        }
                        if (!find)
                        {
                            bmp.SetPixel(j, i, Color.FromArgb(0));
                            bt[i * width + j] = (byte)0;

                            //bmp.SetPixel(i, height - j - 1, Color.FromArgb(0));
                            //bt[(height - j - 1) * width + i] = (byte)0;
                        }
                    }
                }
            }               
            lsi.width = width;
            lsi.height = height;
            bmp.Save(savePath + "\\" + layername + ".bmp", ImageFormat.Bmp);

            using (System.IO.FileStream fs = File.Open(savePath + "\\" + layername + ".dat", FileMode.Create))
            {
                fs.Write(bt, 0, bt.Length);
                fs.Close();
            }

            using (System.IO.FileStream fs = File.Open(savePath + "\\" + layername + ".cfg", FileMode.Create))
            {
                System.Xml.Serialization.XmlSerializer ser = new System.Xml.Serialization.XmlSerializer(typeof(LayerSpatialIndex));
                ser.Serialize(fs, lsi);
                fs.Close();
            }

            MessageBox.Show((DateTime.Now - dt1).TotalSeconds.ToString());
        }

public class ValueIndex
    {
        public List<string> Value{get;set;}
        public int index{get;set;}
    }

        private void DrawBound(ISegment Segment, double upperleftX, double lowerrightY, double dX, double dY, int width, int height, byte[] bt, Bitmap bmp, Color c)
        {
            IPoint fromPoint = Segment.FromPoint;
            IPoint toPoint = Segment.ToPoint;
            //throw new NotImplementedException();
            
            //开启DDA算法
            double y1 = fromPoint.Y;
            double y2 = toPoint.Y;


            if (y1 > y2)
            {
                double ytemp = y1;
                y1 = y2;
                y2 = ytemp;
            }


            int starty = (int)((y1 - lowerrightY) / dY);
            int endy = (int)((y2 - lowerrightY) / dY);


            //最后一格
            if (endy == height)
            {
                endy = height - 1;
            }

            double p1X = fromPoint.X;
            double p1Y = fromPoint.Y;
            double p2X = toPoint.X;
            double p2Y = toPoint.Y;

            double firstY = lowerrightY + (starty+1) * dY;
            double lastY = lowerrightY + endy * dY;

            if (starty == endy)
            {
                int x1 = (int)((p1X - upperleftX) / dX);
                int x2 = (int)((p2X - upperleftX) / dX);

                if (x1 < 0)
                {
                    x1 = 0;
                }
                if (x1 >= width)
                {
                    x1 = width - 1;
                }

                if (x2 < 0)
                {
                    x2 = 0;
                }
                if (x2 >= width)
                {
                    x2 = width - 1;
                }

                if(x1 > x2)
                {
                    int xtemp = x1;
                    x1 = x2;
                    x2 = xtemp;
                }

                int offset = (height-1-starty)*width;
                for (int i = x1; i <= x2; i++)
                {
                    bt[offset + i] = 1;
                    try
                    {
                        bmp.SetPixel(i, height - 1 - starty, c);
                    }
                    catch (Exception ex)
                    {


                    }
                }
            }
            else
            {
                int x1 = (int)((p1X - upperleftX) / dX);
                int x2 = (int)((p2X - upperleftX) / dX);


                if (x1 < 0)
                {
                    x1 = 0;
                }
                if (x1 >= width)
                {
                    x1 = width - 1;
                }


                if (x2 < 0)
                {
                    x2 = 0;
                }
                if (x2 >= width)
                {
                    x2 = width - 1;
                }

                double deltaX = (p2X - p1X) * dY / (p2Y - p1Y); 

                if (p1Y > p2Y)
                {
                    double dfirstX = ((firstY - y1) / dY * deltaX + p2X - upperleftX);
                    int ifirstX =  (int)(((firstY - y1)/dY * deltaX + p2X - upperleftX) / dX);
                    int ilastX = (int)(((lastY - y1)/dY * deltaX + p2X - upperleftX) / dX);

                    if (ifirstX < 0)
                    {
                        ifirstX = 0;
                    }
                    if (ifirstX >= width)
                    {
                        ifirstX = width - 1;
                    }

                    if (ilastX < 0)
                    {
                        ilastX = 0;
                    }
                    if (ilastX >= width)
                    {
                        ilastX = width - 1;
                    }

                    int tmpx1 = x2;
                    int tmpx2 = ifirstX;
                    if(tmpx1 > tmpx2)
                    {
                        int tmpx = tmpx1;
                        tmpx1 = tmpx2;
                        tmpx2 = tmpx;
                    }

                    int offset = (height - 1 - starty) * width;

                    for (int i = tmpx1; i <= tmpx2; i++)
                    {
                        bt[offset + i] = 1;
                        try
                        {
                            bmp.SetPixel(i, height - 1 - starty, c);
                        }
                        catch (Exception ex)
                        {
                        }
                    }

                    tmpx1 = x1;
                    tmpx2 = ilastX;
                    if (tmpx1 > tmpx2)
                    {
                        int tmpx = tmpx1;
                        tmpx1 = tmpx2;
                        tmpx2 = tmpx;
                    }

                    offset = (height - 1 - endy) * width;
                    for (int i = tmpx1; i <= tmpx2; i++)
                    {
                        bt[offset + i] = 1;
                        try
                        {
                            bmp.SetPixel(i, height - 1 - endy, c);
                        }
                        catch (Exception ex)
                        {
                        }
                    }

                    double dSX = dfirstX;
                    for (int i = starty + 1; i < endy; i++)
                    {
                        offset = (height - 1 - i) * width;
                        tmpx1 = (int)(dSX / dX);
                        dSX += deltaX;
                        tmpx2 = (int)(dSX / dX);

                        if (tmpx1 < 0)
                        {
                            tmpx1 = 0;
                        }
                        if (tmpx1 >= width)
                        {
                            tmpx1 = width - 1;
                        }

                        if (tmpx2 < 0)
                        {
                            tmpx2 = 0;
                        }
                        if (tmpx2 >= width)
                        {
                            tmpx2 = width - 1;
                        }

                        if (tmpx1 > tmpx2)
                        {
                            int tmpx = tmpx1;
                            tmpx1 = tmpx2;
                            tmpx2 = tmpx;
                        }
                        for (int j = tmpx1; j <= tmpx2; j++)
                        {
                            bt[offset + j] = 1;
                            try
                            {
                                bmp.SetPixel(j, height - 1 - i, c);
                            }
                            catch (Exception ex)
                            {
                            }
                        }
                    }
                }
                else
                {
                    double dfirstX = ((firstY - y1) / dY * deltaX + p1X - upperleftX);
                    int ifirstX = (int)(((firstY - y1) / dY * deltaX + p1X - upperleftX) / dX);
                    int ilastX = (int)(((lastY - y1) / dY * deltaX + p1X - upperleftX) / dX);

                    if (ifirstX < 0)
                    {
                        ifirstX = 0;
                    }
                    if (ifirstX >= width)
                    {
                        ifirstX = width - 1;
                    }

                    if (ilastX < 0)
                    {
                        ilastX = 0;
                    }
                    if (ilastX >= width)
                    {
                        ilastX = width - 1;
                    }

                    int tmpx1 = x1;
                    int tmpx2 = ifirstX;
                    if (tmpx1 > tmpx2)
                    {
                        int tmpx = tmpx1;
                        tmpx1 = tmpx2;
                        tmpx2 = tmpx;
                    }

                    int offset = (height - 1 - starty) * width;

                    for (int i = tmpx1; i <= tmpx2; i++)
                    {
                        bt[offset + i] = 1;
                        try
                        {
                            bmp.SetPixel(i, height - 1 - starty, c);
                        }
                        catch (Exception ex)
                        {
                        }
                    }


                    tmpx1 = x2;
                    tmpx2 = ilastX;
                    if (tmpx1 > tmpx2)
                    {
                        int tmpx = tmpx1;
                        tmpx1 = tmpx2;
                        tmpx2 = tmpx;
                    }

                    offset = (height - 1 - endy) * width;
                    for (int i = tmpx1; i <= tmpx2; i++)
                    {
                        bt[offset + i] = 1;
                        try
                        {
                            bmp.SetPixel(i, height - 1 - endy, c);
                        }
                        catch (Exception ex)
                        {
                        }
                    }

                    double dSX = dfirstX;
                    for (int i = starty + 1; i < endy; i++)
                    {
                        offset = (height - 1 - i) * width;

                        tmpx1 = (int)(dSX / dX);
                        dSX += deltaX;
                        tmpx2 = (int)(dSX / dX);

                        if (tmpx1 < 0)
                        {
                            tmpx1 = 0;
                        }
                        if (tmpx1 >= width)
                        {
                            tmpx1 = width - 1;
                        }

                        if (tmpx2 < 0)
                        {
                            tmpx2 = 0;
                        }
                        if (tmpx2 >= width)
                        {
                            tmpx2 = width - 1;
                        }

                        if (tmpx1 > tmpx2)
                        {
                            int tmpx = tmpx1;
                            tmpx1 = tmpx2;
                            tmpx2 = tmpx;
                        }
                        for (int j = tmpx1; j <= tmpx2; j++)
                        {
                            bt[offset + j] = 1;
                            try
                            {
                                bmp.SetPixel(j, height - 1 - i, c);
                            }
                            catch (Exception ex)
                            {
                            }
                        }
                    }
                }
            }


        }



private int GetSit(IRelationalOperator perferro, IEnvelope tempenv, int opindex)
        {
            if (perferro.Contains(tempenv))
            {
                return opindex + 2;
            }
            else if (perferro.Overlaps(tempenv))
            {
                return 1;
            }
            else
            {
                return 0;
            }

           // throw new NotImplementedException();
        }



jiushidt
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
为数据库建立索引
12-14
象许多的PHP开发者一样，在刚开始建立动态网站的时候，我都是使用相对简单的数据结构。PHP在连接数据库方面的确实是十分方便（译者注：有些人认为 PHP...但却对如何为数据库建立适 当的索引所知较少，因此我起了写一篇
AE Tips：获取属性表中的所有记录
lzx的博客
06-05 249
// 获得第一个图层 IFeatureLayer fly = axMapControl1.get_Layer(0) as IFeatureLayer; // 获得属性表 IFeatureClass fc = fly.FeatureClass; // 获得游标 IFeatureCursor cursor = fc.Search(null, true); // 获得游标所代表的值 IFeature fea = cursor.NextFeature(); int cnt = 0; // 对属性表的记录进行遍历 w
IFeatureClass--2
jojojojo2002的专栏
11-25 2483
IFeatureClass.GetFeatures Method [Visual Basic.NET]        Public Function GetFeatures(ByVal fids As Object,ByVal Recycling As Boolean) As IFeatureCursor [C#]                             public IF
数据库创建索引的几种方法
热门推荐
weberhuangxingbo的博客
11-09 8万+
  1、普通索引      CREATE INDEX indexName ON mytable(username(length));      创建表的时候直接指定：  CREATE TABLE mytable(        ID INT NOT NULL,         username VARCHAR(16) NOT NULL,         INDEX [indexName] (...
建立索引的原则
https://www.cnblogs.com/hezemin/ 已经放弃CSDN了，请转移博客园！请转移博客园！请转移博客园！
06-24 647
第一步对执行计划的理解： explain（执行计划）包含的信息十分的丰富，着重关注以下几个字段信息。 ①id，select子句或表执行顺序，id相同，从上到下执行，id不同，id值越大，执行优先级越高。 ②type，type主要取值及其表示sql的好坏程度（由好到差排序）：system>const>eq_ref>ref>range>index>ALL。保证ran...
通过索引优化含ORDER BY的MySQL语句
爱码农爱生活
03-18 96
关于建立索引的几个准则： 1、合理的建立索引能够加速数据读取效率，不合理的建立索引反而会拖慢数据库的响应速度。 2、索引越多，更新数据的速度越慢。 3、尽量在采用MyIsam作为引擎的时候使用索引（因为MySQL以BTree存储索引），而不是InnoDB。但MyISAM不支持Transcation。 4、当你的程序和数据库结构/SQL语句已经优化到无法优化的程度，而程序瓶颈并不能顺利解决，...
Django 建立索引
NULL
06-18 4027
数据库数据规模挺大的，建立索引以加速查询。 通过db_index和Meta index选项给数据表字段建立索引 使用索引可快速访问数据库表中的特定信息。数据库索引好比是一本书前面的目录，没有索引目录的话，你访问书中某个页面需要从第1页遍历到最后一页，如果有目录，你可以快速地根据目录查找到所需要的页面。Django项目中如果你需要频繁地对数据表中的某些字段(如title)使用filter(), exclude()和order_by()方法进行查询，我们强烈建议你对这些字段建议索引(index), 提升查询
哪些字段适合建立索引
weixin_44390164的博客
09-16 5899
表的主键，外键 一般对重复元素少的字段进行建立索引 索引应该建立在选择性高的字段上 经常与其他表进行连表查询，在连接字段上可以建立索引 经常出现在where子句中的字段，应该建立索引 索引应该建立在小字段上，对于大的文本字段不要建立索引 ...
java 建立索引_java中怎么创建索引
weixin_36350504的博客
02-12 2850
java中创建索引的方法：首先把对象转换为JSON字符串；然后把json文档写入索引；最后使用Java代码新建一个Java项目，在其中写好创建索引代码调用就可以了。索引是与表或视图关联的磁盘上结构，可以加快从表或视图中检索行的速度。索引包含由表或视图中的一列或多列生成的键。索引其实关键目的是为了加快检索速度而建立的，所以，怎么用索引是数据库系统本身的事情，作为数据库设计或使用者，设计并创建好索引然...
数据库如何建立索引
Jacson__的博客
07-16 1万+
数据库如何建立索引
mysql建立索引原则
debugmyworld
08-05 4886
一、数据库索引创建规则 1、表的主键、外键必须有索引； 2、数据量超过300的表应该有索引； 3、经常与其他表进行连接的表，在连接字段上应该建立索引； 4、经常出现在Where子句中的字段，特别是大表的字段，应该建立索引； 5、索引应该建在选择性高的字段上； 6、索引应该建在小字段上，对于大的文本字段甚至超长字段，不要建索引； 7、复合索引的建立需要进行仔细分析；尽量考虑用单字段索引代替： 　正确选择复合索引中的主列字段，一般是选择性较好的字段； 　复合索引的几个字段是否经常同时以AND方式出现在Where
数据库建立索引的一般依据小结
09-11
以下是一些普遍的建立索引时的判断依据。一言以蔽之，索引的建立必须慎重，对每个索引的必要性都应该经过仔细分析，要有建立的依据
数据库为何要建立索引的原因说明
09-11
数据库索引是为了增加查询速度而对表字段附加的一种标识。见过很多人机械的理解索引的概念，认为增加索引只有好处没有坏处。
mssql 建立索引第1/2页
09-11
假设你想找到本书中的某一个句子。你可以一页一页地逐页搜索，但这会花很多时间。而通过使用本书的索引，你可以很快地找到你要搜索的主题。
MySQL中建立索引的集中方式
12-14
　在数据库表中，对字段建立索引可以大大提高查询速度。假如我们创建了一个 mytable表： 　CREATE TABLE mytable( ID INT NOT NULL， username VARCHAR(16) NOT NULL ); 我们随机向里面插入了10000条记录，...
基于risc-V的五级流水线CPU实验项目源码+文档说明.zip
05-23
基于risc-V的五级流水线CPU实验项目源码+文档说明.zip已获导师指导并通过的97分的高分课程设计项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 基于risc-V的五级流水线CPU实验项目源码+文档说明.zip已获导师指导并通过的97分的高分课程设计项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 基于risc-V的五级流水线CPU实验项目源码+文档说明.zip已获导师指导并通过的97分的高分课程设计项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 基于risc-V的五级流水线CPU实验项目源码+文档说明.zip已获导师指导并通过的97分的高分课程设计项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 基于risc-V的五级流水线CPU实验项目源码+文档说明.zip已获导师指导并通过的97分的高分课程设计项目，可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 基于risc-V的五级流水线CPU实验项目源码+文档说明.zip已获导师指导并通过的97分的高分课程
IMG_20240523_164715.jpg
05-23
IMG_20240523_164715.jpg
Unity使用人工智能模型进行数字识别（Sentis）
05-23
Unity使用人工智能模型进行数字识
mobilenet模型-python语言pytorch框架的图像分类食品口味分类识别-不含数据集图片-含逐行注释和说明文档
最新发布
05-23
mobilenet模型_python语言pytorch框架的图像分类食品口味分类识别-不含数据集图片-含逐行注释和说明文档 本代码是基于python pytorch环境安装的。 下载本代码后，有个环境安装的requirement.txt文本 如果有环境安装不会的，可自行网上搜索如何安装python和pytorch,这些环境安装都是有很多教程的，简单的 环境需要自行安装,推荐安装anaconda然后再里面推荐安装python3.7或3.8的版本，pytorch推荐安装1.7.1或1.8.1版本 首先是代码的整体介绍 总共是3个py文件，十分的简便 且代码里面的每一行都是含有中文注释的,小白也能看懂代码 然后是关于数据集的介绍。 本代码是不含数据集图片的，下载本代码后需要自行搜集图片放到对应的文件夹下即可 在数据集文件夹下是我们的各个类别,这个类别不是固定的，可自行创建文件夹增加分类数据集 需要我们往每个文件夹下搜集来图片放到对应文件夹下，每个对应的文件夹里面也有一张提示图，提示图片放的位置 然后我们需要将搜集来的图片，直接放到对应的文件夹下，就可以对代码进行训练了。
mongodbcompass建立索引
07-28
要在MongoDB Compass中建立索引，您可以按照以下步骤进行操作： 1. 打开MongoDB Compass应用程序并连接到您的数据库。您可以在连接界面中输入相应的主机和端口信息。如果没有用户认证，认证字段可以留空。点击...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值