• python使用ElasticSearch7.17.6笔记

    数操作系统：windows10

    我开始使用最新的版本，8.4.1但是使用过程中kibana启动不了，就索性使用旧版；

    下载地址：

    es7.17.6 下载地址 

    kibana7.17.6下载地址

    解压到合适的位置，更改elasticsearch.yml

    添加配置如下：

    1. cluster.name: robin-es
    2. node.name: node-1
    3. network.host: 0.0.0.0
    4. http.port: 9200
    5. cluster.initial_master_nodes: ["node-1"]

    更改kibana.yml配置

    i18n.locale: "zh-CN"

    到各自的bin目录下启动两个服务bat文件，

    在浏览器中执行http:://localhost:9200

    可以看到json就对了

    1. {
    2.   "name" : "node-1",
    3.   "cluster_name" : "robin-es",
    4.   "cluster_uuid" : "pAvuRyRESuCHtbTnfdWrvA",
    5.   "version" : {
    6.     "number" : "7.17.6",
    7.     "build_flavor" : "default",
    8.     "build_type" : "zip",
    9.     "build_hash" : "f65e9d338dc1d07b642e14a27f338990148ee5b6",
    10.     "build_date" : "2022-08-23T11:08:48.893373482Z",
    11.     "build_snapshot" : false,
    12.     "lucene_version" : "8.11.1",
    13.     "minimum_wire_compatibility_version" : "6.8.0",
    14.     "minimum_index_compatibility_version" : "6.0.0-beta1"
    15.   },
    16.   "tagline" : "You Know, for Search"
    17. }

    使用python需要添加一下相关的库，我这里使用国内的库，并且使用代理，

    注意：建议使用对应版本的库，否则可能不兼容。

    1. pip install -i https://pypi.tuna.tsinghua.edu.cn/simple/   elasticsearch==7.17.6 --proxy="http://127.0.0.1:1081"
    2. pip install -i https://pypi.tuna.tsinghua.edu.cn/simple/   elasticsearch[async]==7.17.6 --proxy="http://127.0.0.1:1081"

    连接数据库：

    1. indexName = "student"
    2. client = Elasticsearch(
    3.     ['127.0.0.1:9200'],
    4.     # 在做任何操作之前，先进行嗅探
    5.     # sniff_on_start=True,
    6.     # # 节点没有响应时，进行刷新，重新连接
    7.     sniff_on_connection_fail=True,
    8.     # # 每 60 秒刷新一次
    9.     sniffer_timeout=60
    10. )

    写几个增删改查的函数：

    需要注意：7.15版本以上使用了新的函数，旧的方式已经不适用了

    1. # 推荐使用  elasticsearch  需要注意版本问题
    2. from queue import Empty
    3. from elasticsearch import Elasticsearch
    4. from elasticsearch import *
    5. import json
    6. # es 7.17
    7.  
    8.  
    9. def checkIndexByName(client, indexName):
    10.     try:
    11.         res = client.indices.get(index=indexName)
    12.         # print(res)
    13.         return True
    14.     except Exception as ex:
    15.         return False
    16.  
    17. # 创建索引
    18. def createIndex(client, name,  doc):
    19.     ret = False
    20.     try:
    21.         # Elasticsearch.options()
    22.         resp = client.indices.create(index=name, mappings=doc["mappings"])
    23.         # print(resp['result'])
    24.         ret = True
    25.     except Exception as ex:
    26.         print(ex)
    27.         return False
    28.  
    29.     return ret
    30.  
    31. # 删除索引 
    32. def dropIndex(client, name):
    33.     ret = False
    34.     try:
    35.         # Elasticsearch.options()
    36.         result = client.indices.delete(index=name)
    37.         ret = True
    38.     except:
    39.         return False
    40.  
    41.     return ret
    42.  
    43.  
    44. def addDoc(client, index, doc, id):
    45.     # 重复添加，数据覆盖
    46.     try:
    47.         resp = client.index(index=index, document=doc, id=id)
    48.         print(resp['result'])
    49.         return True
    50.     except Exception as e:
    51.         print("create index error")
    52.         return False
    53.  
    54.  
    55. def delDocFromIndex(client, index, id):
    56.     try:
    57.         res = client.delete(index=index, id=id)
    58.         print(res['_shards']['successful'])
    59.         return '1'
    60.     except Exception as e:
    61.         print(e)
    62.         return '0'
    63.  
    64.  
    65. def findDocById(client, index, id):
    66.     try:
    67.         res = client.get(index=index, id=id)
    68.         return res['_source']
    69.     except Exception as e:
    70.         print(e)
    71.         return 'nil'
    72.

    创建索引的过程，可以在外部配置文件中设置相关的参数，

    比如我们创建一个学生的相关索引，我们建立一个配置文件student.json

    1. {
    2.     "settings": {
    3.         "index": {
    4.             "number_of_shards": 1,
    5.             "number_of_replicas": 0
    6.         }
    7.     },
    8.     "mappings": {
    9.         "dynamic": "strict",
    10.         "properties": {
    11.             "name": {
    12.                 "type": "key"
    13.             },
    14.             "age": {
    15.                 "type": "long"
    16.             },
    17.             "birthday": {
    18.                 "type": "date"
    19.             }
    20.         }
    21.     }
    22. }

    之后，我们创建索引时候这样使用：

    1. def load_json(filePath):
    2.     data = open(filePath, 'r').read()
    3.     return json.loads(data)
    4.  
    5.  
    6. docMapping = load_json("./student.json")
    7. # print(docMapping)
    8.  
    9.  
    10. #dropIndex(client, indexName, result)
    11. ret = checkIndexByName(client, indexName)
    12. if not ret:
    13.     print("\nindex is exsit = %d" % ret)
    14.     createIndex(client, indexName, docMapping)

    如果没有索引，则创建一下；

    在kibana的开发工具中可以看到相关的结果：

    之后， 添加2个记录（文档）试试

    1. doc = {
    2.  
    3.     "name": "灰太狼",
    4.     "age": 22,
    5.     "birthday": "2000-02-02",
    6.     "tags": ["男"]
    7.  
    8. }
    9. res = addDoc(client, indexName, doc, 13810500001)
    10. # print(res)
    11.  
    12. doc = {
    13.  
    14.     "name": "美羊羊",
    15.     "age": 10,
    16.     "birthday": "2010-01-01",
    17.     "tags": ["女"]
    18.  
    19. }
    20. res = addDoc(client, indexName, doc, 13810500002)
    21. # print(res)

    可以在kibana中看到：

     

     目前位置，基本的增删改查，都实现了，但是还需要复杂的查询：

    1. bodyQueryAll = {
    2.     "query": {
    3.         "match_all": {}
    4.     }
    5. }
    6. res = client.search(index=indexName, query=bodyQueryAll["query"])
    7. print("查询到%d 个" % res['hits']['total']['value'])
    8.  
    9. items = res["hits"]["hits"]
    10. # print(items)
    11. for item in items:
    12.     print("index=%s, id=%s doc=%s" %
    13.           (item['_index'], item['_id'], item['_source']))
    1. 查询到2 个
    2. index=student, id=13810501001 doc={'name': '灰太狼', 'age': 22, 'birthday': '2000-02-02', 'tags': ['男']}
    3. index=student, id=13810501002 doc={'name': '美羊羊', 'age': 21, 'birthday': '2000-01-01', 'tags': ['女']}

    在kibana中，是这样的：

     

    知道了查询后返回数据的结构了，就可以提取我们想要的数据了，

    再添加2个查询函数：

    1. def queryAll(client, indexName):
    2.     bodyQueryAll = {
    3.         "query": {
    4.             "match_all": {}
    5.         }
    6.     }
    7.     res = client.search(index=indexName, query=bodyQueryAll["query"])
    8.     n = res['hits']['total']['value']
    9.     #print("查询到%d 个" % n)
    10.  
    11.     items = res["hits"]["hits"]
    12.     # print(items)
    13.     # for item in items:
    14.     #     print("index=%s, id=%s doc=%s" %
    15.     #           (item['_index'], item['_id'], item['_source']))
    16.     return (n, items)
    17.  
    18.  
    19. def queryByDoc(client, indexName, query):
    20.     res = client.search(index=indexName, query=query)
    21.     n = res['hits']['total']['value']
    22.     items = res["hits"]["hits"]
    23.     return (n, items)

    测试代码如下：

    1. print("查全量：")
    2. res = queryAll(client, indexName)
    3. n = res[0]
    4. items = res[1]
    5. # print(items)
    6. for item in items:
    7.     print("index=%s, id=%s doc=%s" %
    8.           (item['_index'], item['_id'], item['_source']))
    9.  
    10.  
    11. queryNames = {
    12.     "bool":
    13.     {
    14.         "should": [
    15.             {"match":
    16.                 {"name": "美羊羊"}
    17.              },
    18.             {
    19.                 "match": {"name": "喜羊羊"}
    20.             }
    21.         ]
    22.     }
    23. }
    24.  
    25. print("查名字：")
    26. res = queryByDoc(client, indexName, queryNames)
    27. n = res[0]
    28. items = res[1]
    29. # print(items)
    30. for item in items:
    31.     print("index=%s, id=%s doc=%s" %
    32.           (item['_index'], item['_id'], item['_source']))

    输出：

    1. 查全量：
    2. index=student, id=13810501001 doc={'name': '灰太狼', 'age': 22, 'birthday': '2000-02-02', 'tags': ['男']}
    3. index=student, id=13810501002 doc={'name': '美羊羊', 'age': 21, 'birthday': '2000-01-01', 'tags': ['女']}
    4. 查名字：
    5. index=student, id=13810501002 doc={'name': '美羊羊', 'age': 21, 'birthday': '2000-01-01', 'tags': ['女']}

    kibana中这样的：

     

    参考：python操作Elasticsearch7.x - lshan - 博客园

    Elasticsearch API Reference — Python Elasticsearch client 8.4.1 documentation

    python操作Elasticsearch7.17.0_有勇气的牛排的博客-CSDN博客

    https://github.com/elastic/elasticsearch-py/issues/1698

    elasticsearch——入门 - 走看看

  • 相关阅读:
    17、Mybatis获取参数值的情况3（若mapper接口方法的参数为多个时，可以手动将这些参数放入map中存储）
    【开源】基于Vue.js的智能停车场管理系统的设计和实现
    面试五 -bind 和 function
    Flink之KeyedState
    python使用ElasticSearch7.17.6笔记
    企业真实面试：父子类之间到底是怎么实例化的？
    linux-4.19 内存之页面回收
    1.0、C语言数据结构 ——初识数据结构和算法
    【图像分割】图像检测（分割、特征提取）、各种特征（面积等）的测量和过滤（Matlab代码实现）
    Java的垃圾回收机制详解——从入门到出土，学不会接着来砍我！
  • 原文地址：https://blog.csdn.net/robinfoxnan/article/details/126768161