Grundlegende Verwendung der Python-Operation elasticsearch

Erstellen Sie eine es-Indexbibliothek, die dem Erstellen einer Tabelle entspricht

     from elasticsearch import Elasticsearch
     from elasticsearch.helpers import bulk
     es = Elasticsearch(hosts='localhost:9200')
     #创建索引表
     es.indices.create(index='my', ignore=400)

Fügen Sie ein Datenelement in die es-Indexbibliothek ein

  data = {
    
    "name": "小明", "age": "8", "gender": "男"}
  res = es.index(index='my', doc_type='doc', body=data)

Batch-Insert-Daten in die Indexbibliothek

    from elasticsearch.helpers import bulk
    data_lis = [{
    
    "name": "小红", "age": "8", "gender": "女"}, {
    
    "name": "小王", "age": "8",    "gender": "男"}]
    # 批量插入es创建的索引表
    res2 = bulk(es, data_lis, index='my' )

Fragen Sie alle Daten ab

    data = es.search(index='my')
    #查询所有的第二种方法
    body = {
    
    
            'query':{
    
    
            'match_all':{
    
    }
             }
        }
    data = es.search(index='my', body=body)

Begriff: Abfragedaten basierend auf dem Wert eines Feldes

    # es 官方文档: term 和 terms 是 包含(contains) 操作,而非 等值(equals) (判断)
    body2 =  {
    
    
                 "query":{
    
    
                   "term":{
    
    
                      "age":8 }
                          }
                        }
    data_list = es.search(index='my', body=body2)

Begriffe: Daten abfragen, die auf mehreren Werten eines Feldes basieren

    body3 = {
    
    
               "query":{
    
    
                "terms":{
    
    
                 "age:[ 8,10 ] }}}
    age_list = es.search(index='my', body=body3)

match: Abfrage basierend auf einem Feld, das ein bestimmtes Zeichen enthält

 body4 =  {
    
    
           "query":{
    
    
               "match":{
    
    
                  "name":"红" } 
                  }
           }
    red_list = es.search(index='my', body=body4)

multi_match: Abfrage basierend auf mehreren Feldern, die ein bestimmtes Zeichen enthalten

    body = {
    
    
            "query":{
    
    
                  "multi_match":{
    
    
                      "query":"红",
                       "fields":["name","addr"]
                       }
                          }
                  }
     #查询name和addr中包含红的数据
     es.search(index="my", body=body)

match_phrase: Matching Tiltle enthält Quick Fox, die beiden Felder müssen nebeneinander liegen

    body = {
    
    
    "query": {
    
    
        "match_phrase": {
    
    
            "title": {
    
    
            	"query": "quick fox",
            	"slop":  1
            }
        }
    }
}
     #查询name和addr中包含红的数据
     es.search(index="my", body=body)

Abfrage basierend auf ID

    body = {
    
    
			"query": {
    
    
				"ids": {
    
    
					"type": "doc",
					"values": ["vxGrGGwBv1w0KXkAjsEd""wBG_GGwBv1w0KXkAcsEn"
					]
				}
			} }
    h = es.search(index="my",  body=body)

Zusammengesetzte Abfrage

# bool有3类查询关系,must(都满足), should(其中一个满足), must_not(都不满足)
{
    
    
    "query": {
    
    
        "bool": {
    
    
            "must": [{
    
    
                "term": {
    
    
                    "name": "小红"
                }
            }, {
    
    
                "term": {
    
    
                    "age": 18
                }
            }]
        }
    }
}
es.search(index='my', body=body)

Bereich: Bereichsabfrage

body = {
    
    
    "query": {
    
    
        "range": {
    
    
            "age": {
    
    
                "gte": 18,
                "lte": 30
            }
        }
    }
}

# 查询18<=age<=30的所有数
es.search(index="my_index", doc_type="test_type", body=body)

Slice-Abfrage

body = {
    
    
    "query": {
    
    
        "match_all": {
    
    }
    },
    "from": 2,
    "size": 4
}
# 从第2条数据开始,获取4条数据
es.search(index="my", body=body)

Platzhalterabfrage

body = {
    
    
    "query":
        {
    
    
        "wildcard":
            {
    
    
            "name": "*红"
        }
    }
}
# 查询name字段以红结尾的数据
es.search(index="my",body=body)   

Präfixabfrage

body = {
    
    
    "query": {
    
    
        "prefix": {
    
    
            "name": "李"
        }
    }
}
# 查询前缀为"李"的所有数据
es.search(index='my', body=body)

existiert: fragt ab, ob ein Feld keine Nulldaten ist

# 查询某个字段不是空值:
body = {
    
    
  "query": {
    
    
    "bool": {
    
    
      "must": {
    
    
        "exists": {
    
    
          "field": "name"
        }
      }
    }
  }
}
es.search(index='my', body=body)

Legen Sie die Gewichtung des Abfragefelds fest

# ^ 字符语法为单个字段提升权重,在字段名称的末尾添加 ^boost ,其中 boost 是一个浮点数:
body = {
    
    
    "query": {
    
    
        "multi_match": {
    
    
            "query": "明 红",
            "field": ["name^2", 'last_name^1.5', "first_name^0.9"]
        }
    }
}
es.search(index='my', body=body)

Sortieren

body = {
    
    
    "query": {
    
    
        "match_all": {
    
    }
    },
    "sort": {
    
    
        "age": {
    
                     # 根据age字段升序排序
            "order": "asc"       # asc升序,desc降序
        }
    }
}

# 多字段排序,注意顺序!写在前面的优先排序
body = {
    
    
    "query": {
    
    
        "match_all": {
    
    }
    },
    "sort": [{
    
    
        "age": {
    
                    # 先根据age字段升序排序
            "order": "asc"      # asc升序,desc降序
        }
    }, {
    
    
        "name": {
    
                   # 后根据name字段升序排序
            "order": "asc"      # asc升序,desc降序
        }
    }],
}
es.search(index='my', body=body)

count führt die Abfrage aus und ermittelt die Anzahl der Abfrageübereinstimmungen

body = {
    
    
    "query": {
    
    
        "prefix": {
    
    
            "name": "李"
        }
    }
}
# 查询前缀为"李"的所有数据
es.count(index='my', body=body)

aggs: aggregierte Abfrage, um das älteste Alter zu erhalten

body = {
    
    
    "query": {
    
    
        "match_all": {
    
    }
    },
    "aggs": {
    
    
        "max_age": {
    
    
            "max": {
    
    
                "field": "age"
            }
            
        }
    }
}
es.search(index='my', body=body)

aggs: aggregierte Abfrage, um das kleinste Alter zu erhalten

body = {
    
    
    "query": {
    
    
        "match_all": {
    
    }
    },
    "aggs": {
    
    
        "min_age": {
    
    
            "min": {
    
    
                "field": "age"
            }

        }
    }
}
es.search(index='my', body=body)

aggs: Aggregierte Abfrage, um das Alter der Summe zu ermitteln

body = {
    
    
    "query": {
    
    
        "match_all": {
    
    }
    },
    "aggs": {
    
    
        "sum_age": {
    
    
            "sum": {
    
    
                "field": "age"
            }

        }
    }
}
es.search(index='my', body=body)

aggs: aggregierte Abfrage, um das Durchschnittsalter zu ermitteln

body = {
    
    
    "query": {
    
    
        "match_all": {
    
    }
    },
    "aggs": {
    
    
        "avg_age": {
    
    
            "avg": {
    
    
                "field": "age"
            }

        }
    }
}
es.search(index='my', body=body)

Ich denke du magst

Origin blog.csdn.net/xxy_yang/article/details/96995547
Empfohlen
Rangfolge