python 使用 Elasticsearch 增删查改

最新推荐文章于 2024-05-12 17:57:20 发布
最新推荐文章于 2024-05-12 17:57:20 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： Elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Waller_/article/details/109810964
版权 
pip install elasticsearch==7.10

连接ES

from elasticsearch import Elasticsearch

# es服务器ip, port
ES_IP = '172.30.xx.xx'
ES_PORT = 9200

# 认证信息
http_auth = ('elastic', '123456')

es = Elasticsearch(
    [ES_IP],
    http_auth=('elastic', '123456'),
    port=ES_PORT
)

基础概念

index: 索引, 可以看做是mysql的表名
doc_type: 文档类型
id: 可看做是mysql表中记录的id
body: 查询体, 就是es的查询语句，使用DSL语句，相比SQL语句要复杂得多，但是基本逻辑其实是类似的

操作

索引

  • 创建索引
from elasticsearch.exceptions import RequestError

方法一: 若索引已经存在了，就返回个400，
try:
    es.indices.create(index='my-index')
except RequestError as e:
    print('索引已存在')

方法二: 参数 ignore=400 表示 忽略返回的400状态码
es.indices.create(index='my-index', ignore=400)  # 索引不存在创建,存在则不操作
  • 删除索引
# 该索引及其内部的数据全部删除, 类似mysql把表删除

es.indices.delete(index='my-index', ignore=[400, 404])

数据

  • 增
向指定索引内增加数据, 若索引不存在,则自动创建索引,并插入数据

方法一: index
如果不指定 id，会自动生成一个 id,
若该id存在,则是将此id的原数据删除,重新创建

es.index(index="user_info",doc_type="_doc",id=1, body={"name":"喜洋洋","age":21,})


方法二: create
需要我们指定 id 字段来唯一标识该条数据
若该id存在,则报错

from elasticsearch.exceptions import ConflictError
try:
    es.create(index="user_info",doc_type="_doc",id=1,body={"name":"喜洋洋","age":27})
except ConflictError as e:
    print('id存在')
  • 删
删除索引内指定id对应的那一行数据

from elasticsearch.exceptions import NotFoundError
try:
    es.delete(index='user_info', doc_type='_doc', id=2)
except NotFoundError as e:
    print('数据不存在')

或

es.delete(index='user_info', doc_type='_doc', id=1, ignore=[404])  # 忽略状态码
  • 改
修改索引内指定id对应的数据, 如 将id为1的name改成'懒洋洋'
body={"doc":{"name":"懒洋洋"}}  # 固定写法
es.update(index="user_info",doc_type="_doc",id=1, body=body)
  • 查
get 查询

res = es.get(index="user_info", doc_type="_doc",id=1)
print(res)
{'_index': 'user_info', '_type': '_doc', '_id': '1', '_version': 3, '_seq_no': 11, '_primary_term': 1, 'found': True, '_source': {'name': '懒洋洋', 'age': 18}}

search 查询

1.查询所有:
body = {
        'query':{
        'match_all':{}
         }
    }

res = es.search(index='user_info',doc_type='_doc')
print(res['hits']['hits'])
[
    {'_index': 'user_info', '_type': '_doc', '_id': '2', '_score': 1.0, '_source': {'name': '喜洋洋', 'age': 27}},
    {'_index': 'user_info', '_type': '_doc', '_id': '1', '_score': 1.0, '_source': {'name': '懒洋洋', 'age': 18}}
]

2.根据某个字段的值进行查询数据, 如查询年龄为18的数据信息
body = {
        "query":{
            "term":{
                "age":18
                }
            }
        }
res = es.search(index='user_info',doc_type='_doc', body=body)
print(res['hits']['hits'])
[{'_index': 'user_info', '_type': '_doc', '_id': '1', '_score': 1.0, '_source': {'name': '懒洋洋', 'age': 18}}]
 
3.根据某个字段的多个值进行查询数据, 如查询年龄为18和27的数据信息
body = {
        "query":{
            "terms":{  # 注意是 'terms'
                "age":[18, 27]  # 注意是 列表
                }
            }
        }
res = es.search(index='user_info',doc_type='_doc', body=body)
print(res['hits']['hits'])
[
    {'_index': 'user_info', '_type': '_doc', '_id': '2', '_score': 1.0, '_source': {'name': '喜洋洋', 'age': 27}}, 
    {'_index': 'user_info', '_type': '_doc', '_id': '1', '_score': 1.0, '_source': {'name': '懒洋洋', 'age': 18}}
]

4.根据某个字段包含某个字符进行查询, 如查询名字中含有'喜'的数据
body = {
        "query":{
            "match":{
                "name":'喜'
                }
            }
        }
res = es.search(index='user_info',doc_type='_doc', body=body)
print(res['hits']['hits'])
[{'_index': 'user_info', '_type': '_doc', '_id': '2', '_score': 0.4700036, '_source': {'name': '喜洋洋', 'age': 27}}]

5.根据多个字段包含某个字符进行查询, 如查询name与age中含有'2'的数据
body = {
        "query":{
            "multi_match":{
                "query":'2',
                "fields":["name","age"]
                }
            }
        }
res = es.search(index='user_info',doc_type='_doc', body=body)
print(res['hits']['hits'])
[{'_index': 'user_info', '_type': '_doc', '_id': '3', '_score': 1.1001158, '_source': {'name': '美羊羊2', 'age': 20}}]

6.范围查询
body = {
        "query":{
            "range":{
                       "age":{
                             "gte":20,       # >=18
                             "lte":30        # <=30
                       }
                    }
            }
        }
res = es.search(index='user_info',doc_type='_doc', body=body)
print(res['hits']['hits'])
[
    {'_index': 'user_info', '_type': '_doc', '_id': '2', '_score': 1.0, '_source': {'name': '喜洋洋', 'age': 27}}, 
    {'_index': 'user_info', '_type': '_doc', '_id': '3', '_score': 1.0, '_source': {'name': '美羊羊2', 'age': 20}}
]

配置IK分词器后查询 

首先是创建索引, 在创建索引时,就要指定字段的拆词粒度,如下,注意:这里是es7.x版本

body = {
  'mappings':{
    'dynamic':'strict',  # 规定如果添加新的字段,报错. 
      'properties':{
        'id': {
              'type': 'text',
          },
        'text':{
          'type':'text',
          'analyzer':'ik_max_word',  # 新增数据时,规定该字段对应值的拆词粒度为 ik_max_word
          "search_analyzer": "ik_smart"  # 查询时,规定该字段对应搜索词的拆词粒度为 ik_smart
        },
         'knowledge_id':{
          'type':'text',
        },
      }
  }
}

res = es.indices.create(index='my-index', body=body)

下面插入一些数据到索引中

info = [
    {'text':'服务器无法登录，提示“可信芯片异常，拒绝登陆！"', 'id':1, 'knowledge_id':1},
    {'text':'查看系统中所有用户的三种方式', 'id':2, 'knowledge_id':2},
    {'text':'如何退出三合一注册向导全屏界面？', 'id':2, 'knowledge_id':3},
]

for dic in info:
    es.index(index='my-index',doc_type="_doc",body=dic)

到head中看一下搜索词为'三合一拒绝登陆',拆词粒度为'ik_smart'时, 得到的拆词结果如下,得到三个词: '三合一','拒绝','登录',

对应到我们的数据中,可以查出来的结果应该是两条数据,第一条和第三条.

用代码实现查询:

body = {
        "query":{
            "match":{
                "text":'三合一拒绝登陆'
                }
            }
        }

res = es.search(index='my-index',doc_type='_doc', body=body)
print(res['hits']['hits'])

# 这里仅把查出的数据拿出来展示
# {'text': '服务器无法登录，提示“可信芯片异常，拒绝登陆！"', 'id': 1, 'knowledge_id': 1}}
# {'text': '如何退出三合一注册向导全屏界面？', 'id': 2, 'knowledge_id': 3}

python获取es拆分后的词

body={
    "text":"惠普 p2015dn",
    "analyzer":"ik_max_word"
    # "analyzer":"optimizeIK"
}
res = es.indices.analyze(index=INDEX_KNOWLEDGE, body=body)
key_list = [dic['token'] for dic in res['tokens']]
print(key_list)  # ['惠普', 'p2015dn', 'p', '2015', 'dn']

案例: 

现在需要在文章内容中匹配搜索词,如果文章数量多,用mysql的模糊匹配会很慢,所以将mysql中的数据取出,存到es中,

import pymysql
from elasticsearch import Elasticsearch
from elasticsearch.exceptions import RequestError, ConflictError, NotFoundError, ConnectionError

# 连接mysql获取数据
def checkmysql(num=None):
    conn = pymysql.connect(
        host='172.30.00.00',
        port=3306,
        user='xy',
        password='123456',
        database='xxx',
        charset='utf8',
    )

    cursor = conn.cursor(pymysql.cursors.DictCursor)

    cursor.execute('select * from knowledgetext')
    # rows = cursor.fetchmany(num)
    rows = cursor.fetchall()
    cursor.close()
    conn.close()
    return rows

# 连接es
ES_IP = '172.30.00.01'
ES_PORT = 9200

# 认证信息
http_auth = ('elastic', '123456')

es = Elasticsearch(
    [ES_IP],
    http_auth=('elastic', '123456'),
    port=ES_PORT
)


# 规定body内字段格式及拆词类型
body = {
    "settings": {
        "index": {
            "number_of_shards": 1,  # 是数据分片数，默认为5，有时候设置为3
            "number_of_replicas": 0  # 是数据备份数，如果只有一台机器，设置为0
        }
    },
  'mappings':{
    'dynamic':'strict',  # 规定如果添加新的字段,报错
      'properties':{
        'id': {
              'type': 'text',
          },
        'text':{
          'type':'text',
          'analyzer':'ik_max_word',  # 新增数据时,规定该字段的拆词粒度为 ik_max_word
          "search_analyzer": "ik_smart"  # 查询时,规定该此字段的拆词粒度为 ik_smart
        },
         'knowledge_id':{
          'type':'text',
        },
      }
  }
}

# 创建索引
es.indices.create(index='my-index', body=body)

# 将数据存入es
for dic in checkmysql():
    es.index(index='my-index',doc_type="_doc",body=dic, request_timeout=30)
    # request_timeout 是允许的最大超时时间


# 查询数据
# 1.查所有
body = {
        "size": 111,  # 最大显示数量,es默认展示10条

        'query':{
        'match_all':{}
         }
    }
# 2.查具体某个字段
body = {
        "size": 10000,  # 最大显示数量
        "query": {
            "match": {
                # "text": search_key,
                "text": {
                    "query": search_key,
                    "analyzer": "ik_smart",  # 用来指定搜索的词语按那种拆词粒度拆词
                    "operator": "or",  # 按拆分后的词查询时,词与词之间是 and 还是 or 的关系
                    "minimum_should_match": "75%"  # 该参数用来控制应该匹配的分词的最少数量,至少匹配几个词才召回查询的结果
                }
            }
        },
        }

try:
    res = es.search(
        index='my-index',
        # doc_type='_doc',  # 可以不加doc_type, 若加上该参数则会出现 ElasticsearchDeprecationWarning: [types removal] Specifying types in search requests is deprecated.
        body=body,
        request_timeout=30  # 允许的超时时间,默认是10s
    )
except ConnectionError:
    res = None
    print('连接超时或ES未启动')


def filter_data(res=None):
    data = []
    if res:
        for d in res['hits']['hits']:
            data.append(d.get('_source'))
    return data

print(len(filter_data(res)))

推荐文章 参考文章 参考文章 参考文章

查看文章 参考文章 参考文章 参考文章 参考文章

常见错误

其他: 提高搜索精准度, 使IK分词器兼容英文分词

  • IK兼容英文分词
body = {
    "settings": {
        "index": {
            "number_of_shards": 1,  # 是数据分片数，默认为5，有时候设置为3
            "number_of_replicas": 0  # 是数据备份数，如果只有一台机器，设置为0
        },
        # 使中文分词器IK 增加对英文的支持,可以理解为基于ik自定义了拆词模式:optimizeIK
        "analysis": {
            "analyzer": {
                "optimizeIK": {
                    "type": "custom",
                    "tokenizer": "ik_max_word",
                    "filter": [
                        "stemmer"  # stemmer模式是将在ik对文档完成分词之后，将其中的英文单词做提取词干处理。
                    ] 
                }
            }
        }
    },
    'mappings': {
        # 'dynamic': 'strict',  # 规定如果添加新的字段,报错
        'properties': {
            'id': {
                'type': 'keyword',
            },
            'text': {
                "type": "text",
                "analyzer": "optimizeIK",  # 若不需要对英文分词的支持,可注销这行,将下面一行开打
                # "analyzer": "ik_max_word",  # 新增数据时,规定该字段的拆词粒度为 ik_max_word
                "search_analyzer": "ik_smart"  # 查询时,规定该此字段的拆词粒度为 ik_smart
            },
            'knowledge_id': {
                'type': 'keyword',
            },
        }
    }
}

补充: 使用上面模板创建的索引支持三种分词模式: ik_max_word, ik_smart, optimizeIK(这是自定义的分词模式,准确的说应该是IK的ik_max_word + stemmer英文拆词)

检查一下拆词结果

POST klbp-knowledge/_analyze
{
    "text":"惠普 p2015dn",
    "analyzer":"ik_smart"  # 这是IK自带的拆词模式
}

结果:
{
  "tokens" : [
    {
      "token" : "惠普",
      "start_offset" : 0,
      "end_offset" : 2,
      "type" : "CN_WORD",
      "position" : 0
    },
    {
      "token" : "p2015dn",
      "start_offset" : 3,
      "end_offset" : 10,
      "type" : "LETTER",
      "position" : 1
    }
  ]
}


POST klbp-knowledge/_analyze
{
    "text":"惠普 p2015dn",
    "analyzer":"optimizeIK"  # 这是兼容英文拆词后的拆词模式
}

结果:
{
  "tokens" : [
    {
      "token" : "惠普",
      "start_offset" : 0,
      "end_offset" : 2,
      "type" : "CN_WORD",
      "position" : 0
    },
    {
      "token" : "p2015dn",
      "start_offset" : 3,
      "end_offset" : 10,
      "type" : "LETTER",
      "position" : 1
    },
    {
      "token" : "p",
      "start_offset" : 3,
      "end_offset" : 4,
      "type" : "ENGLISH",
      "position" : 2
    },
    {
      "token" : "2015",
      "start_offset" : 4,
      "end_offset" : 8,
      "type" : "ARABIC",
      "position" : 3
    },
    {
      "token" : "dn",
      "start_offset" : 8,
      "end_offset" : 10,
      "type" : "ENGLISH",
      "position" : 4
    }
  ]
}
  • 提高搜索精准度
多字段搜索:
这是基于上面自定义了拆词模式的搜索
POST klbp-knowledge/_search
{
        "size": 10000,
        "query": {
            # bool: 内部的匹配方式如果匹配成功了,就把结果拿出来, 内部的匹配方式都会去匹配
            "bool": {
                "must_not": {
                    "match": {
                        "status": "0"
                    }
                },
                "must": [
                    {
                        # multi_match 匹配多个字段
                        "multi_match": {
                            "query": "惠普 p2015",
                            "fields": [
                                "title",
                                "abstract"
                            ],
                            "analyzer": "optimizeIK",
                            "minimum_should_match": "50%"
                            # "type": "best_fields",  # 使 完全匹配的文档占的评分比较高
                            # "tie_breaker": 0.3  # 使 没有完全匹配的评分乘以0.3的系数
                        }
                    },
                    {
                        "bool": {
                            "should": [
                                {
                                    "match": {
                                        "abstract": {
                                            "query": "惠普 p2015",
                                            "analyzer": "optimizeIK",  # 可根据实际情况换成 ik_smart 模式
                                            "boost": 2,
                                            "operator": "and"
                                        }
                                    }
                                },
                                {
                                    "match": {
                                        "title": {
                                            "query": "惠普 p2015",
                                            "analyzer": "optimizeIK",
                                            "operator": "and",
                                            "boost": 3
                                        }
                                    }
                                },
                                {
                                    "match": {
                                        "keyword": {
                                            "query": "惠普 p2015",
                                            "analyzer": "optimizeIK"
                                        }
                                    }
                                }
                            ],
                            "minimum_should_match": 1  # 至少满足一个条件
                        }
                    }
                ]
            }
        }
    }

单字段搜索:
POST klbp-knowledgetext/_search
{
  "size": 10000,
  "query": {
    "dis_max": {
      "queries": [
        {
          "function_score": {
            "query": {
              "match_phrase": {
                "text": {
                  "query": "惠普 p2015",
                  "slop": 2
                }
              }
            },
            # 定义了一个加分方法
            "functions": [
              {
                "weight": 10
              }
            ]
          }
        },
        {
          "match": {
            "text": {
              "query": "惠普 p2015",
              "analyzer": "optimizeIK",
              "minimum_should_match": "50%"
            }
          }
        }
      ]
    }
  }
}

提高搜索精准度推荐文章  文章    文章

如果需要搜索分页，可以通过from size组合来进行。from表示从第几行开始，size表示查询多少条文档。from默认为0，size默认为10， 
如果搜索size大于10000，需要设置index.max_result_window参数 
注意：size的大小不能超过index.max_result_window这个参数的设置，默认为10,000。 

PUT _settings
{
    "index": {
        "max_result_window": "10000000"
    }
}

elasticsearch bool中should must联用问题

elasticsearch match_phrase slop参数问题

i0208
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Python操作ElasticSearch
【逸辰杳】的博客
12-23 3万+
环境依赖：　　Python：2.7 　　ES依赖包：pyelasticsearch 　　ElasticSearch：5.5.1 / 6.0.1 　　操作系统：Windows 10 / CentOS 7　本文主要就ES基本的CRUD操作做以归纳整理，ES官方对Python的依赖支持有很多，eg：pyelasticsearch、ESClient、elasticutils、pyes、rawes、Su
Python 操作 Elasticsearch 实现 增 删 改 查
freeking101的博客
12-28 1834
Github 地址：https://github.com/elastic/elasticsearch-py/blob/master/docs/index.rst 官网地址：https://elasticsearch-py.readthedocs.io/en/latest/index.html Python-ElasticSearch，python对ES进行写入、更新、删除、搜索：h...
【5分钟学会一个知识点】01.Elasticsearch基本操作-增删改查
05-12 5877
Elasticsearch是当今最受欢迎的开源搜索与分析引擎之一，它的强大功能和灵活性正在改变数据处理和信息检索的方式。《一天一个Elasticsearch知识点》将带您深入了解这个令人惊叹的技术。从基本概念到高级用法，每天我们将分享一个关于Elasticsearch的精彩知识点。您将了解到其在全文搜索、实时数据分析和日志处理方面的应用，以及如何优化性能、构建可扩展的集群和实现高可用性。不论您是开发者、数据工程师还是决策者，这篇文章将帮助您掌握Elasticsearch的核心概念，并启发您在项目中应用其强大
elasticsearch的python增删查改实例分析
weixin_34406061的博客
01-18 101
Reference:  http://bigg.top/2015/11/29/elasticsearch%E7%9A%84python%E5%A2%9E%E5%88%A0%E6%9F%A5%E6%94%B9%E5%AE%9E%E4%BE%8B%E5%88%86%E6%9E%90/   ES的部署请查看相关文档，我这里就不在赘叙。提醒，官方建议ES的在60G以上内存的环境下运行，如果你的服务器的内...
python直接操作Elasticsearch7
不能堕落的小黑粉
12-30 3863
python直接操作Elasticsearch7的命令 本文Python代码在python3.6中测试通过，仅做记录，有问题请执教。谢谢???? 简介 本次代码基于ES7.9，python版本3.6。ES服务器是基于docker中的ES7.10 安装命令 pip3 install elasticsearch==7.9.1 1、连接ES，创建索引 from elasticsearch import Elasticsearch es = Elasticsearch( ['.
Python项目——项目优化(Elasticsearch)(一)
python全栈
07-04 807
Elasticsearch是一个基于Lucene的分布式搜索引擎。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。 Elasticsearch用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。官方客户端在Java、.NET（C#）、PHP、Python、Apache Groovy、Ruby和许多其他语言中都是可用的。根据DB-Engines的排名
Python的BBS问答社区程序.zip
最新发布
06-04
同时，高效的搜索功能，可能需要使用Elasticsearch或Solr等全文搜索引擎。 10. 测试和部署： 使用unittest、pytest等Python测试框架确保代码质量，通过Docker容器化部署可以简化环境配置和应用部署。 总的来说，...
es-geonames-loader:用于将 Geoname 数据加载到 Elasticseach 的 Python 工具
06-22
Elasticsearch 提供了 RESTful API，允许通过 HTTP 请求对数据进行增删查改操作。`es-geonames-loader` 工具通过调用这些 API 将 Geoname 数据以 JSON 格式发送到 Elasticsearch，创建或更新索引。这个过程中，可能...
Python库 | elastic_wikidata-1.0.0-py3-none-any.whl
03-19
4. **API接口**：库还提供了一系列API，方便开发者在自己的应用中调用，进行数据的增删查改操作。 5. **性能优化**：考虑到大规模数据处理的需求，"elastic_wikidata"库设计时考虑了性能优化，如批量导入、并发处理...
elasticsearch-5.6.3.tar.gz
10-26
例如，使用curl命令行工具，或者在Python、Java等语言中集成的HTTP客户端库，都可以便捷地执行增删查改操作。此外，5.6.3版本还引入了对JSON格式的支持，这使得数据交换变得直观且易于处理。 Elasticsearch的集群...
图书管理系统
04-14
通过Python的sqlite3库，我们可以方便地执行SQL语句，进行数据的增删查改操作。 在【2016-course-DB-master】这个压缩包文件中，可能包含了该项目的源代码、数据库脚本、测试文件、文档等资源。源代码可能包括了...
【Elasticsearch】Elasticsearch 安装配置与实践
Ezrealer的博客
04-29 320
python 操作 Elasticsearch 插入 from elasticsearch import Elasticsearch es = Elasticsearch(hosts="120.133.17.175", port=9200, http_auth=('elastic', 'RdCm*_*!so@c0ol'), timeout=3600) result = es.index(index="test",body={"first_name":"xiao","last_name":"xiao",
Elasticsearch：关于在 Python 中使用 Elasticsearch 你需要知道的一切 - 8.x
Elastic 中国社区官方博客
01-16 6215
Elasticsearch 是一个非常强大的搜索引擎，使用非常广泛。本文的重点是使用 Python 批量创建 Elasticsearch 文档。我们仅仅触及了 Elasticsearch 搜索查询的皮毛。我有专门的文章介绍 Elasticsearch的 基本查询和高级查询，用于搜索和分析。Elasticsearch 原生语言中使用的查询与 Python 中使用的查询相同。因此，当你掌握了Kibana中的原生查询后，你就可以在Python中自由使用了。
ElasticSearch入门
AngleWang
11-27 2910
ElasticSearch入门
Elasticsearch入门学习（二）
itman_cx的博客
05-29 284
ES的基本概念 索引 字段类型 文档 我们可以用关系型数据库来做个类比： 而ES则是面向文档的，文档是最小的单位，文档又有几个主要属性： 自我包含，一篇文档同时包含字段和对应的值，也就是同时包含 key:value！ 可以是层次型的，一个文档中包含自文档，复杂的逻辑实体就是这么来的！ {就是一个json对象！ fastjson进行自动转换！} 灵活的结构，文档不依赖预先定义的模式，我们知道关系型数据库中，要提前定义字段才能使用， 在elasticsearch中，对于字段是非常灵活的，有时候，我们可以
Elasticsearch 聚合分析
大灰狼的专栏
10-17 1万+
Elasticsearch聚合定义 聚合有助于基于搜索查询提供聚合数据。 它基于称为聚合的简单构建块，可以组合以构建复杂的数据。 基本语法结构如下： "aggregations" : { "<aggregation_name>" : { "<aggregation_type>" : { <aggregation_b...
Elasticsearch 的安装与使用（三）: python操作Elasticsearch增删改查
mygodit的博客
06-06 1453
python链接ES： from elasticsearch import Elasticsearch self.es = Elasticsearch([{'host': "192.168.1.88", 'port': 9200}]) 可以指定链接的ES的IP ES插入数据: 插入单条数据 for i in range(10): self.es.index(index...
Elasticsearch入门（五）：Elasticsearch基础概念与基本操作
热门推荐
蛋壳城堡
04-29 1万+
引子 在上一篇博文 Elasticsearch入门（四）：使用docker搭建Elasticsearch 7.0.0 集群，安装head插件中，我讲了如何在docker环境下搭建ES集群、安装head插件。接下来本文中，我将讲一些Elasticsearch的基础知识，以及一些基础操作。 该文章，我是跟着慕课网的Elasticsearch教程第三、四章节走的。 基础概念 1、索引（Index...
python
ziqiaowang的专栏
02-10 449
通过python对接ES（安全认证），输入城市楼盘数据返回权重高（top 10）的数据。
spring-boot-starter-data-elasticsearch 的增删查改demo
05-26
好的，下面是一个简单的示例： 1. 引入依赖 在 pom.xml 文件中添加以下依赖： ```xml <groupId>org.springframework.boot ...运行测试类，查看控制台输出结果，即可验证增删查改功能是否正常。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值