精华内容
参与话题
问答
  • 干货 | Elasticsearch Nested类型深入详解

    万次阅读 多人点赞 2018-10-06 13:08:20
    0、概要 在Elasticsearch实战场景中,我们或多或少会遇到嵌套文档的组合形式,反映在ES中称为父子文档。 父子文档的实现,至少包含以下两种方式: ...2)Nested嵌套类型 本文通过一个例...

    0、概要

    在Elasticsearch实战场景中,我们或多或少会遇到嵌套文档的组合形式,反映在ES中称为父子文档。
    父子文档的实现,至少包含以下两种方式:
    1)父子文档
    父子文档在5.X版本中通过parent-child父子type实现,即:1个索引对应多个type;
    6.X+版本已经不再支持一个索引多个type,6.X+的父子索引的实现改成Join。
    2)Nested嵌套类型

    本文通过一个例子将Nested类型适合解决的问题、应用场景、使用方法串起来,
    文中所有的DSL都在Elasticsearch6.X+验证通过。

    1、Elasticsearch 数据类型全景概览

    在这里插入图片描述

    2、从一个例子说起吧

    在这里插入图片描述

    2.1 问题背景

    在elasticsearch中,我们可以将密切相关的实体存储在单个文档中。 例如,我们可以通过传递一系列评论来存储博客文章及其所有评论。
    举例:

    {
      "title": "Invest Money",
      "body": "Please start investing money as soon...",
      "tags": ["money", "invest"],
      "published_on": "18 Oct 2017",
      "comments": [
        {
          "name": "William",
          "age": 34,
          "rating": 8,
          "comment": "Nice article..",
          "commented_on": "30 Nov 2017"
        },
        {
          "name": "John",
          "age": 38,
          "rating": 9,
          "comment": "I started investing after reading this.",
          "commented_on": "25 Nov 2017"
        },
        {
          "name": "Smith",
          "age": 33,
          "rating": 7,
          "comment": "Very good post",
          "commented_on": "20 Nov 2017"
        }
      ]
    }
    

    如上所示,所以我们有一个文档描述了一个帖子和一个包含帖子上所有评论的内部对象评论。
    但是Elasticsearch搜索中的内部对象并不像我们期望的那样工作。

    2.2 问题出现

    现在假设我们想查找用户{name:john,age:34}评论过的所有博客帖子。 让我们再看一下上面的示例文档,找到评论过的用户。

    name age
    William 34
    John 38
    Smith 33

    从列表中我们可以清楚地看到,没有34岁的用户John。
    为简单起见,我们在elasticsearch索引中只有1个文档。
    让我们通过查询索引来验证它:

    GET /blog/_search?pretty
    {
      "query": {
        "bool": {
          "must": [
            {
              "match": {
                "comments.name": "John"
              }
            },
            {
              "match": {
                "comments.age": 34
              }
            }
          ]
        }
      }
    }
    

    我们的示例文档作为回复返回。 很惊讶,这是为什么呢?

    2.3 原因分析

    这就是为什么我说:
    elasticsearch中的内部对象无法按预期工作
    这里的问题是elasticsearch(lucene)使用的库没有内部对象的概念,因此内部对象被扁平化为一个简单的字段名称和值列表。
    我们的文档内部存储为:

    {
      "title":                    [ invest, money ],
      "body":                     [ as, investing, money, please, soon, start ],
      "tags":                     [ invest, money ],
      "published_on":             [ 18 Oct 2017 ]
      "comments.name":            [ smith, john, william ],
      "comments.comment":         [ after, article, good, i, investing, nice, post, reading, started, this, very ],
      "comments.age":             [ 33, 34, 38 ],
      "comments.rating":          [ 7, 8, 9 ],
      "comments.commented_on":    [ 20 Nov 2017, 25 Nov 2017, 30 Nov 2017 ]
    }
    

    如上,您可以清楚地看到,comments.name和comments.age之间的关系已丢失。
    这就是为什么我们的文档匹配john和34的查询。

    2.4 如何解决呢?

    要解决这个问题,我们只需要对elasticsearch的映射进行一些小改动。
    如果您查看索引的映射,您会发现comments字段的类型是object。
    我们需要更新它的类型为nested。
    我们可以通过运行以下查询来简单地更新索引的映射:

    PUT /blog_new
    {
      "mappings": {
        "blog": {
          "properties": {
            "title": {
              "type": "text"
            },
            "body": {
              "type": "text"
            },
            "tags": {
              "type": "keyword"
            },
            "published_on": {
              "type": "keyword"
            },
            "comments": {
              "type": "nested",
              "properties": {
                "name": {
                  "type": "text"
                },
                "comment": {
                  "type": "text"
                },
                "age": {
                  "type": "short"
                },
                "rating": {
                  "type": "short"
                },
                "commented_on": {
                  "type": "text"
                }
              }
            }
          }
        }
      }
    }
    

    将映射更改为Nested类型后,我们可以查询索引的方式略有变化。 我们需要使用Nested查询。
    下面给出了Nested查询示例:

    GET /blog_new/_search?pretty
    {
      "query": {
        "bool": {
          "must": [
            {
              "nested": {
                "path": "comments",
                "query": {
                  "bool": {
                    "must": [
                      {
                        "match": {
                          "comments.name": "john"
                        }
                      },
                      {
                        "match": {
                          "comments.age": 34
                        }
                      }
                    ]
                  }
                }
              }
            }
          ]
        }
      }
    }
    

    由于用户{name:john,age:34}没有匹配,上面的查询将不返回任何文档。

    再次感到惊讶? 只需一个小小的改变即可解决问题。
    这可能是我们理解的一个较小的变化,但是在elasticsearch存储我们的文档的方式上有很多变化。
    在内部,嵌套对象将数组中的每个对象索引为单独的隐藏文档,这意味着可以独立于其他对象查询每个嵌套对象。
    下面给出了更改映射后样本文档的内部表示:

    {
      {
        "comments.name":    [ john ],
        "comments.comment": [ after i investing started reading this ],
        "comments.age":     [ 38 ],
        "comments.rating":  [ 9 ],
        "comments.date":    [ 25 Nov 2017 ]
      },
      {
        "comments.name":    [ william ],
        "comments.comment": [ article, nice ],
        "comments.age":     [ 34 ],
        "comments.rating":   [ 8 ],
        "comments.date":    [ 30 Nov 2017 ]
      },
      {
        "comments.name":    [ smith ],
        "comments.comment": [ good, post, very],
        "comments.age":     [ 33 ],
        "comments.rating":   [ 7 ],
        "comments.date":    [ 20 Nov 2017 ]
      },
      {
        "title":            [ invest, money ],
        "body":             [ as, investing, money, please, soon, start ],
        "tags":             [ invest, money ],
        "published_on":     [ 18 Oct 2017 ]
      }
    }
    

    如您所见,每个内部对象都在内部存储为单独的隐藏文档。 这保持了他们的领域之间的关系。

    3、Nested类型的作用?

    从上一小节,可以清晰的看出nested类型的特别之处。
    nested类型是对象数据类型的专用版本,它允许对象数组以可以彼此独立查询的方式进行索引。

    4、Nested类型的适用场景

    图片来自:rockybean教程
    ——图片来自:rockybean教程

    5、Nested类型的增、删、改、查、聚合操作详解

    还是以第2节的blog_new索引示例,Nested类型的增、删、改、查操作。

    5.1 Nested类型——增

    新增blog和评论

    POST blog_new/blog/2
    {
      "title": "Hero",
      "body": "Hero test body...",
      "tags": ["Heros", "happy"],
      "published_on": "6 Oct 2018",
      "comments": [
        {
          "name": "steve",
          "age": 24,
          "rating": 18,
          "comment": "Nice article..",
          "commented_on": "3 Nov 2018"
        }
      ]
    }
    

    5.2 Nested类型——删

    序号为1的评论原来有三条,现在删除John的评论数据,删除后评论数为2条。

    POST  blog_new/blog/1/_update
    {
     "script": {
        "lang": "painless",
        "source": "ctx._source.comments.removeIf(it -> it.name == 'John');"
     }
    }
    

    5.3 Nested类型——改

    将steve评论内容中的age值调整为25,同时调整了评论内容。

    POST blog_new/blog/2/_update
    {
      "script": {
        "source": "for(e in ctx._source.comments){if (e.name == 'steve') {e.age = 25; e.comment= 'very very good article...';}}" 
      }
    }
    

    5.4 Nested类型——查

    如前所述,查询评论字段中评论姓名=William并且评论age=34的blog信息。

    GET /blog_new/_search?pretty
    {
      "query": {
        "bool": {
          "must": [
            {
              "nested": {
                "path": "comments",
                "query": {
                  "bool": {
                    "must": [
                      {
                        "match": {
                          "comments.name": "William"
                        }
                      },
                      {
                        "match": {
                          "comments.age": 34
                        }
                      }
                    ]
                  }
                }
              }
            }
          ]
        }
      }
    }
    

    5.5 Nested类型——聚合

    认知前提:nested聚合隶属于聚合分类中的Bucket聚合分类。
    聚合blog_new 中评论者年龄最小的值。

    GET blog_new/_search
    {
      "size": 0,
      "aggs": {
        "comm_aggs": {
          "nested": {
            "path": "comments"
          },
          "aggs": {
            "min_age": {
              "min": {
                "field": "comments.age"
              }
            }
          }
        }
      }
    }
    

    6、小结

    如果您在索引中使用内部对象并做查询操作,请验证内部对象的类型是否为nested类型。 否则查询可能会返回无效的结果文档。
    更新认知是非常痛苦的,不确定的问题只有亲手实践才能检验真知。

    参考:
    [1]http://t.cn/Evwh0uW
    [2]官网6.x+:http://t.cn/Ehltakr
    这里写图片描述
    打造Elasticsearch基础、进阶、实战第一公众号!

    展开全文
  • es nested

    2019-01-25 11:57:31
    要想能用父子级联查询 首先 index得设置成 nested 类型,如 PUT my_index { “mappings”: { “_doc”: { "properties": { "manager": { "properties": { "age": { ...

    要想能用父子级联查询 首先 index得设置成 nested 类型,如

    PUT my_index
    {
    “mappings”: {
    “_doc”: {

      "properties": {
        "manager": { 
    
    
          "properties": {
            "age":  { "type": "integer" },
            "name": { "type": "text"  }
          }
        },
        "employees": { 
    

    “type”: “nested”,
    “properties”: {
    “age”: { “type”: “integer” },
    “name”: { “type”: “text” }
    }
    }
    }
    }
    }
    }
    查询的时候 即可使用
    GET my_index/_search
    {
    “query”: {
    “match”: {
    manager.name”: “Alice White”
    }
    },
    “aggs”: {
    “Employees”: {
    “nested”: {
    “path”: “employees”
    },
    “aggs”: {
    “Employee Ages”: {
    “histogram”: {
    “field”: “employees.age”,
    “interval”: 5
    }
    }
    }
    }
    }
    }

    展开全文
  • ES中使用nested类型的内嵌对象

    千次阅读 2019-03-15 16:52:11
    在大数据的应用环境中,往往使用反范式设计来提高读写性能。 假设我们有个类似简书的系统,系统里有文章,用户也可以对文章进行赞赏。在关系型数据库中,如果按照数据库范式设计,需要两张表:一张文章表和一张赞赏...

     

    https://www.jianshu.com/p/d685b7b6c9d1

    在大数据的应用环境中,往往使用反范式设计来提高读写性能。
    假设我们有个类似简书的系统,系统里有文章,用户也可以对文章进行赞赏。在关系型数据库中,如果按照数据库范式设计,需要两张表:一张文章表和一张赞赏历史记录表,赞赏历史记录表包括了赞赏者姓名和赞赏金额。
    在Elastic search中,由于都是json格式存储,则可以在一个index存储系统中的文章及其赞赏记录,这种情况下需要在elastic search中使用nested类型的内嵌对象。因为如果使用数组或者object对象的话,赞赏者姓名和赞赏金额是相互独立的进行存储,不能被正确的关联。

    建立index

    PUT articles
    {
      "mappings": {
        "doc": {
          "properties": {
            "payment": {
              "type": "nested",
              "properties": {
                "amount": {
                  "type": "integer"
                },
                "name": {
                  "type": "keyword"
                }
              }
            }
          }
        }
      }
    }
    

    这样articles就有了payment这个nested类型的字段,payment里面的对象有amount和name,表示金额和姓名。

    产生数据

    产生如下数据,表示jack给文章1赞赏了29元,ross给文章1赞赏30元,ross给文章2赞赏31元。

    POST articles/doc/1
    {
      "payment": [
        {
          "name": "jack",
          "amount": 29
        },
        {
          "name": "ross",
          "amount": 30
        }
      ]
    }
    
    POST articles/doc/2
    {
      "payment": [
        {
          "name": "ross",
          "amount": 31
        }
      ]
    }
    

    根据内嵌对象进行查询

    现在想查询ross赞赏过的文章,需要使用nested query

    GET articles/_search
    {
      "query": {
        "nested": {
          "path": "payment",
          "query": {
            "term": {
              "payment.name": {
                "value": "ross"
              }
            }
          }
        }
      }
    }
    

    path表示了nested字段的名称,需要注意的是,查询语句中要指定查询字段的全名,所以赞赏者姓名要用"payment.name"
    如果在多个index上进行nested查询,没有nested字段的index会报错,这时可以将ignore_unmapped设置为true

    nested对象聚合

    如果想查看赞赏的平均金额,需要用nested aggregation

    GET articles/_search
    {
      "size": 0, 
      "aggs": {
        "nested": {
          "nested": {
            "path": "payment"
          },
          "aggs": {
            "amount_avg": {
              "avg": {
                "field": "payment.amount"
              }
            }
          }
        }
      }
    }
    

    同样注意要用path指定字段名称。返回的数据中,比普通的聚合查询多了一层嵌套
    返回结果为

    {
      "took": 1,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 2,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "nested": {
          "doc_count": 3,
          "amount_avg": {
            "value": 30
          }
        }
      }
    }
    

    nested对象聚合和过滤

    如果想看ross赞赏过的总金额,一开始写出query如下

    GET articles/_search
    {
      "size": 0, 
      "query": {
        "nested": {
          "path": "payment",
          "query": {
            "term": {
              "payment.name": {
                "value": "ross"
              }
            }
          }
        }
      },
      "aggs": {
        "nested": {
          "nested": {
            "path": "payment"
          },
          "aggs": {
            "sum": {
              "sum": {
                "field": "payment.amount"
              }
            }
          }
        }
      }
    }
    

    此时结果并不是正确的,因为上面的query过滤的是ross赞赏过的文章,下面的聚合操作sum的是文章里所有的赞赏,包括了jack的赞赏。
    所以需要在sum聚合操作之前,需要用Filter Aggregation筛选ross的赞赏。

    GET articles/_search
    {
      "size": 0,
      "query": {
        "nested": {
          "path": "payment",
          "query": {
            "term": {
              "payment.name": {
                "value": "ross"
              }
            }
          }
        }
      },
      "aggs": {
        "payment": {
          "nested": {
            "path": "payment"
          },
          "aggs": {
            "payer": {
              "filter": {
                "term": {
                  "payment.name": {
                    "value": "ross"
                  }
                }
              },
              "aggs": {
                "sum": {
                  "sum": {
                    "field": "payment.amount"
                  }
                }
              }
            }
          }
        }
      }
    }
    

    最外层的query筛选出ross赞赏过的文章。
    第一层的aggs表示进行内嵌聚合。
    第二层的aggs用Filter Aggregation筛选出表示ross赞赏行为的nested对象。
    第三层的aggs进行聚合。



    作者:大神带我来搬砖
    链接:https://www.jianshu.com/p/d685b7b6c9d1
    来源:简书
    简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

    展开全文
  • Elasticsearch之Nested Aggregation

    千次阅读 2015-04-16 20:52:07
    (这是一个小系列:请戳:Elasticsearch之Nested(嵌套)系列,查看其他nested相关文章)  In the same way as we need to use the special nested query to gain access to nested objects at ...

                                                      (这是一个小系列:请戳:ElasticsearchNested(嵌套)系列,查看其他nested相关文章)

                 In the same way as we need to use the special nested query to gain access to nested objects at search time, the dedicated nested aggregation allows

     us to aggregate fields in nested objects:

      与在检索时需要使用特定的nested查询来接触nested object一样,特定的nested聚合同样能让我们对nested object内的字段进行聚合:

    curl -XGET 'localhost:9200/my_index/blogpost/_search?search_type=count' -d '
    {
      "aggs":{
         "comments":{①
    	    "nested":{
    		   "path":"comments"
    		},
    		"aggs":{
    		   "by_month":{
    		      "date_histogram":{②
    			      "field":"comments.date",
    				  "interval":"month",
    				  "format":"yyyy-MM"
    			  },
    			  "aggs":{
    			     "avg_stars":{
    				    "avg":{③
    					   "field":"comments.stars"
    					}
    				 }
    			  }
    		   }
    		}
    	 }
      }
    }

    ①:The nested aggregation “steps down” into the nested comments object.

    nested 聚合进入nested评论对象。

    ②:Comments are bucketed into months based on the comments.date field

       评论基于comments.date字段聚合成月

    ③:The average number of stars is calculated for each bucket.

    对于每一个簇,计算星级 的平均值。

    The results show that aggregation has happened at the nested document level:

    结果表明,聚合的确发生在nested文本层:

    ...
    "aggregations": {
      "comments": {
         "doc_count": 4, 
         "by_month": {
            "buckets": [
               {
                  "key_as_string": "2014-09",
                  "key": 1409529600000,
                  "doc_count": 1, 
                  "avg_stars": {
                     "value": 4
                  }
               },
               {
                  "key_as_string": "2014-10",
                  "key": 1412121600000,
                  "doc_count": 3, 
                  "avg_stars": {
                     "value": 2.6666666666666665
                  }
               }
            ]
         }
      }
    }

    reverse_nested Aggregation

    反嵌套聚合

     

    A nested aggregation can access only the fields within the nested document. It can’t see fields in the root document or in a different 

    nested document. However, we can step out of the nested scope back into the parent with a reverse_nested aggregation.

    一个nested聚合只能接入nested文本内的字段,它不能看到根文本或者不同nested文本内的字段。但是,我们可以通过一个反嵌套聚合跳出nested局域进入父层。

    For instance, we can find out which tags our commenters are interested in, based on the age of the commenter. The comment.age is

     a nested field, while the tags are in the root document:

    比如我们基于评论者的年龄找出哪些标签是评论者感兴趣的。comment.age是一个nested字段,而tags位于根文本中:

    curl -XGET 'localhost:9200/my_index/blogpost/_search?search_type=count' -d '
    {
      "aggs":{
         "comments":{
    	    "nested":{①
    		   "path":"comments"
    		},
    		"aggs":{
    		  "age_group":{
    		      "histogram":{②
    			     "field":"comments.age",
    				 "interval":10
    			  },
    			  "aggs":{
    			     "blogposts":{
    				    "reverse_nested":{},③
    					"aggs":{
    					   "tags":{
    					      "terms":{④
    						     "field":"tags"
    						  }
    					   }
    					}
    				 }
    			  }
    		  }
    		}
    	  }
        }		
    }

    ②:The histogram agg groups on the comments.age field, in buckets of 10 years.

    histogram(直方图)聚合在comments.age字段上分组,每10年一组。

    ③:The reverse_nested agg steps back up to the root document.

    reverse_nested聚合跳转回根文本。

    ④:The terms agg counts popular terms per age group of the commenter.

    terms聚合计算每个年龄组的流行terms

    The abbreviated results show us the following:

    下面是简化结果:

    ..
    "aggregations": {
      "comments": {
         "doc_count": 4, 
         "age_group": {
            "buckets": [
               {
                  "key": 20, 
                  "doc_count": 2, 
                  "blogposts": {
                     "doc_count": 2, 
                     "tags": {
                        "doc_count_error_upper_bound": 0,
                        "buckets": [ 
                           { "key": "shares",   "doc_count": 2 },
                           { "key": "cash",     "doc_count": 1 },
                           { "key": "equities", "doc_count": 1 }
                        ]
                     }
                  }
               },
    ...

    When to Use Nested Objects

    何时使用nested 对象。

    Nested objects are useful when there is one main entity, like our blogpost, with a limited number of closely related but less important entities, 

    such as comments. It is useful to be able to find blog posts based on the content of the comments, and the nested query and filter provide for

     fast query-time joins.

    当有一个主要的实体,就像blogpost(博客文章),还有有限的一些相关但是没这么重要的其他实体,比如comments(评论)nested对象就显得非常有用。基于评论的内容找到博客文章是有价值的。同时为了快速查询时间拼接,还提供了nested查询和过滤。

    The disadvantages of the nested model are as follows:

    nested模式的缺点如下:

    1.To add, change, or delete a nested document, the whole document must be reindexed. This becomes more costly the more nested

     documents there are.

    1.为了增加,改变或者删除一个nested文本,整个文本必须重新建索引。nested文本越多,这就会变得代价越大。

    2.Search requests return the whole document, not just the matching nested documents. Although there are plans afoot to support returning 

    the best -matching nested documents with the root document, this is not yet supported.

    2.检索请求返回整个文本,而不仅是匹配的nested文本。尽管有计划正在执行以能够支持返回根文本的同时返回最匹配的nested文本,但目前还未实现。



    原文:http://www.elastic.co/guide/en/elasticsearch/guide/master/nested-aggregation.html

    展开全文
  • Elasticsearch之Nested(嵌套)系列

    万次阅读 2015-04-14 16:54:27
    1.Elasticsearch之Nested Object 2.Elasticsearch之Nested Object Mapping 3.Elasticsearch之Nested Query (2015-04-16更新) 4.Elasticsearch之Nested Sorting (2015-04-17更新) 5.Elasticsearch之Nested ...
  • 1.问题引入: 由于在 ES 里新建、删除、更新单个文档都是原子性的,那么将相关实体保存在同一文档里面是有意义的。 PUT /blog/_doc/1 { "title":"Nest eggs", "body":"Making your money work...", ...
  • 传统关系型数据库对关联关系的处理 对于传统关系型数据库而言,处理数据的关联关系时比较正规的设计是范式化设计与非范式化设计。 范式化 (Normalization) 范式化设计的主要⽬标是“减少不必要的更新”,一般有三段...
  • Elasticsearch嵌套式对象Nested分析

    万次阅读 2017-03-15 14:13:12
    nested结构是Elasticsearch提供关系存储的一种特殊的结构,是NOSQL的一种高级特性,在传统的关系型sql中,很难做到一行记录中存储某个实体以及附属的内容,比如某个用户下评论数据,或某个订单下的所有商品等这种关系...
  • Elasticsearch之Nested Object

    万次阅读 多人点赞 2015-04-14 16:46:18
    Given the fact that creating, deleting, and updating a single document in Elasticsearch is atomic, it makes sense to store closely related entities within the same document. ...
  • 文章目录概述官网示例模拟数据需求一: 需求1: 按照评论日期进行bucket划分,然后拿到每个月的评论的评分的平均值需求二: 以年龄 10岁一个划分,看下都有哪些tagreverse_nested 概述 继续跟中华石杉老师学习ES,...
  • Elasticsearch之Nested Object

    千次阅读 2017-12-27 18:39:09
    原文地址:...  Given the fact that creating, deleting, and updating a single document in Elasticsearch is atomic,  it makes sense to store close
  • spring事务传播之NESTED

    千次阅读 2016-11-23 11:22:43
    * Execute within a nested transaction if a current transaction exists, * behave like PROPAGATION_REQUIRED else. There is no analogous feature in EJB. * <p>Note: Actual creation of a nest
  • The Nested Set Model

    千次阅读 2013-03-05 15:57:54
    原理:  我们先把树按照水平方式摆开。从根节点开始(“Food”),然后他的左边写上1。然后按照树的顺序(从上到下)给“Fruit”的左边写上2。这样,你沿着树的边界走啊走(这就是“遍历”),然后同时在每个节点...
  • Nested Aggregation A special single bucket aggregation that enables aggregating nested documents. 一种特殊的单桶聚合,可聚合嵌套文档。 Reverse nested Aggregation A special single bucket aggregation ...
  • NESTED LOOPS 成本计算

    千次阅读 2011-08-02 17:43:33
    SQL> select * from v$version where rownum=1; BANNER -------------------------------------------------------------------------------- Or
  • 转:nested type

    千次阅读 2012-05-26 22:44:38
    原本是想找有关C++对象模型的资料的,恰巧搜到了这边博文,感觉还可以,就转载了。原文如下: 因为是基础,所以一定要吃透,记牢。归整一下,方便记忆。...class or struct is called a nested typ
  • nested exception is org.apache.ibatis.exceptions.PersistenceExceptionCause: org.springframework.jdbc.CannotGetJdbcConnectionException: Could not get JDBC Connection;
  • 十一月 06, 2018 5:44:57 下午 org.springframework.context.support.AbstractApplicationContext refresh 警告: Exception encountered during context initialization - cancelling refresh attempt: org....
  • ElasticSearch - 嵌套对象 nested

    万次阅读 2018-06-22 20:58:56
    由于在ES中,所有单个文档的增删改...查询效率非常高因此除了基本数据类型之外,ES也支持使用複杂的数据类型,像是数组、内部对象,而要使用内部对象的话,需要使用nested来定义索引,使文档内可以包含一个内部对象...
  • Elasticsearch嵌套式对象Nested分析

    千次阅读 2017-09-11 17:19:15
    nested结构是Elasticsearch提供关系存储的一种特殊的结构,是NOSQL的一种高级特性,在传统的关系型sql中,很难做到一行记录中存储某个实体以及附属的内容,比如某个用户下评论数据,或某个订单下的所有商品等这种关系...

空空如也

1 2 3 4 5 ... 20
收藏数 174,865
精华内容 69,946
关键字:

nested