curl -XPOST "http://192.168.9.19:9200/vivo_vimc"

curl -XGET "http://192.168.9.19:9200/vivo_ ... ot%3B
 

curl -XPOST http://192.168.9.19:9200/vivo_vmic/apps/_mapping -d '{

  "apps" : {

    "properties" : {

      "appName" : {

        "type" : "string",

        "index" : "not_analyzed",

        "fields" :{

         "cn": {

           "type"  : "string",

           "index" : "analyzed",

           "analyzer": "ik"

          },

          "en": {

           "type"  : "string",

          }

        },

        "store":"yes"

      },

      "status" : {

        "type" : "boolean"

      },

      "type" : {

        "type" : "integer"

      },

      "onsaleDate" : {

        "type" : "date"

      },

    }

  }

}'

curl -XPOST "http://192.168.9.19:9200/vivo_ ... ot%3B -d '{

    "apps": {

        "properties": {

            "score":{

                "type":"float"

                }

        }

    }

}'

{

  "acknowledged" : true

}

• true  ：支持动态扩展，新增数据有新的属性时，自动添加，索引成功
• false ：不支持动态扩展，新增数据有新的属性时，直接忽略，索引成功
• strict: 不支持动态扩展，新增数据有新的属性时，会报错，索引失败

• string

• date :           如果不明确指定，那么默认的date格式是："strict_date_optional_time||epoch_millis"，这是官网的表述，意思是可以是一个字符串类型的输入，也可以是数值类型的输入，前者可以是日期或者日期加上时间，后者则是毫秒数。关于时区信息：不管业务上是否需要时区信息，我们建议依然保存，以防万一。另外，data类型在明确指定 format 参数时，也有很多坑，对于format: epoch_second, epools_millis ,如果你想用来排序，那么为了性能，我们强烈建议你使用 epoc_second，差距很大哟，你可以亲自做一个对比测试。

•  long, integer, short, byte, double ,float 希望此类字段参与搜索和聚合的话，就不能设置not_analyzed。

• boolean, binaryboolean类型比较特殊，在ES里面只定义了false类的值（ false, "false", "off", "no", "0", "" , 0, 0.0 ），其他所有都认为是true。实践中，我们建议优先使用 0（编程和性能友好），其次使用 true（兼容json默认的类型）。

•  ipv4 type:ip 日志分析等最常用的数据类型，注意这里的是ipv4，ipv6目前暂不支持（ES 2.x）；赋值时其实传递的是字符串，但ES内部其实保存的是一个long类型。

• geo type:geo_point ， type:geo_shape  LBS服务的必选数据类型，但不建议完全依赖此特性，业务层面要尽可能地缩小范围，或者在使用围栏类功能时，只要业务容忍，使用正方形代替圆形。

• 数组，对象，内嵌将一个复杂对象放在一个属性中，其中数组最常用。

• completion主要是用来做自动完成和拼写纠错的。

curl -s -XPUT http://192.168.9.19:9200/vivo_vimc -d '

{

    "mappings": {

        "apps": {

            "_id": {

                "path": "uuid"

            },

            "properties": {

                "cnName": {

                    "type":   "string",

                    "index":  "analyzed"

                }

            }

        }

    }

}'

index                        alias
vivo_appstore_log_20160108  
vivo_appstore_log_20160109  vivo_appstore_log
vivo_appstore_log_20160110  vivo_appstore_log
vivo_appstore_log_20160111  vivo_appstore_log
...

GET /vivo_vimc/apps/_analyze?text=Hello, vivo 移动互联网&analyzer=ik

GET /vivo_vimc/apps/_analyze

{

  "field": "appName",

  "text": "Pokemon Go"

}

• 重新看lucene源码
• 看es源码
• 对比lucene和es
• 基于lucene实现自己的搜索框架

$ npm install -g cnpm --registry=https://registry.npm.taobao.org

$ cnpm install

export NODE_HOME=/usr/local/elastic/node/node-v6.9.2-linux-x64

export PATH=$NODE_HOME/bin:$PATH

$ source /etc/profile

http.cors.enabled: true

http.cors.allow-origin: "*"

./grunt server 

npm install mysql_2_elasticsearch

var esMysqlRiver = require('mysql_2_elasticsearch');



var river_config = {

  mysql: {

    host: '127.0.0.1',

    user: 'root',

    password: 'root',

    database: 'users',

    port: 3306

  },

  elasticsearch: {

    host_config: {               // es客户端的配置参数

      host: 'localhost:9200',

      // log: 'trace'

    },

    index: 'myIndex'

  },

  riverMap: {

    'users => users': {}         // 将数据表 users 导入到 es 类型: /myIndex/users

  }

};





/*

** 以下代码内容：

** 通过 esMysqlRiver 方法进行数据传输，方法的回调参数(一个JSON对象) obj 包含此次数据传输的结果

** 其中：

** 1. obj.total    => 需要传输的数据表数量

** 2. obj.success  => 传输成功的数据表数量

** 3. obj.failed   => 传输失败的数据表数量

** 4. obj.result   => 本次数据传输的结论

*/



esMysqlRiver(river_config, function(obj) {

  /* 将传输结果打印到终端 */

  console.log('\n---------------------------------');

  console.log('总传送：' + obj.total + '项');

  console.log('成功：' + obj.success + '项');

  console.log('失败：' + obj.failed + '项');

  if (obj.result == 'success') {

    console.log('\n结论：全部数据传送完成！');

  } else {

    console.log('\n结论：传送未成功...');

  }

  console.log('---------------------------------');

  console.log('\n(使用 Ctrl + C 退出进程)');

  /* 将传输结果打印到终端 */

});

var esMysqlRiver = require('mysql_2_elasticsearch');



/*

** mysql_2_elasticsearch 的相关参数配置(详情见注释)

*/



var river_config = {



  /* [必需] MySQL数据库的相关参数(根据实际情况进行修改) */

  mysql: {

    host: '127.0.0.1',

    user: 'root',

    password: 'root',

    database: 'users',

    port: 3306

  },



  /* [必需] es 相关参数(根据实际情况进行修改) */

  elasticsearch: {

    host_config: {               // [必需] host_config 即 es客户端的配置参数，详细配置参考 es官方文档

      host: 'localhost:9200',

      log: 'trace',

      // Other options...

    },

    index: 'myIndex',            // [必需] es 索引名

    chunkSize: 8000,             // [非必需] 单分片最大数据量，默认为 5000 (条数据)

    timeout: '2m'                // [非必需] 单次分片请求的超时时间，默认为 1m

    //(注意：此 timeout 并非es客户端请求的timeout，后者请在 host_config 中设置)

  },



  /* [必需] 数据传送的规则 */

  riverMap: {

    'users => users': {            // [必需] 'a => b' 表示将 mysql数据库中名为 'a' 的 table 的所有数据 输送到 es中名为 'b' 的 type 中去

      filter_out: [                // [非必需] 需要过滤的字段名，即 filter_out 中的设置的所有字段将不会被导入 elasticsearch 的数据中

        'password',

        'age'

      ],

      exception_handler: {           // [非必需] 异常处理器，使用JS正则表达式处理异常数据，避免 es 入库时由于类型不合法造成数据缺失

        'birthday': [                // [示例] 对 users 表的 birthday 字段的异常数据进行处理

          {

            match: /NaN/gi,          // [示例] 正则条件(此例匹配字段值为 "NaN" 的情况)

            writeAs: null            // [示例] 将 "NaN" 重写为 null

          },

          {

            match: /(\d{4})年/gi,    // [示例] 正则表达式(此例匹配字段值为形如 "2016年" 的情况)

            writeAs: '$1.1'          // [示例] 将 "2015年" 样式的数据重写为 "2016.1" 样式的数据

          }

        ]

      }

    },

    // Other fields' options...

  }



};





/*

** 将传输结果打印到终端

*/



esMysqlRiver(river_config, function(obj) {

  console.log('\n---------------------------------');

  console.log('总传送：' + obj.total + '项');

  console.log('成功：' + obj.success + '项');

  console.log('失败：' + obj.failed + '项');

  if (obj.result == 'success') {

    console.log('\n结论：全部数据传送完成！');

  } else {

    console.log('\n结论：传送未成功...');

  }

  console.log('---------------------------------');

  console.log('\n(使用 Ctrl + C 退出进程)');

});

select * from x_order where userId = 1 order by id desc limit 10,1;



解析之后会变成golang的一个struct，来看看具体的定义：



&sqlparser.Select{

    Comments:sqlparser.Comments(nil),

    Distinct:"",

    SelectExprs:sqlparser.SelectExprs{(*sqlparser.StarExpr)(0xc42000aee0)},

    From:sqlparser.TableExprs{(*sqlparser.AliasedTableExpr)(0xc420016930)},

    Where:(*sqlparser.Where)(0xc42000afa0),

    GroupBy:sqlparser.GroupBy(nil),

    Having:(*sqlparser.Where)(nil),

    OrderBy:sqlparser.OrderBy{(*sqlparser.Order)(0xc42000af20)},

    Limit:(*sqlparser.Limit)(0xc42000af80),

    Lock:""

}

type Order struct {

    Expr      ValExpr

    Direction string

}\

type Limit struct {

    Offset, Rowcount ValExpr

}

&sqlparser.Where{

    Type:"where",

    Expr:(*sqlparser.ComparisonExpr)(0xc420016a50)

}

select * from users where user_id = 1 and product_id =2



=>



&sqlparser.Where{

    Type:"where",

    Expr:(*sqlparser.AndExpr)(0xc42000b020)

}



AndExpr有Left和Right两个成员，分别是：



Left:

&sqlparser.ComparisonExpr{

    Operator:"=",

    Left:(*sqlparser.ColName)(0xc4200709c0),

    Right:sqlparser.NumVal{0x31}

}



Right:

&sqlparser.ComparisonExpr{

    Operator:"=",

    Left:(*sqlparser.ColName)(0xc420070a50),

    Right:sqlparser.NumVal{0x32}

}

a and (b and (c or d) and e)



=>



select * from user_history where user_id = 1 and (product_id = 2 and (star_num = 4 or star_num = 5) and banned = 1)

query {

    boolmust {

        a,

        boolmust {

            b,

            c

        }

    }

}

query {

    boolmust {

        a,

        boolmust {

            b,

            boolshould {

                c,

                d

            },

            e

        }

    }

}

AndExpr => bool must [{left}, {right}]

OrExpr => bool should [{left}, {right}]

ComparisonExpr => 一般是叶子节点

ParenBoolExpr => 指代括号表达式，其实内部是上述三种节点的某一种，所以直接取出内部节点按上述方法来处理

package main

 

import (

    "fmt"

    "io/ioutil"

    "os"

)

 

func main() {

    //apply run path "." without argument.

    if len(os.Args) == 1 {

        listDir(".")

    } else {

        listDir(os.Args[1])

    }

}

 

func listDir(dirFile string) {

    files, _ := ioutil.ReadDir(dirFile)

    for _, f := range files {

        t := f.ModTime()

        fmt.Println(f.Name(), dirFile+"/"+f.Name(), f.IsDir(), t, f.Size())

 

        if f.IsDir() {

            listDir(dirFile + "/" + f.Name())

        }

    }

}

$ go get github.com/elastic/beats

$ cd $GOPATH/src/github.com/{user}

$ cookiecutter $GOPATH/src/github.com/elastic/beats/generate/beat

project_name [Examplebeat]: lsbeat

github_name [your-github-name]: {username}

beat [lsbeat]:

beat_path [github.com/{github id}]:

full_name [Firstname Lastname]: {Full Name}

$ cd lsbeat

$ tree

.

├── CONTRIBUTING.md

├── LICENSE

├── Makefile

├── README.md

├── beater

│   └── lsbeat.go

├── config

│   ├── config.go

│   └── config_test.go

├── dev-tools

│   └── packer

│       ├── Makefile

│       ├── beats

│       │   └── lsbeat.yml

│       └── version.yml

├── docs

│   └── index.asciidoc

├── etc

│   ├── beat.yml

│   └── fields.yml

├── glide.yaml

├── lsbeat.template.json

├── main.go

├── main_test.go

└── tests

    └── system

        ├── config

        │   └── lsbeat.yml.j2

        ├── lsbeat.py

        ├── requirements.txt

        └── test_base.py

$ make setup

$ git remote add origin git@github.com:{username}/lsbeat.git

$ git push -u origin master

lsbeat.yml

lsbeat:

# Defines how often an event is sent to the output

period: 1s

lsbeat:

# Defines how often an event is sent to the output

period: 10s

path: "."

$ make update

$ cat lsbeat.yml

 

################### Lsbeat Configuration Example #########################

 

############################# Lsbeat ######################################

 

lsbeat:

  # Defines how often an event is sent to the output

  period: 10s

  path: "."

###############################################################################

package config

 

import "time"

 

type Config struct {

Period time.Duration `config:"period"`

Path   string        `config:"path"`

}

 

var DefaultConfig = Config{

Period: 10 * time.Second,

Path:   ".",

}

type Lsbeat struct {

done   chan struct{}

config config.Config

client publisher.Client

 

lastIndexTime time.Time

...

}

func New(b *beat.Beat, cfg *common.Config) (beat.Beater, error) {

config := config.DefaultConfig

if err := cfg.Unpack(&config); err != nil {

return nil, fmt.Errorf("Error reading config file: %v", err)

}

 

ls := &Lsbeat{

done:   make(chan struct{}),

config: config,

}

return ls, nil

}

"@timestamp": common.Time(time.Now()),

"type": beatname,

"modtime": common.Time(t),

"filename": f.Name(),

"path": dirFile + "/" + f.Name(),

"directory": f.IsDir(),

"filesize": f.Size(),

func (bt *Lsbeat) listDir(dirFile string, beatname string, init bool) {

files, _ := ioutil.ReadDir(dirFile)

for _, f := range files {

t := f.ModTime()

 

event := common.MapStr{

"@timestamp": common.Time(time.Now()),

"type":       beatname,

"modtime":    common.Time(t),

"filename":   f.Name(),

"path":       dirFile + "/" + f.Name(),

"directory":  f.IsDir(),

"filesize":   f.Size(),

}

if init {

// index all files and directories on init

bt.client.PublishEvent(event)

} else {

// Index only changed files since last run.

if t.After(bt.lastIndexTime) {

bt.client.PublishEvent(event)

}

}

 

if f.IsDir() {

bt.listDir(dirFile+"/"+f.Name(), beatname, init)

}

}

}

import (

"fmt"

"io/ioutil"

"time"

)

func (bt *Lsbeat) Run(b *beat.Beat) error {

logp.Info("lsbeat is running! Hit CTRL-C to stop it.")

 

bt.client = b.Publisher.Connect()

ticker := time.NewTicker(bt.config.Period)

counter := 1

for {

 

select {

case <-bt.done:

return nil

case <-ticker.C:

}

 

bt.listDir(bt.config.Path, b.Name, true)   // call lsDir

bt.lastIndexTime = time.Now()               // mark Timestamp

 

logp.Info("Event sent")

counter++

}

 

}

func (bt *Lsbeat) Stop() {

bt.client.Close()

close(bt.done)

}

- key: lsbeat

  title: LS Beat

  description:

  fields:

    - name: counter

      type: integer

      required: true

      description: >

        PLEASE UPDATE DOCUMENTATION

    #new fiels added lsbeat

    - name: modtime

      type: date

    - name: filename

      type: text

    - name: path

    - name: directory

      type: boolean

    - name: filesize

      type: long

{

  "mappings": {

        ...

  },

  "order": 0,

  "settings": {

    "index.refresh_interval": "5s",

    "analysis": {

      "analyzer": {

        "ls_ngram_analyzer": {

          "tokenizer": "ls_ngram_tokenizer"

        }

      },

      "tokenizer": {

        "ls_ngram_tokenizer": {

          "type": "ngram",

          "min_gram": "2",

          "token_chars": [

            "letter",

            "digit"

          ]

        }

      }

    }

  },

  "template": "lsbeat-*"

}

lsbeat:

  # Defines how often an event is sent to the output

  period: 10s

  path: "/Users/ec2-user/go"

• app
• visTypes
• spyModes
• fieldFormatter