常见的查询索引

_id索引

        _id 索引是绝大多数集合默认建立的索引。对于每一个插入的数据。MongoDB 会自己主动生成一条唯一的 _id 字段。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
> db.jerome_2.collection.insert({x:2})
WriteResult({ "nInserted" : 1 })
> db.jerome_2.collection.getIndexes()
[
    {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "jerome.jerome_2.collection"
    }
]
> db.jerome_2.collection.findOne()
{ "_id" : ObjectId("557004f1f2824fa15224e20b"), "x" : 2 }
> 

单键索引

        单键索引是最普通的索引，与_id 索引不同。单键索引不会自己主动创建。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
> db.jerome_2.collection.ensureIndex({x:1}) # 创建单键索引
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
> db.jerome_2.collection.getIndexes()
[
    {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "jerome.jerome_2.collection"
    },
    {
        "v" : 1,
        "key" : {
            "x" : 1
        },
        "name" : "x_1",
        "ns" : "jerome.jerome_2.collection"
    }
]
> db.jerome_2.collection.find({x:1}) #使用创建的索引查询
{ "_id" : ObjectId("557005a5f2824fa15224e20c"), "x" : 1, "y" : 2, "z" : 3 }
> 

多键索引

        多键索引和单键索引创建形式同样，差别在于字段的值。

        单键索引：值为一个单一的值，比如字符串，数字或者日期。
        多键索引：值具有多个记录，比如数组。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
> db.jerome_2.collection.getIndexes()
[
    {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "jerome.jerome_2.collection"
    },
    {
        "v" : 1,
        "key" : {
            "x" : 1
        },
        "name" : "x_1",
        "ns" : "jerome.jerome_2.collection"
    }
]
> db.jerome_2.collection.find()
{ "_id" : ObjectId("557004f1f2824fa15224e20b"), "x" : 2 }
{ "_id" : ObjectId("557005a5f2824fa15224e20c"), "x" : 1, "y" : 2, "z" : 3 }
> db.jeroem_2.collection.insert({x:[1,2,3,4,5]}) #插入一条数组数据，对于这条数据来讲。mongodb为其创建了一个多键索引
WriteResult({ "nInserted" : 1 })

复合索引

    
        当我们的查询条件不仅仅有一个时。就须要建立复合索引。
1
2
3
4
5
6
7
8
9
10
> db.jerome_2.collection.ensureIndex({x:1,y:1}) #创建
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 2,
    "numIndexesAfter" : 3,
    "ok" : 1
}
> db.jerome_2.collection.find({x:1,y:2}) #使用
{ "_id" : ObjectId("557005a5f2824fa15224e20c"), "x" : 1, "y" : 2, "z" : 3 }
> 

过期索引

        过期索引是在一段时间后会过期的索引。在索引过期后，对应的数据会被删除。这适合存储一些在一段时间之后会失效的数据。比方用户的登陆信息、存储的日志等。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
> db.jerome_2.collection.ensureIndex({time:1},{expireAfterSeconds:30}) #创建过期索引，过期时间30秒
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 3,
    "numIndexesAfter" : 4,
    "ok" : 1
}
> db.jerome_2.collection.insert({time:new Date()}) #插入数据測试
WriteResult({ "nInserted" : 1 })
> db.jerome_2.collection.find()
{ "_id" : ObjectId("557004f1f2824fa15224e20b"), "x" : 2 }
{ "_id" : ObjectId("557005a5f2824fa15224e20c"), "x" : 1, "y" : 2, "z" : 3 }
{ "_id" : ObjectId("55700b17f2824fa15224e20e"), "time" : ISODate("2015-06-04T08:23:51.531Z") }
> db.jerome_2.collection.find()
{ "_id" : ObjectId("557004f1f2824fa15224e20b"), "x" : 2 }
{ "_id" : ObjectId("557005a5f2824fa15224e20c"), "x" : 1, "y" : 2, "z" : 3 }
{ "_id" : ObjectId("55700b17f2824fa15224e20e"), "time" : ISODate("2015-06-04T08:23:51.531Z") }
> db.jerome_2.collection.find() #时间过了就找不到了
{ "_id" : ObjectId("557004f1f2824fa15224e20b"), "x" : 2 }
{ "_id" : ObjectId("557005a5f2824fa15224e20c"), "x" : 1, "y" : 2, "z" : 3 }
> 
使用限制
        1. 存储在过期索引字段的值必须是指定的时间类型。

（必须是ISODate或者ISODate数组，不能使用时间戳。否则不能被自己主动删除）

        2. 假设指定了ISODate数组。则依照最小的时间进行删除。
        3. 过期索引不能是复合索引。
        4. 删除时间不是精确的。（删除过程是由后台程序没60s跑一次，并且删除也须要一些时间，所以存在误差）

全文索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
> db.jerome_2.ensureIndex({"article":"text"}) #创建全文可搜索索引
{
    "createdCollectionAutomatically" : true,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
> db.jerome_2.insert({"article":"aa bb cc dd ee"}) #插入測试数据
WriteResult({ "nInserted" : 1 })
> db.jerome_2.insert({"article":"aa bb rr gg zz"})
WriteResult({ "nInserted" : 1 })
> db.jerome_2.insert({"article":"aa bb"})
WriteResult({ "nInserted" : 1 })
> db.jerome_2.insert({"article":"aa bb cc zz ff ww"})
WriteResult({ "nInserted" : 1 })
> db.jerome_2.find({$text:{$search:"aa"}}) #查找
{ "_id" : ObjectId("5572904271c0bbd90f4ce0e2"), "article" : "aa bb rr gg zz" }
{ "_id" : ObjectId("5572903371c0bbd90f4ce0e1"), "article" : "aa bb cc dd ee" }
{ "_id" : ObjectId("5572905671c0bbd90f4ce0e4"), "article" : "aa bb cc zz ff ww" }
{ "_id" : ObjectId("5572904771c0bbd90f4ce0e3"), "article" : "aa bb" }
> db.jerome_2.find({$text:{$search:"ff"}})
{ "_id" : ObjectId("5572905671c0bbd90f4ce0e4"), "article" : "aa bb cc zz ff ww" }
> db.jerome_2.find({$text:{$search:"aa bb cc"}}) #空格表示或
{ "_id" : ObjectId("5572904271c0bbd90f4ce0e2"), "article" : "aa bb rr gg zz" }
{ "_id" : ObjectId("5572903371c0bbd90f4ce0e1"), "article" : "aa bb cc dd ee" }
{ "_id" : ObjectId("5572905671c0bbd90f4ce0e4"), "article" : "aa bb cc zz ff ww" }
{ "_id" : ObjectId("5572904771c0bbd90f4ce0e3"), "article" : "aa bb" }
> db.jerome_2.find({$text:{$search:"aa bb -cc"}}) #-cc 表示不包括cc
{ "_id" : ObjectId("5572904271c0bbd90f4ce0e2"), "article" : "aa bb rr gg zz" }
{ "_id" : ObjectId("5572904771c0bbd90f4ce0e3"), "article" : "aa bb" }
> db.jerome_2.find({$text:{$search:"\"aa\" \"bb\" \"cc\""}}) #加引號，表示与
{ "_id" : ObjectId("5572903371c0bbd90f4ce0e1"), "article" : "aa bb cc dd ee" }
{ "_id" : ObjectId("5572905671c0bbd90f4ce0e4"), "article" : "aa bb cc zz ff ww" }
> 
全文索引类似度
        $meta操作符：｛score：｛$meta:"textScore"｝｝，返回结果的类似度，与 sort 一起使用能够达到非常好的有用效果。
1
2
3
4
5
6
7
8
9
10
11
> db.jerome_2.find({$text:{$search:"aa bb"}},{score:{$meta:"textScore"}}) #score越高，类似度越高。
{ "_id" : ObjectId("5572904271c0bbd90f4ce0e2"), "article" : "aa bb rr gg zz", "score" : 1.2 }
{ "_id" : ObjectId("5572903371c0bbd90f4ce0e1"), "article" : "aa bb cc dd ee", "score" : 1.2 }
{ "_id" : ObjectId("5572905671c0bbd90f4ce0e4"), "article" : "aa bb cc zz ff ww", "score" : 1.1666666666666667 }
{ "_id" : ObjectId("5572904771c0bbd90f4ce0e3"), "article" : "aa bb", "score" : 1.5 }
> db.jerome_2.find({$text:{$search:"aa bb"}},{score:{$meta:"textScore"}}).sort({score:{$meta:"textScore"}}) #依据score进行排序
{ "_id" : ObjectId("5572904771c0bbd90f4ce0e3"), "article" : "aa bb", "score" : 1.5 }
{ "_id" : ObjectId("5572903371c0bbd90f4ce0e1"), "article" : "aa bb cc dd ee", "score" : 1.2 }
{ "_id" : ObjectId("5572904271c0bbd90f4ce0e2"), "article" : "aa bb rr gg zz", "score" : 1.2 }
{ "_id" : ObjectId("5572905671c0bbd90f4ce0e4"), "article" : "aa bb cc zz ff ww", "score" : 1.1666666666666667 }
> 
使用限制
        1. 每次查询仅仅能指定一个$text查询
        2. $text查询不能出如今$nor查询中
        3. 查询中假设包括了$text。hint不再起作用
        4. MongoDB 索引如今还不支持中文

地理位置索引

概念：
        将一些点的位置存储在 MongoDB 中。创建索引后，能够依照位置来查找其它点。

分类：
        1. 2d 索引。用于存储和查找平面上的点。
        2. 2dsphere 索引，用于存储和查找球面上的点。

查找方式：
        1. 查找距离某个点一定距离内的点。
        2. 查找包括在某区域内的点。
2d索引
    
1. $near查询
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
> db.location.ensureIndex({"w":"2d"}) #创建2d索引
> db.location.insert({w:[1,1]}) #插入測试数据。经纬度[经度，纬度]。

取值范围：经度[-180,180] 纬度[-90,90]

WriteResult({ "nInserted" : 1 })
> db.location.insert({w:[1,2]})
WriteResult({ "nInserted" : 1 })
> db.location.insert({w:[2,3]})
WriteResult({ "nInserted" : 1 })
> db.location.insert({w:[100,80]})
WriteResult({ "nInserted" : 1 })
> db.location.find({w:{$near:[1,1]}}) #查询距离某个点近期的点
{ "_id" : ObjectId("5572a961aba41684d6e8826c"), "w" : [ 1, 1 ] }
{ "_id" : ObjectId("5572a965aba41684d6e8826d"), "w" : [ 1, 2 ] }
{ "_id" : ObjectId("5572a970aba41684d6e8826e"), "w" : [ 2, 3 ] }
{ "_id" : ObjectId("5572a97aaba41684d6e8826f"), "w" : [ 100, 80 ] }
> db.location.find({w:{$near:[1,1],$maxDistance:2}}) #能够使用maxDistance限制（near不能使用minDistance）
{ "_id" : ObjectId("5572a961aba41684d6e8826c"), "w" : [ 1, 1 ] }
{ "_id" : ObjectId("5572a965aba41684d6e8826d"), "w" : [ 1, 2 ] }
2. $geoWithin查询
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
> db.location.find({w:{$geoWithin:{$box:[[0,0],[3,3]]}}}) #矩形
{ "_id" : ObjectId("5572a965aba41684d6e8826d"), "w" : [ 1, 2 ] }
{ "_id" : ObjectId("5572a970aba41684d6e8826e"), "w" : [ 2, 3 ] }
{ "_id" : ObjectId("5572a961aba41684d6e8826c"), "w" : [ 1, 1 ] }
> db.location.find({w:{$geoWithin:{$box:[[1,2],[2,3]]}}})
{ "_id" : ObjectId("5572a965aba41684d6e8826d"), "w" : [ 1, 2 ] }
{ "_id" : ObjectId("5572a970aba41684d6e8826e"), "w" : [ 2, 3 ] }
> db.location.find({w:{$geoWithin:{$center:[[0,0],100]}}}) #圆形。100是半径
{ "_id" : ObjectId("5572a961aba41684d6e8826c"), "w" : [ 1, 1 ] }
{ "_id" : ObjectId("5572a970aba41684d6e8826e"), "w" : [ 2, 3 ] }
{ "_id" : ObjectId("5572a965aba41684d6e8826d"), "w" : [ 1, 2 ] }
> db.location.find({w:{$geoWithin:{$center:[[0,0],1000]}}})
{ "_id" : ObjectId("5572a961aba41684d6e8826c"), "w" : [ 1, 1 ] }
{ "_id" : ObjectId("5572a97aaba41684d6e8826f"), "w" : [ 100, 80 ] }
{ "_id" : ObjectId("5572a970aba41684d6e8826e"), "w" : [ 2, 3 ] }
{ "_id" : ObjectId("5572a965aba41684d6e8826d"), "w" : [ 1, 2 ] }
> db.location.find({w:{$geoWithin:{$polygon:[[0,0],[0,1],[2,5],[6,1]]}}}) #多边形查询（各个点围成的多边形的范围）
{ "_id" : ObjectId("5572a970aba41684d6e8826e"), "w" : [ 2, 3 ] }
{ "_id" : ObjectId("5572a961aba41684d6e8826c"), "w" : [ 1, 1 ] }
{ "_id" : ObjectId("5572a965aba41684d6e8826d"), "w" : [ 1, 2 ] }
> db.location.find({w:{$geoWithin:{$polygon:[[0,0],[0,1],[2,5],[6,1000],[1001,0]]}}})
{ "_id" : ObjectId("5572a970aba41684d6e8826e"), "w" : [ 2, 3 ] }
{ "_id" : ObjectId("5572a97aaba41684d6e8826f"), "w" : [ 100, 80 ] }
{ "_id" : ObjectId("5572a961aba41684d6e8826c"), "w" : [ 1, 1 ] }
{ "_id" : ObjectId("5572a965aba41684d6e8826d"), "w" : [ 1, 2 ] }
3. 使用geoNear查询
geoNear使用runCommand命令进行使用
db.runCommand(
    {getNear:<collection>,
    near:[x,y],
    minDistance:(对2d索引无效)
    maxDistance:
    num:
}
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
> db.runCommand({geoNear:"location",near:[1,2],maxDistance:10,num:1})
{
    "results" : [
        {
            "dis" : 0,
            "obj" : {
                "_id" : ObjectId("5572a965aba41684d6e8826d"),
                "w" : [
                    1,
                    2
                ]
            }
        }
    ],
    "stats" : {
        "nscanned" : NumberLong(1),
        "objectsLoaded" : NumberLong(1),
        "avgDistance" : 0,
        "maxDistance" : 0,
        "time" : 2
    },
    "ok" : 1
}
> 
2dsphere 球面地理位置索引
        概念：球面地理位置索引。
        创建方式：db.collection.ensureIndex({w:"2dsphere"})
        位置表示方式：
            GeoJson：描写叙述一个点。一条直线，多边形等形状
        格式：{type:"",coordinates:[<coordinates>]}
        支持$minDistance与$maxDistance

创建索引比較重要属性介绍

格式
    db.collection.ensureIndex({param},{param}) #第二个參数是索引的属性
比較重要的属性有：名字、唯一性、稀疏性、是否定时删除。

1. 名字，name指定：db.collection.ensureIndex({},{name:""})

    默认命名格式是例如以下这种
    单键索引。1和-1，命名是依据key+_1/-1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
> db.jerome_2.ensureIndex({x:1})
> db.jerome_2.ensureIndex({y:-1})
> db.jerome_2.getIndexes()
[
    {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "jerome.jerome_2"
    },
    {
        "v" : 1,
        "key" : {
            "x" : 1
        },
        "name" : "x_1",
        "ns" : "jerome.jerome_2"
    },
    {
        "v" : 1,
        "key" : {
            "y" : -1
        },
        "name" : "y_-1",
        "ns" : "jerome.jerome_2"
    }
    复合索引
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
> db.jerome_2.ensureIndex({x:1,y:-1})
> db.jerome_2.ensureIndex({x:1,y:-1,z:1})
> db.jerome_2.getIndexes()
[
    {
        "v" : 1,
        "key" : {
            "x" : 1,
            "y" : -1
        },
        "name" : "x_1_y_-1",
        "ns" : "jerome.jerome_2"
    },
    {
        "v" : 1,
        "key" : {
            "x" : 1,
            "y" : -1,
            "z" : 1
        },
        "name" : "x_1_y_-1_z_1",
        "ns" : "jerome.jerome_2"
    }
]
MongoDB 对索引限制是125字节，所以我们须要自己定义索引名字。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
> db.jerome_2.ensureIndex({x:1,y:1,z:1,m:1},{name:"normal_index"})
> db.jerome_2.getIndexes()
[
    {
        "v" : 1,
        "key" : {
            "x" : 1,
            "y" : 1,
            "z" : 1,
            "m" : 1
        },
        "name" : "normal_index",
        "ns" : "jerome.jerome_2"
    }
]
> db.jerome_2.dropIndex("normal_index")
{ "nIndexesWas" : 7, "ok" : 1 }
> 

2. 唯一性。unique 指定：db.collection.ensureIndex({},{unique:true/false})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
> db.jerome.ensureIndex({m:1,n:1},{unique:true})
{
    "createdCollectionAutomatically" : true,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}
> db.jerome.insert({m:1,n:2})
WriteResult({ "nInserted" : 1 })
> db.jerome.insert({m:1,n:2})
WriteResult({
    "nInserted" : 0,
    "writeError" : {
        "code" : 11000,
        "errmsg" : "insertDocument :: caused by :: 11000 E11000 duplicate key error index: jerome.jerome.$m_1_n_1  dup key: { : 1.0, : 2.0 }"
    }
})
> 

3. 稀疏性，sparse 指定：db.collection.ensureIndex({},{sparse:true/false})

        默认创建的索引是不稀疏的。

由于 MongoDB 没有固定的格式，插入的时候可能插入不存在的字段。比方x：1，MongoDB 会为这条不存在的字段创建索引。假设不希望发现这种事情能够指定稀疏索引为 true，就不会为不存在的字段创建索引了。

能够降低磁盘占用和增大插入速度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
> db.jerome.insert({"m":1})
WriteResult({ "nInserted" : 1 })
> db.jerome.insert({"n":1})
WriteResult({ "nInserted" : 1 })
> db.jerome.find({m:{$exists:true}}) #exists查找数据集合中一个字段存在或者不存在的记录
{ "_id" : ObjectId("55729ec1aba41684d6e8826a"), "m" : 1 }
{ "_id" : ObjectId("55729d5caba41684d6e88268"), "m" : 1, "n" : 2 }
> db.jerome.ensureIndex({m:1},{sparse:true}) #创建稀疏索引
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 2,
    "numIndexesAfter" : 3,
    "ok" : 1
}
> db.jerome.find({m:{$exists:false}}) #MongoDB内部问题。所以找得到，通过以下强制指定索引
{ "_id" : ObjectId("55729ec7aba41684d6e8826b"), "n" : 1 }
> db.jerome.find({m:{$exists:false}}).hint("m_1") #以下这条记录。不存在m字段，所以不会创建索引。所以查不到记录 
> 
        注意：不能在稀疏索引上查找这个字段不存在的记录。

4. 是否定时删除

        过期索引，前面已介绍。
參考
        1. 慕课网

MongoDB 常见的查询索引的更多相关文章

  1. mongoDB常见的查询索引（三）

    1. _id索引     _id索引是绝大多数集合默认建立的索引     对于每个插入的数据,MongoDB会自动生成一条唯一的_id字段. 1 2 3 4 5 6 7 8 9 10 11 12 13 ...

  2. Mongodb 常见的查询语句及与 mysql 对比

    db.users.find()select * from users db.users.find({"age" : 27})select * from users where ag ...

  3. spring Mongodb查询索引报错 java.lang.NumberFormatException: empty String

    最近事情比较多,本篇文章算是把遇到的问题杂糅到一起了. 背景:笔者最近在写一个mongo查询小程序,由于建立索引时字段名用大写,而查询的时候用小写. 代码如下: db.getCollection(&q ...

  4. java mongodb 基础系列---查询，排序，limit，$in,$or,输出为list,创建索引,$ne 非操作

    官方api教程:http://docs.mongodb.org/ecosystem/tutorial/getting-started-with-java-driver/#getting-started ...

  5. Mongodb 笔记03 查询、索引

    查询 1. MongoDB使用find来进行查询.find的第一个参数决定了要返回哪些文档,这个参数是一个文档,用于指定查询条件.空的查询会匹配集合的全部内容.要是不指定查询,默认是{}. 2. 可以 ...

  6. MongoDB优化，建立索引实例及索引机制原理讲解

    MongoDB优化,建立索引实例及索引机制原理讲解 为什么需要索引? 当你抱怨MongoDB集合查询效率低的时候,可能你就需要考虑使用索引了,为了方便后续介绍,先科普下MongoDB里的索引机制(同样 ...

  7. mongodb 高级聚合查询

    mongodb高级聚合查询   在工作中会经常遇到一些mongodb的聚合操作,特此总结下.mongo存储的可以是复杂类型,比如数组.对象等mysql不善于处理的文档型结构,并且聚合的操作也比mysq ...

  8. Mysql常见四种索引的使用

    提到MySQL优化,索引优化是必不可少的.其中一种优化方式 --索引优化,添加合适的索引能够让项目的并发能力和抗压能力得到明显的提升. 我们知道项目性能的瓶颈主要是在"查(select)&q ...

  9. 【mongoDB中级篇②】索引与expain

    索引的操作 数据库百分之八十的工作基本上都是查询,而索引能帮我们更快的查询到想要的数据.但是其降低了数据的写入速度,所以要权衡常用的查询字段,不必在太多字段上建立索引. 在mongoDB中默认是用bt ...

随机推荐

  1. Jquery操作基本筛选过滤器

    <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title> ...

  2. Netty源码学习（三）NioEventLoop

    0. NioEventLoop简介 NioEventLoop如同它的名字,它是一个无限循环(Loop),在循环中不断处理接收到的事件(Event) 在Reactor模型中,NioEventLoop就是 ...

  3. 计蒜客 28449.算个欧拉函数给大家助助兴-大数的因子个数 (HDU5649.DZY Loves Sorting) ( ACM训练联盟周赛 G)

    ACM训练联盟周赛 这一场有几个数据结构的题,但是自己太菜,不会树套树,带插入的区间第K小-替罪羊套函数式线段树, 先立个flag,BZOJ3065: 带插入区间K小值 计蒜客 Zeratul与Xor ...

  4. CodeForces 450B Jzzhu and Sequences 【矩阵快速幂】

    Jzzhu has invented a kind of sequences, they meet the following property: You are given x and y, ple ...

  5. kibana-metric

    1. Visualize 新建图形 2. 选择图形类型 3. 选择索引 4. 设置metric参数 4.1 count 4.2 unique count 5. 保存图形

  6. Number of Connected Components in an Undirected Graph -- LeetCode

    Given n nodes labeled from 0 to n - 1 and a list of undirected edges (each edge is a pair of nodes), ...

  7. Python学习笔记——模块

    使用模块 python中包的组织方式是模块,一个使用其它模块的例子如下: # Filename: using_sys.py import sys print 'The command line arg ...

  8. sql查询,如果有更新时间则按更新时间倒序,没有则按创建时间倒序排列

    原文:sql查询,如果有更新时间则按更新时间倒序,没有则按创建时间倒序排列 ORDER BY IFNULL(update_time,create_time) DESC IFNULL(expr1,exp ...

  9. linux的file指令

    显示文件的类型,用命令 file 可以使你知道某个文件究竟是ELF格式的可执行文件, 还是shell script文 件或是其他的什么格式 例如:#file startx 语 法:file [-beL ...

  10. asp.net mvc 生成二维码

    生成二维码,帮助类: using Gma.QrCodeNet.Encoding; using Gma.QrCodeNet.Encoding.Windows.Render; using System; ...