允许根据字段值折叠搜索结果。通过按折叠键选择顶部排序文档来完成折叠。例如,下面的查询检索每个用户的最佳推文,并按喜欢的数量对它们进行排序。

  1. GET /twitter/_search
  2. {
  3. "query": {
  4. "match": {
  5. "message": "elasticsearch"
  6. }
  7. },
  8. "collapse" : {
  9. "field" : "user"
  10. },
  11. "sort": ["likes"],
  12. "from": 10
  13. }

使用“user”字段折叠结果集

按喜欢的数量对顶级文档进行排序

定义第一个折叠结果的偏移量

响应中的总命中数表示没有折叠的匹配文档的数量。不同组的总数是未知的。

用于折叠的字段必须是 keyword 或numeric已激活doc_values的字段

折叠仅应用于顶部匹配,不会影响聚合

Expand collapse result

也可以使用inner_hits选项展开每个折叠的顶部命中。

  1. GET /twitter/_search
  2. {
  3. "query": {
  4. "match": {
  5. "message": "elasticsearch"
  6. }
  7. },
  8. "collapse" : {
  9. "field" : "user",
  10. "inner_hits": {
  11. "name": "last_tweets",
  12. "size": 5,
  13. "sort": [{ "date": "asc" }]
  14. },
  15. "max_concurrent_group_searches": 4
  16. },
  17. "sort": ["likes"]
  18. }

使用“user”字段折叠结果集

用于响应中内部命中部分的名称

每个折叠键检索的inner_hits数

如何对每个组内的文档进行排序

允许每组检索inner_hits`的并发请求数

有关支持的选项的完整列表和响应的格式,请参阅内部命中

inner_hits每次折叠命中也可以请求多个。当您想要获得折叠命中的多个表示时,这可能很有用。

  1. GET /twitter/_search
  2. {
  3. "query": {
  4. "match": {
  5. "message": "elasticsearch"
  6. }
  7. },
  8. "collapse" : {
  9. "field" : "user",
  10. "inner_hits": [
  11. {
  12. "name": "most_liked",
  13. "size": 3,
  14. "sort": ["likes"]
  15. },
  16. {
  17. "name": "most_recent",
  18. "size": 3,
  19. "sort": [{ "date": "asc" }]
  20. }
  21. ]
  22. },
  23. "sort": ["likes"]
  24. }

使用“user”字段折叠结果集

返回给用户最喜欢的三条推文

返回给用户的三条最新推文

通过为inner_hit响应中返回的每个折叠命中的每个请求发送附加查询来完成组的扩展 。如果您有太多的组和/或inner_hit请求,这可能会显着减慢速度。

所述max_concurrent_group_searches请求参数可用于控制允许在这个阶段并行搜索的最大数目。默认值基于数据节点数和默认搜索线程池大小。

collapse不能与滚动, 重新结合或搜索结合使用

Second level of collapsing 二级折叠

还支持并应用第二级折叠inner_hits。例如,以下请求查找每个国家/地区的最高得分推文,并且在每个国家/地区内查找每个用户的得分最高的推文。

二级折叠是不允许的inner_hits

  1. GET /twitter/_search
  2. {
  3. "query": {
  4. "match": {
  5. "message": "elasticsearch"
  6. }
  7. },
  8. "collapse" : {
  9. "field" : "country",
  10. "inner_hits" : {
  11. "name": "by_location",
  12. "collapse" : {"field" : "user"},
  13. "size": 3
  14. }
  15. }
  16. }

响应:

  1. {
  2. ...
  3. "hits": [
  4. {
  5. "_index": "twitter",
  6. "_type": "_doc",
  7. "_id": "9",
  8. "_score": ...,
  9. "_source": {...},
  10. "fields": {"country": ["UK"]},
  11. "inner_hits":{
  12. "by_location": {
  13. "hits": {
  14. ...,
  15. "hits": [
  16. {
  17. ...
  18. "fields": {"user" : ["user124"]}
  19. },
  20. {
  21. ...
  22. "fields": {"user" : ["user589"]}
  23. },
  24. {
  25. ...
  26. "fields": {"user" : ["user001"]}
  27. }
  28. ]
  29. }
  30. }
  31. }
  32. },
  33. {
  34. "_index": "twitter",
  35. "_type": "_doc",
  36. "_id": "1",
  37. "_score": ..,
  38. "_source": {...},
  39. "fields": {"country": ["Canada"]},
  40. "inner_hits":{
  41. "by_location": {
  42. "hits": {
  43. ...,
  44. "hits": [
  45. {
  46. ...
  47. "fields": {"user" : ["user444"]}
  48. },
  49. {
  50. ...
  51. "fields": {"user" : ["user1111"]}
  52. },
  53. {
  54. ...
  55. "fields": {"user" : ["user999"]}
  56. }
  57. ]
  58. }
  59. }
  60. }
  61. },
  62. ....
  63. ]
  64. }

实例

下面来看看具体的例子,就知道怎么回事了,使用起来很简单。

  • 先准备索引和数据,这里以菜谱为例,name:菜谱名,type 为菜系,rating 为用户的累积平均评分
  1. PUT recipes
  2. POST /recipes/type/_mapping
  3. {
  4. "properties": {
  5. "name":{
  6. "type": "text"
  7. },
  8. "rating":{
  9. "type": "float"
  10. },"type":{
  11. "type": "keyword"
  12. }
  13. }
  14. }
  15. /recipes/_bulk
  16. { "index": { "_index": "recipes", "_type": "type"}}
  17. {"name":"清蒸鱼头","rating":1,"type":"湘菜"}
  18. { "index": { "_index": "recipes", "_type": "type"}}
  19. {"name":"剁椒鱼头","rating":2,"type":"湘菜"}
  20. { "index": { "_index": "recipes", "_type": "type"}}
  21. {"name":"红烧鲫鱼","rating":3,"type":"湘菜"}
  22. { "index": { "_index": "recipes", "_type": "type"}}
  23. {"name":"鲫鱼汤(辣)","rating":3,"type":"湘菜"}
  24. { "index": { "_index": "recipes", "_type": "type"}}
  25. {"name":"鲫鱼汤(微辣)","rating":4,"type":"湘菜"}
  26. { "index": { "_index": "recipes", "_type": "type"}}
  27. {"name":"鲫鱼汤(变态辣)","rating":5,"type":"湘菜"}
  28. { "index": { "_index": "recipes", "_type": "type"}}
  29. {"name":"广式鲫鱼汤","rating":5,"type":"粤菜"}
  30. { "index": { "_index": "recipes", "_type": "type"}}
  31. {"name":"鱼香肉丝","rating":2,"type":"川菜"}
  32. { "index": { "_index": "recipes", "_type": "type"}}
  33. {"name":"奶油鲍鱼汤","rating":2,"type":"西菜"}
  • 现在我们看看普通的查询效果是怎么样的,搜索关键字带“鱼”的菜,返回3条数据
  1. POST recipes/type/_search
  2. {
  3. "query": {"match": {
  4. "name": "鱼"
  5. }},"size": 3
  6. } 

全是湘菜,我的天,最近上火不想吃辣,这个第一页的结果对我来说就是垃圾,如下:

  1. {
  2.   "took": 2,
  3.   "timed_out": false,
  4.   "_shards": {
  5.     "total": 5,
  6.     "successful": 5,
  7.     "failed": 0
  8.   },
  9.   "hits": {
  10.     "total": 9,
  11.     "max_score": 0.26742277,
  12.     "hits": [
  13.       {
  14.         "_index": "recipes",
  15.         "_type": "type",
  16.         "_id": "AVoESHYF_OA-dG63Txsd",
  17.         "_score": 0.26742277,
  18.         "_source": {
  19.           "name": "鲫鱼汤(变态辣)",
  20.           "rating": 5,
  21.           "type": "湘菜"
  22.         }
  23.       },
  24.       {
  25.         "_index": "recipes",
  26.         "_type": "type",
  27.         "_id": "AVoESHXO_OA-dG63Txsa",
  28.         "_score": 0.19100356,
  29.         "_source": {
  30.           "name": "红烧鲫鱼",
  31.           "rating": 3,
  32.           "type": "湘菜"
  33.         }
  34.       },
  35.       {
  36.         "_index": "recipes",
  37.         "_type": "type",
  38.         "_id": "AVoESHWy_OA-dG63TxsZ",
  39.         "_score": 0.19100356,
  40.         "_source": {
  41.           "name": "剁椒鱼头",
  42.           "rating": 2,
  43.           "type": "湘菜"
  44.         }
  45.       }
  46.     ]
  47.   }
  48. }
  • 我们再看看,这次我想加个评分排序,大家都喜欢的是那些,看看有没有喜欢吃的,执行查询:
  1. POST recipes/type/_search
  2. {
  3. "query": {"match": {
  4. "name": "鱼"
  5. }},"sort": [
  6. {
  7. "rating": {
  8. "order": "desc"
  9. }
  10. }
  11. ],"size": 3
  12. } 

结果稍微好点了,不过3个里面2个是湘菜,还是有点不合适,结果如下:

  1. {
  2.   "took": 1,
  3.   "timed_out": false,
  4.   "_shards": {
  5.     "total": 5,
  6.     "successful": 5,
  7.     "failed": 0
  8.   },
  9.   "hits": {
  10.     "total": 9,
  11.     "max_score": null,
  12.     "hits": [
  13.       {
  14.         "_index": "recipes",
  15.         "_type": "type",
  16.         "_id": "AVoESHYF_OA-dG63Txsd",
  17.         "_score": null,
  18.         "_source": {
  19.           "name": "鲫鱼汤(变态辣)",
  20.           "rating": 5,
  21.           "type": "湘菜"
  22.         },
  23.         "sort": [
  24.           5
  25.         ]
  26.       },
  27.       {
  28.         "_index": "recipes",
  29.         "_type": "type",
  30.         "_id": "AVoESHYW_OA-dG63Txse",
  31.         "_score": null,
  32.         "_source": {
  33.           "name": "广式鲫鱼汤",
  34.           "rating": 5,
  35.           "type": "粤菜"
  36.         },
  37.         "sort": [
  38.           5
  39.         ]
  40.       },
  41.       {
  42.         "_index": "recipes",
  43.         "_type": "type",
  44.         "_id": "AVoESHX7_OA-dG63Txsc",
  45.         "_score": null,
  46.         "_source": {
  47.           "name": "鲫鱼汤(微辣)",
  48.           "rating": 4,
  49.           "type": "湘菜"
  50.         },
  51.         "sort": [
  52.           4
  53.         ]
  54.       }
  55.     ]
  56.   }
  57. }
  • 现在我知道了,我要看看其他菜系,这家不是还有西餐、广东菜等各种菜系的么,来来,帮我每个菜系来一个菜看看,换 terms agg 先得到唯一的 term 的 bucket,再组合 top_hits agg,返回按评分排序的第一个 top hits,有点复杂,没关系,看下面的查询就知道了:
  1. GET recipes/type/_search
  2. {
  3. "query": {
  4. "match": {
  5. "name": "鱼"
  6. }
  7. },
  8. "sort": [
  9. {
  10. "rating": {
  11. "order": "desc"
  12. }
  13. }
  14. ],"aggs": {
  15. "type": {
  16. "terms": {
  17. "field": "type",
  18. "size": 10
  19. },"aggs": {
  20. "rated": {
  21. "top_hits": {
  22. "sort": [{
  23. "rating": {"order": "desc"}
  24. }],
  25. "size": 1
  26. }
  27. }
  28. }
  29. }
  30. },
  31. "size": 0,
  32. "from": 0
  33. } 

看下面的结果,虽然 json 结构有点复杂,不过总算是我们想要的结果了,湘菜、粤菜、川菜、西菜都出来了,每样一个,不重样:

  1. {
  2.   "took": 4,
  3.   "timed_out": false,
  4.   "_shards": {
  5.     "total": 5,
  6.     "successful": 5,
  7.     "failed": 0
  8.   },
  9.   "hits": {
  10.     "total": 9,
  11.     "max_score": 0,
  12.     "hits": []
  13.   },
  14.   "aggregations": {
  15.     "type": {
  16.       "doc_count_error_upper_bound": 0,
  17.       "sum_other_doc_count": 0,
  18.       "buckets": [
  19.         {
  20.           "key": "湘菜",
  21.           "doc_count": 6,
  22.           "rated": {
  23.             "hits": {
  24.               "total": 6,
  25.               "max_score": null,
  26.               "hits": [
  27.                 {
  28.                   "_index": "recipes",
  29.                   "_type": "type",
  30.                   "_id": "AVoESHYF_OA-dG63Txsd",
  31.                   "_score": null,
  32.                   "_source": {
  33.                     "name": "鲫鱼汤(变态辣)",
  34.                     "rating": 5,
  35.                     "type": "湘菜"
  36.                   },
  37.                   "sort": [
  38.                     5
  39.                   ]
  40.                 }
  41.               ]
  42.             }
  43.           }
  44.         },
  45.         {
  46.           "key": "川菜",
  47.           "doc_count": 1,
  48.           "rated": {
  49.             "hits": {
  50.               "total": 1,
  51.               "max_score": null,
  52.               "hits": [
  53.                 {
  54.                   "_index": "recipes",
  55.                   "_type": "type",
  56.                   "_id": "AVoESHYr_OA-dG63Txsf",
  57.                   "_score": null,
  58.                   "_source": {
  59.                     "name": "鱼香肉丝",
  60.                     "rating": 2,
  61.                     "type": "川菜"
  62.                   },
  63.                   "sort": [
  64.                     2
  65.                   ]
  66.                 }
  67.               ]
  68.             }
  69.           }
  70.         },
  71.         {
  72.           "key": "粤菜",
  73.           "doc_count": 1,
  74.           "rated": {
  75.             "hits": {
  76.               "total": 1,
  77.               "max_score": null,
  78.               "hits": [
  79.                 {
  80.                   "_index": "recipes",
  81.                   "_type": "type",
  82.                   "_id": "AVoESHYW_OA-dG63Txse",
  83.                   "_score": null,
  84.                   "_source": {
  85.                     "name": "广式鲫鱼汤",
  86.                     "rating": 5,
  87.                     "type": "粤菜"
  88.                   },
  89.                   "sort": [
  90.                     5
  91.                   ]
  92.                 }
  93.               ]
  94.             }
  95.           }
  96.         },
  97.         {
  98.           "key": "西菜",
  99.           "doc_count": 1,
  100.           "rated": {
  101.             "hits": {
  102.               "total": 1,
  103.               "max_score": null,
  104.               "hits": [
  105.                 {
  106.                   "_index": "recipes",
  107.                   "_type": "type",
  108.                   "_id": "AVoESHY3_OA-dG63Txsg",
  109.                   "_score": null,
  110.                   "_source": {
  111.                     "name": "奶油鲍鱼汤",
  112.                     "rating": 2,
  113.                     "type": "西菜"
  114.                   },
  115.                   "sort": [
  116.                     2
  117.                   ]
  118.                 }
  119.               ]
  120.             }
  121.           }
  122.         }
  123.       ]
  124.     }
  125.   }
  126. }
  • 上面的实现方法,前面已经说了,可以做,有局限性,那看看新的字段折叠法如何做到呢,查询如下,加一个 collapse 参数,指定对那个字段去重就行了,这里当然对菜系“type”字段进行去重了:
  1. GET recipes/type/_search
  2. {
  3. "query": {
  4. "match": {
  5. "name": "鱼"
  6. }
  7. },
  8. "collapse": {
  9. "field": "type"
  10. },
  11. "size": 3,
  12. "from": 0
  13. }

结果很理想嘛,命中结果还是熟悉的那个味道(和查询结果长的一样嘛),如下:

  1. {
  2. "took": 1,
  3. "timed_out": false,
  4. "_shards": {
  5. "total": 5,
  6. "successful": 5,
  7. "failed": 0
  8. },
  9. "hits": {
  10. "total": 9,
  11. "max_score": null,
  12. "hits": [
  13. {
  14. "_index": "recipes",
  15. "_type": "type",
  16. "_id": "AVoDNlRJ_OA-dG63TxpW",
  17. "_score": 0.018980097,
  18. "_source": {
  19. "name": "鲫鱼汤(微辣)",
  20. "rating": 4,
  21. "type": "湘菜"
  22. },
  23. "fields": {
  24. "type": [
  25. "湘菜"
  26. ]
  27. }
  28. },
  29. {
  30. "_index": "recipes",
  31. "_type": "type",
  32. "_id": "AVoDNlRk_OA-dG63TxpZ",
  33. "_score": 0.013813315,
  34. "_source": {
  35. "name": "鱼香肉丝",
  36. "rating": 2,
  37. "type": "川菜"
  38. },
  39. "fields": {
  40. "type": [
  41. "川菜"
  42. ]
  43. }
  44. },
  45. {
  46. "_index": "recipes",
  47. "_type": "type",
  48. "_id": "AVoDNlRb_OA-dG63TxpY",
  49. "_score": 0.0125863515,
  50. "_source": {
  51. "name": "广式鲫鱼汤",
  52. "rating": 5,
  53. "type": "粤菜"
  54. },
  55. "fields": {
  56. "type": [
  57. "粤菜"
  58. ]
  59. }
  60. }
  61. ]
  62. }
  63. }
  • 我再试试翻页,把 from 改一下,现在返回了3条数据,from 改成3,新的查询如下:
  1. {
  2. "took": 1,
  3. "timed_out": false,
  4. "_shards": {
  5. "total": 5,
  6. "successful": 5,
  7. "failed": 0
  8. },
  9. "hits": {
  10. "total": 9,
  11. "max_score": null,
  12. "hits": [
  13. {
  14. "_index": "recipes",
  15. "_type": "type",
  16. "_id": "AVoDNlRw_OA-dG63Txpa",
  17. "_score": 0.012546891,
  18. "_source": {
  19. "name": "奶油鲍鱼汤",
  20. "rating": 2,
  21. "type": "西菜"
  22. },
  23. "fields": {
  24. "type": [
  25. "西菜"
  26. ]
  27. }
  28. }
  29. ]
  30. }
  31. }
  • 上面的结果只有一条了,去重之后本来就只有4条数据,上面的工作正常,每个菜系只有一个菜啊,那我不乐意了,帮我每个菜系里面多返回几条,我好选菜啊,加上参数 inner_hits 来控制返回的条数,这里返回2条,按 rating 也排个序,新的查询构造如下:
  1. GET recipes/type/_search
  2. {
  3. "query": {
  4. "match": {
  5. "name": "鱼"
  6. }
  7. },
  8. "collapse": {
  9. "field": "type",
  10. "inner_hits": {
  11. "name": "top_rated",
  12. "size": 2,
  13. "sort": [
  14. {
  15. "rating": "desc"
  16. }
  17. ]
  18. }
  19. },
  20. "sort": [
  21. {
  22. "rating": {
  23. "order": "desc"
  24. }
  25. }
  26. ],
  27. "size": 2,
  28. "from": 0
  29. }

查询结果如下,完美:

  1. {
  2.   "took": 1,
  3.   "timed_out": false,
  4.   "_shards": {
  5.     "total": 5,
  6.     "successful": 5,
  7.     "failed": 0
  8.   },
  9.   "hits": {
  10.     "total": 9,
  11.     "max_score": null,
  12.     "hits": [
  13.       {
  14.         "_index": "recipes",
  15.         "_type": "type",
  16.         "_id": "AVoESHYF_OA-dG63Txsd",
  17.         "_score": null,
  18.         "_source": {
  19.           "name": "鲫鱼汤(变态辣)",
  20.           "rating": 5,
  21.           "type": "湘菜"
  22.         },
  23.         "fields": {
  24.           "type": [
  25.             "湘菜"
  26.           ]
  27.         },
  28.         "sort": [
  29.           5
  30.         ],
  31.         "inner_hits": {
  32.           "top_rated": {
  33.             "hits": {
  34.               "total": 6,
  35.               "max_score": null,
  36.               "hits": [
  37.                 {
  38.                   "_index": "recipes",
  39.                   "_type": "type",
  40.                   "_id": "AVoESHYF_OA-dG63Txsd",
  41.                   "_score": null,
  42.                   "_source": {
  43.                     "name": "鲫鱼汤(变态辣)",
  44.                     "rating": 5,
  45.                     "type": "湘菜"
  46.                   },
  47.                   "sort": [
  48.                     5
  49.                   ]
  50.                 },
  51.                 {
  52.                   "_index": "recipes",
  53.                   "_type": "type",
  54.                   "_id": "AVoESHX7_OA-dG63Txsc",
  55.                   "_score": null,
  56.                   "_source": {
  57.                     "name": "鲫鱼汤(微辣)",
  58.                     "rating": 4,
  59.                     "type": "湘菜"
  60.                   },
  61.                   "sort": [
  62.                     4
  63.                   ]
  64.                 }
  65.               ]
  66.             }
  67.           }
  68.         }
  69.       },
  70.       {
  71.         "_index": "recipes",
  72.         "_type": "type",
  73.         "_id": "AVoESHYW_OA-dG63Txse",
  74.         "_score": null,
  75.         "_source": {
  76.           "name": "广式鲫鱼汤",
  77.           "rating": 5,
  78.           "type": "粤菜"
  79.         },
  80.         "fields": {
  81.           "type": [
  82.             "粤菜"
  83.           ]
  84.         },
  85.         "sort": [
  86.           5
  87.         ],
  88.         "inner_hits": {
  89.           "top_rated": {
  90.             "hits": {
  91.               "total": 1,
  92.               "max_score": null,
  93.               "hits": [
  94.                 {
  95.                   "_index": "recipes",
  96.                   "_type": "type",
  97.                   "_id": "AVoESHYW_OA-dG63Txse",
  98.                   "_score": null,
  99.                   "_source": {
  100.                     "name": "广式鲫鱼汤",
  101.                     "rating": 5,
  102.                     "type": "粤菜"
  103.                   },
  104.                   "sort": [
  105.                     5
  106.                   ]
  107.                 }
  108.               ]
  109.             }
  110.           }
  111.         }
  112.       }
  113.     ]
  114.   }
  115. }

好了,字段折叠介绍就到这里。

elasticsearch 基础 —— Field Collapsing字段折叠的更多相关文章

  1. 【转载】Elasticsearch 5.x 字段折叠的使用,广度搜索

    https://elasticsearch.cn/article/132 备注,分组字段只能是 keyword或num类型,不能是text类型 在 Elasticsearch 5.x 有一个字段折叠( ...

  2. ElasticSearch 基础 1

    ElasticSearch 基础=============================== 索引创建 ========================== 1. RESTFUL APIAPI 基本 ...

  3. ElasticSearch基础学习(SpringBoot集成ES)

    一.概述 什么是ElasticSearch? ElasticSearch,简称为ES, ES是一个开源的高扩展的分布式全文搜索引擎. 它可以近乎实时的存储.检索数据:本身扩展性很好,可以扩展到上百台服 ...

  4. ELK(elasticsearch+kibana+logstash)搜索引擎(二): elasticsearch基础教程

    1.elasticsearch的结构 首先elasticsearch目前的结构为 /index/type/id  id对应的就是存储的文档ID,elasticsearch一般将数据以JSON格式存储. ...

  5. elasticsearch 基础 —— ReIndex

    Reindex会将一个索引的数据复制到另一个已存在的索引,但是并不会复制原索引的mapping(映射).shard(分片).replicas(副本)等配置信息. 一.reindex的常用操作 1.re ...

  6. Django笔记&教程 4-2 模型(models)中的Field(字段)

    Django 自学笔记兼学习教程第4章第2节--模型(models)中的Field(字段) 点击查看教程总目录 参考:https://docs.djangoproject.com/en/2.2/ref ...

  7. Elasticsearch基础但非常有用的功能之二:模板

    文章转载自: https://mp.weixin.qq.com/s?__biz=MzI2NDY1MTA3OQ==&mid=2247484584&idx=1&sn=accfb65 ...

  8. 分布式爬虫之elasticsearch基础1

    一:搜索引擎elasticsearch介绍 Elasticsearch 是一个全文搜索引擎,可以快速地储存.搜索和分析海量数据. 二:应用场景 海量数据分析引擎 站内搜索引擎 数据仓库 三:安装 我们 ...

  9. Elasticsearch 基础入门

    原文地址:Elasticsearch 基础入门 博客地址:http://www.extlight.com 一.什么是 ElasticSearch ElasticSearch是一个基于 Lucene 的 ...

随机推荐

  1. Jquery异步上传文件

    我想通过jQuery异步上传文件,这是我的HTML: 1 2 3 <span>File</span> <input type="file" id=&q ...

  2. struts2+jsp 遍历 <s:iterator><s:property>

    直接把list用request传到jsp页面 <s:iterator var="u" value="#request.users"> <tr& ...

  3. 【leetcode】1073. Adding Two Negabinary Numbers

    题目如下: Given two numbers arr1 and arr2 in base -2, return the result of adding them together. Each nu ...

  4. powerdesign 显示comment,生成excel

    一.显示 Comment 1. 在弹窗的Table描述里面显Comment 效果图 实现方式: 2. 在最外层显示Comment 效果图 现实方式: 2.1. Tools > Display P ...

  5. 如何分析及处理 Flink 反压?

    反压(backpressure)是实时计算应用开发中,特别是流式计算中,十分常见的问题.反压意味着数据管道中某个节点成为瓶颈,处理速率跟不上上游发送数据的速率,而需要对上游进行限速.由于实时计算应用通 ...

  6. POJ 2391--Ombrophobic Bovines(最大流(拆点)+二分+最短路)

    Ombrophobic Bovines Description FJ's cows really hate getting wet so much that the mere thought of g ...

  7. BaseFragment 基类代码

    public abstract class BaseFragment extends Fragment implements IBaseView { private List<BasePrese ...

  8. matplot在Mac下显示中文的方案

    使用matplotlib经常会出现中文显示异常的问题. 网上很多都讲需要下载中文字体包...偶然看到别人发的一种简单的解决放啊.Mac上本身就有支持中文的字体包啊.引入就好了 贴上代码 plt.rcP ...

  9. 每天一个Linux指令

    开始详细系统的学习linux常用命令,坚持每天一个命令,所以这个系列为每天一个linux命令.学习的主要参考资料为: 1.<鸟哥的linux私房菜> 2.http://codingstan ...

  10. data_model_action

    w PowerDesigner