es中的dsl练习题-----简单的dsl语句

slirp4netns >= 0.4 fuse-overlayfs >= 0.7

这是在本地安装elasticsearch数据然后通过kibana来操作数据的dsl来实现的
其中的查询api文档主要就是来自于：
https://elasticsearchjava-api.readthedocs.io/en/latest/index.html
后面的api因为应用到的比较少，所以就没怎么编写对应的接口了

#其实这是一个新增数据的语法也是一个修改的语法
#在这里改为put其实是更好一些，因为put指定了具体的数据
POST test1/_doc/1
{
  "uid": "1234",
  "phone": "123456",
  "message": "1",
  "msgcode": "1",
  "sendtime": "2019-03-14 01:14:20"
}

#记住这里是从数据库中指定的类型中获取到id为1的数据
GET test1/_doc/1
#这是获取整个数据库中的所有数据
GET test1

#自己定义一个索引库，其中的mappings是一个数据结构
#自己定义就不会采用默认的数据结构了，这样的效率会比较快点
#其中的settings主要的作用就是用来修改分片与副本数的
PUT jason
{
  "settings": {
    "number_of_shards": 10,
    "number_of_replicas": 1,
    "refresh_interval": "1s"
  },
  "mappings": {
    
      "properties":{
        "uid":{"type": "long"},
        "phone":{"type": "long"},
        "message":{"type": "keyword"},
        "msgcode":{"type": "long"},
        "sendtime":{
          "type":"date",
          "format":"yyyy-MM-dd HH:mm:ss"
        }
      
    }
  }
}

GET jason/

#修改es中的数据
#通过主键id的方式进行修改数据
POST jason/_doc/78
{
  "uid": "175",
  "phone": "176590660",
  "message": "章美",
  "msgcode": "1",
  "sendtime": "2020-12-14 01:14:20"
}


#根据id来查询索引库
GET jason/_doc/1

#相当于mysql中的where语句来修改数据的语法
#将电话号码为176259062360中的message数据修改为ruantongqinaduan这样一种数据
POST jason/_update_by_query
{
  "query":{
    "term":{
      "phone":"1762562360"
    }
  },
  "script":{
    "source": "ctx._source['message'] = 'ruantongqinaduan'"
  }
}


#这是查询数据库中的数据与结构
GET jason/

#根据数据中的id来删除数据
DELETE test1/_doc/1


#删除phone为123456中的数据
POST test1/_doc/delete_by_query
{
  "query":{
    "term":{
      "phone": "123456"
    }
  }
}

#删除一个字段的所有数据，由于我的数据量太少，所以这个语法我没有真正的试验过
POST test1/_doc/_update_by_query
{
  "script":{
    "lang":"painless",
    "inline":"ctx._source.remove(\"msgcode\")"
  }
}

#查询语句，查询出所有的数据查询集群所有索引库的信息，包含一些隐藏索引库的信息
#完全匹配数据
GET _search
{
  "query":{
    "match_all": {}
  }
}


#查询索引库中所有的数据
GET jason/_doc/_search

#查询具体的id的数据
GET jason/_doc/1

#等值（term）查询，这是精确的条件
GET jason/_doc/_search
{
  "query":{
    "term":{
      "phone":"176259060"
    }
  }
}


#如果你想在一个字段匹配多个值的话，可以使用terms，相当于sql的in语法
GET jason/_doc/_search
{
  "query":{
    "terms":{
      "uid":[
        176,
        12
        ]
    }
  }
}


#查询range中的关键字
#这个语法由于没有生效，因为存储的数据为string导致失效
GET jason/_doc/search
{
  "query": {
    "range":{
      "uid": {
        "gte": 165,
        "lte": 177
      }
    }
  }
}


#exist存在字段查询，其实就是非null的一些字段数据
GET jason/_doc/_search
{
  "query":{
    "exists":{
      "field": "uid"
    }
  }
}


#bool可以用来合并多个过滤条件查询结果的布尔逻辑
GET jason/_doc/_search
{
  "query":{
    "bool":{
      "must":{
        "term":{
          "phone": "176206660"
        }
      },
      "must_not":{
        "term":{
          "uid": "7890"
        }
      },
      "should":[
      {
        "term":{
          "uid": "176"
        }
      }
      ],
      "adjust_pure_negative": true,
      "boost": 1
    }
  }
}

#模糊查询，其中的*，？这些通配符比较耗性能
#查询在message字段上面的以ruan开头的所有数据
GET jason/_doc/_search
{
  "query":{
    "wildcard":{
      "message": "ruan*"
    }
  }
}

#正则表达式，查询出信息为ruan到0-9的数据
GET jason/_doc/_search
{
  "query":{
    "regexp":{
      "message":"ruan[0-9]"
    }
  }
}

#因为这不是自定义的字段，所以在数据字段类型上
#是无法进行范围查询的
PUT /questionnaire_record/_doc/9
{
  "id": "6",
  "uid":"12",
  "activityNo": "AC20122403071370181",
  "activityCustomType":1,
  "elapsedTime":12,
  "winPrize": true,
  "browerFrom":"wap"
}


#查询索引库中的数据
GET /questionnaire_option_record/_search

GET /questionnaire_record/_search

#可以理解为查询questionnaire_record索引中
#活动编号为AC20122403071370181的数据
GET /questionnaire_record/_search
{
  "query":
  {
    "match":
    {
      "activityNo": "AC20122403071370181"
    }
  }
}

#多条件查询，有点像mysql中的or查询语句
#查询id与UID字段数据为12的所有数据
GET /questionnaire_record/_search
{
  "query": {
    "multi_match":{
      "query":    "12",
    "fields": ["id", "uid"]
    }
  }
}

#通用词条查询，具体的功能还未了解到
GET /questionnaire_record/_search
{
  "query":{
    "common": {
      "body": {
        "query": "这是一个查询测试",
        "cutoff_frequency": 0.001
      }
    }
  }
}

 
#功能点：根据一个字段
#查询出它的值为pc或者是wap的数据
#有点像mysql中的or关键字
GET /questionnaire_record/_search
{
  "query":
  {
    "query_string": {
      "default_field": "browerFrom",
      "query": "(pc)"
    }
  }
}


#简单查询字符串查询不会引起异常，并且会丢弃查询的无效部分
#就是将应用来源中的app排除在外，同时过滤出pc部分的数据
GET /questionnaire_record/_search
{
  "query":{
    "simple_query_string": {
      "query": "\"pc\" -app",
      "fields": ["browerFrom"]
    }
  }
}


#倒排索引中包含确切术语的文档，精确查询出活动编号为Ac20122403071370181的数据
POST /questionnaire_record/_search
{
  "query":{
    "term":{
      "activityNo": "AC20122403071370181"
    }
  }
}


#范围查询只能作用在数字字段上，string类型
#这个写法好像是不支持的
GET /questionnaire_record/_search
{
  "query":
  {
    "range": {
      "uid":{
        "gte":1,
        "lte":14,
        "boost": 1
      }
    }
  }
}


#返回null原始字段中至少具有一个非值得文档，将字段winPrize中的非空数据展示出来
GET /questionnaire_record/_search
{
  "query":
  {
    "exists":{
      "field": "winPrize"
    }
  }
}


#测试es中的范围查询数据，区别点：
#在这个数据插入部分其中的age字段的值都是整数型
PUT /school/student/14
{
  "name": "JetWu",
  "age": 22,
  "city": "chengdu",
  "interests":["run","qiicky_run","mountain climbing"],
  "introduction": "i am form hengyang. i love my hometown"
}

PUT /school/student/8
{
  "name": "jason",
  "age": 18,
  "city": "hefei",
  "interests": ["swiming","sleep"],
  "introduction": "阳光男孩"
}

PUT /school/student/4
{
  "name": "hello",
  "age":15,
  "city": "china",
  "interests":["chinese","game"],
  "introduction":"大家好，我是一个宅男"
}


#查询数据是否插入成功
GET /school/_search/

#范围查询数据，查询出年龄大于等于15且小于等于20的数据
#经过执行后发现boost属性好像并没有生效
GET /school/student/_search
{
  "query":{
    "range":{
      "age":{
        "gte":15,
        "lte":20,
        "boost": 2.0
      }
    }
  }
}

#这个语句与前面的语句的作用是一样的

#都是查询在age这个字段上面非空的数据，查询出age字段上非空的数据
GET /school/student/_search
{
  "query":
  {"exists": {"field": "age"}
  }
}

#前缀查询，匹配具有包含带有指定前缀的术语的字段的文档
#查询出名称这个字段上为Jason的数据
GET /school/student/_search
{
  "query":{
    "prefix":{"name": {"value": "jason"}
    }
  }
}

#通配符查询,其中*代表是所有的，?代表的
#就是一个字符
#wildcard有点像like关键字，查询出name在jet?u的数据
GET /school/student/_search
{
  "query":{
    "wildcard": {
      "name":{"value": "jet?u"}
    }
  }
}

#模糊查询
#该fuzzy查询将生成在中指定的最大编辑距离内的匹配术语
GET /school/student/_search
{
  "query":{
    "fuzzy": {
      "name":"jason"
    }
  }
}

#类型查询,查询出对应的表数据，查询索引库中的type类型值为student的数据
GET /_search
{
  "query":{
    "type":{
      "value" : "student"
    }
  }
}

#ID查询相关的数据与dsl数据，查询数据id值在5.8.9这三个字段上的所有数据
GET /_search
{
  "query":{
    "ids" : {
      "type":"student",
      "values":["5","8", "9"]
    }
  }
}

#恒定分数查询
GET /_search
{
  "query":{
    "constant_score": {
      "filter": {"terms":{
        "name": "jason"
      }},
      "boost": 1.2
    }
  }
}

#布尔查询--就是有点像多条件查询意思
#首先测试must查询语句
#查询出名称必须是jaosn,年龄不为13，且introduction应该为阳光男孩的数据
POST /school/student/_search
{
  "query":{
    "bool":{
      "must":[
        {
          "match":{
            "name": "jason"
          }
        }
        ]
       , "must_not": [
         {
           "match": {
             "age":13
           }
         }
       ]
       , "should": [
         {
           "match": {
             "introduction": "阳光男孩"
           }
         }
       ]
    }
  }
}

#最佳字段查询，这样有利于搜索数据，这个语句就是
GET /school/student/_search
{
  "query": {
    "dis_max": {
      "queries": [
        {"match":{"name": "chengdu"}},
        {"match": {
          "city":"chengdu"
        }}
        ]
    }
  }
}

#查询插入的语句
GET /my_index/_search/

#由于要使用嵌套查询，我们这边就需要采用重新定义数据结构
#所以我们在定义数据结构时，我们是需要采用嵌套语句定义的
#定义一个数据结构
 PUT blog
 {
   "mappings": {
     "_doc":{
       "properties":{
         "blog":{
           "properties":{
             "title":{
               "type":"keyword"
             },
             "content":{
               "type":"text"
             },
             "comment":{
               "type":"nested",
               "properties":{
                 "content":{
                   "type": "text"
                 },
                 "username":{
                   "type":"keyword"
                 }
               }
             }
           }
         }
       }
     }
   }
 }

#往刚才定义的嵌套语句中插入数据
PUT blog/_doc/1
{
  "blog":{
    "title":"this is my first blog",
    "content": "this is my first blog content",
    "comment":[
      {
        "content": "oh so good",
        "username": "zhang san"
      },
      {
        "content": "so bad",
        "username": "lisi"
      }
      ]
  }
}


GET blog/_search
#然后查询出张三的评论数据
GET blog/_search
{
  "query":{
    "bool":{
      "must":[
        {
          "match":{
            "blog.comment.content": "good"
          }
        },
        {
          "match": {
            "blog.comment.username": "lisi"
          }
        }
        ]
    }
  }
}

总结点：在实践这些dsl语句中主要碰见一些问题是如下的
1：在时间范围查询语法中，主要是涉及到数据类型无法执行查询
2：没有实践时间范围的查询
3：在范围查询中的boost属性没有生效
4：前缀查询中踩过的坑，如果内容中的有中文字段时是没法过滤出数据的