精华内容
下载资源
问答
  • impala中转换字段类型,类型强转

    千次阅读 2019-10-30 12:10:17
    cast(字段名 as 要转换为的类型) 例如:要将student表中的age字段(原本是int类型)转成string类型,如下: cast(student.age as string) as age --年龄

    cast(字段名 as 要转换为的类型)
    例如:要将student表中的age字段(原本是int类型)转成string类型,如下:
    cast(student.age as string) as age --年龄

    展开全文
  • mysql数据类型、字段类型

    千次阅读 2016-07-13 16:10:52
    mysql数据类型、字段类型 1. mysql的数据类型  在mysql中有如下几种数据类型:  (1)数值型  数值是诸如32 或153.4 这样的值。mysql 支持科学表示法,科学表示法由整数或浮点数后跟“e”或“e”、一...

    mysql数据类型、字段类型

    1. mysql的数据类型

           在mysql中有如下几种数据类型:

           (1)数值型

           数值是诸如32 或153.4 这样的值。mysql 支持科学表示法,科学表示法由整数或浮点数后跟“e”或“e”、一个符号(“+”或“-”)和一个整数指数来表示。1.24e+12 和23.47e-1 都是合法的科学表示法表示的数。而1.24e12 不是合法的,因为指数前的符号未给
           浮点数由整数部分、一个小数点和小数部分组成。整数部分和小数部分可以分别为空,但不能同时为空。
           数值前可放一个负号“-”以表示负值。
           (2)字符(串)型 
           字符型(也叫字符串型,简称串)是诸如“hello, world!”或“一个馒头引起的血案”这样的值,或者是电话号码87398413这样的值。既可用单引号也可用双引号将串值括起来。
           初学者往往分不清数值87398143和字符串87398143的区别。都是数字啊,怎么一个要用数值型,一个要用字符型呢?关键就在于:数值型的87398143是要参与计算的,比如它是金融中的一个货款总额;而字符型的87398143是不参与计算的,只是表示电话号码,这样的还有街道号码、门牌号码等等,它们都不参与计算。      (3)日期和时间型 
           日期和时间是一些诸如“2006-07-12”或“12:30:43”这样的值。mysql还支持日期/时间的组合,如“2006-07-12 12:30:43”。
           (4)null值 
           null表示未知值。比如填写表格中通讯地址不清楚留空不填写,这就是null值。
           我们用create table语句创建一个表(参看前面的章节),这个表中包含列的定义。例如我们在前面创建了一个joke表,这个表中有content和writer两个列:   create table
    (
    content varchar(20) not null,
    writer varchar(10) null

      

          定义一个列的语法如下:

    col_name col_typy [col_attributes] [general_attributes]


          其中列名由col_name 给出。列名可最多包含64个字符,字符包括字母、数字、下划线及美元符号。列名可以名字中合法的任何符号(包括数字)开头。但列名不能完全由数字组成,因为那样可能使其与数据分不开。mysql保留诸如select、delete和create这样的词,这些词不能用做列名,但是函数名(如pos 和min)是可以使用的。
           列类型col_type表示列可存储的特定值。列类型说明符还能表示存放在列中的值的最大长度。对于某些类型,可用一个数值明确地说明其长度。而另外一些值,其长度由类型名蕴含。例如,char(10) 明确指定了10个字符的长度,而tinyblob值隐含最大长度为255个字符。有的类型说明符允许指定最大的显示宽度(即显示值时使用多少个字符)。浮点类型允许指定小数位数,所以能控制浮点数的精度值为多少。

           可以在列类型之后指定可选的类型说明属性,以及指定更多的常见属性。属性起修饰类型的作用,并更改其处理列值的方式,属性有以下类型:
           (1)专用属性用于指定列。例如,unsigned 属性只针对整型,而binary属性只用于char 和varchar。
           (2)通用属性除少数列之外可用于任意列。可以指定null 或not null 以表示某个列是否能够存放null。还可以用default,def_value 来表示在创建一个新行但未明确给出该列的值时,该列可赋予值def_value。def_value 必须为一个常量;它不能是表达式,也不能引用其他列。不能对blob 或text 列指定缺省值。
           如果想给出多个列的专用属性,可按任意顺序指定它们,只要它们跟在列类型之后、通用属性之前即可。类似地,如果需要给出多个通用属性,也可按任意顺序给出它们,只要将它们放在列类型和可能给出的列专用属性之后即可。

           2. mysql的列(字段)类型 
           数据库中的每个表都是由一个或多个列(字段)构成的。在用create table语句创建一个表时,要为每列(字段)指定一个类型。列(字段)的类型比数据类型更为细化,它精确地描述了给定表列(字段)可能包含的值的种类,如是否带小数、是否文字很多。

           2.1数值列类型

          mysql有整数和浮点数值的列类型,如表1所示。整数列类型可以有符号也可无符号。有一种特殊的属性允许整数列值自动生成,这对需要唯一序列或标识号的应用系统来说是非常有用的。

    类型
    说明

    tinyint 非常小的整数 
    smallint 较小整数 
    mediumint 中等大小整数 
    int 标准整数 
    bigint 较大整数 
    float 单精度浮点数 
    double 双精度浮点数 
    decimal 一个串的浮点数


    表1:数值列类型

           每种数值类型的名称和取值范围如表2所示。

    类型说明
    取值范围

    tinyint[(m)] 有符号值:-128 到127(- 27 到27 - 1)
    无符号值:0到255(0 到28 - 1) 
    smallint[(m)] 有符号值:-32768 到32767(- 215 到215 - 1)
    无符号值:0到65535(0 到21 6 - 1) 
    mediumint[(m)] 有符号值:-8388608 到8388607(- 22 3 到22 3 - 1 )
    无符号值:0到16777215(0 到22 4 - 1) 
    int[(m)] 有符号值:-2147683648 到2147683647(- 231 到231- 1)
    无符号值:0到4294967295(0 到232 - 1) 
    bigint[(m)] 有符号值:-9223372036854775808 到9223373036854775807(- 263到263-1)

    无符号值:0到18446744073709551615(0到264 – 1) 
    float[(m, d)] 最小非零值:±1.175494351e - 38 
    double[(m,d)] 最小非零值:±2.2250738585072014e - 308 
    decimal (m, d) 可变;其值的范围依赖于m 和d

    表2:数值列类型的取值范围

           各种类型值所需的存储量如表3所示。

    类型说明
    存储需求

    tinyint[(m)] 1字节 
    smallint[(m)] 2字节 
    mediumint[(m)] 3字节 
    int[(m)] 4字节 
    bigint[(m)] 8字节 
    float[(m, d)] 4字节 
    double[(m, d)] 8字节 
    decimal (m, d) m字节(mysql < 3.23),m+2字节(mysql > 3.23 )


    表3:数值列类型的存储需求

    mysql提供了五种整型: tinyint、smallint、mediumint、int和bigint。int为integer的缩写。这些类型在可表示的取值范围上是不同的。整数列可定义为unsigned从而禁用负值;这使列的取值范围为0以上。各种类型的存储量需求也是不同的。取值范围较大的类型所需的存储量较大。

          mysql 提供三种浮点类型: float、double和decimal。与整型不同,浮点类型不能是unsigned的,其取值范围也与整型不同,这种不同不仅在于这些类型有最大值,而且还有最小非零值。最小值提供了相应类型精度的一种度量,这对于记录科学数据来说是非常重要的(当然,也有负的最大和最小值)。

           在选择了某种数值类型时,应该考虑所要表示的值的范围,只需选择能覆盖要取值的范围的最小类型即可。选择较大类型会对空间造成浪费,使表不必要地增大,处理起来没有选择较小类型那样有效。对于整型值,如果数据取值范围较小,如人员年龄或兄弟姐妹数,则tinyint最合适。mediumint能够表示数百万的值并且可用于更多类型的值,但存储代价较大。bigint在全部整型中取值范围最大,而且需要的存储空间是表示范围次大的整型int类型的两倍,因此只在确实需要时才用。对于浮点值,double占用float的两倍空间。除非特别需要高精度或范围极大的值,一般应使用只用一半存储代价的float型来表示数据。

           在定义整型列时,可以指定可选的显示尺寸m。如果这样,m应该是一个1 到255的整数。它表示用来显示列中值的字符数。例如,mediumint(4)指定了一个具有4个字符显示宽度的mediumint列。如果定义了一个没有明确宽度的整数列,将会自动分配给它一个缺省的宽度。缺省值为每种类型的“最长”值的长度。如果某个特定值的可打印表示需要不止m个字符,则显示完全的值;不会将值截断以适合m个字符。

           对每种浮点类型,可指定一个最大的显示尺寸m 和小数位数d。m 的值应该取1 到255。d的值可为0 到3 0,但是不应大于m - 2(如果熟悉odbc 术语,就会知道m 和d 对应于odbc 概念的“精度”和“小数点位数”)。m和d对float和double 都是可选的,但对于decimal是必须的。在选项m 和d时,如果省略了它们,则使用缺省值。


           2.2字符串列类型

          mysql提供了几种存放字符数据的串类型,其类型如下:

    类型名
    说明

    char 定长字符串 
    varchar 可变长字符串 
    tinyblob 非常小的blob(二进制大对象) 
    blob 小blob 
    mediumblob 中等的blob 
    longblob 大blob 
    tinytext 非常小的文本串 
    text 小文本串 
    mediumtext 中等文本串 
    longtext 大文本串 
    enum 枚举;列可赋予某个枚举成员 
    set 集合;列可赋予多个集合成员


    表4:字符串列类型

           下表给出了mysql 定义串值列的类型,以及每种类型的最大尺寸和存储需求。对于可变长的列类型,各行的值所占的存储量是不同的,这取决于实际存放在列中的值的长度。这个长度在表中用l 表示。

    类型说明
    最大尺寸
    存储需求

    char( m) m 字节 m 字节 
    varchar(m) m 字节 l + 1字节 
    tinyblob, tinytext 28- 1字节 l + 1字节 
    blob, text 216 - 1 字节 l + 2字节 
    mediumblob, mediumtext 224- 1字节 l + 3字节 
    longblob, longtext 232- 1字节 l + 4字节 
    enum(“value1”, “value2”, ...) 65535 个成员 1 或2字节 
    set (“value1”, “value2”, ...) 64个成员 1、2、3、4 或8字节


    表5:串列类型最大尺寸及存储需求

           l 以外所需的额外字节为存放该值的长度所需的字节数。mysql 通过存储值的内容及其长度来处理可变长度的值。这些额外的字节是无符号整数。请注意,可变长类型的最大长度、此类型所需的额外字节数以及占用相同字节数的无符号整数之间的对应关系。例如,mediumblob 值可能最多224 - 1字节长并需要3 个字节记录其结果。3 个字节的整数类型mediumint 的最大无符号值为224 - 1。这并非偶然。

           2.3日期时间列类型

          mysql 提供了几种时间值的列类型,它们分别是: date、datetime、time、timestamp和year。下表给出了mysql 为定义存储日期和时间值所提供的这些类型,并给出了每种类型的合法取值范围。

    类型名
    说明

    date “yyyy-mm-dd”格式表示的日期值 
    time “hh:mm:ss”格式表示的时间值 
    datetime “yyyy-mm-dd hh:mm:ss”格式 
    timestamp “yyyymmddhhmmss”格式表示的时间戳值 
    year “yyyy”格式的年份值


    表6:日期时间列类型

    类型名
    取值范围
    存储需求

    date “1000-01-01”到“9999-12-31” 3字节 
    time “-838:59:59”到“838:59:59” 3字节 
    datetime “1000-01-01 00:00:00” 到“9999-12-31 23:59:59” 8字节 
    timestamp 19700101000000 到2037 年的某个时刻 4字节 
    year 1901 到2155 1字节


    表7: 日前时间列类型的取值范围和存储需求

           下面举个例子:

    create table student
    (
    name varchar(20) not null,
    chinese tinyint(3),
    maths tinyint(3),
    english tinyint(3),
    birthday date
    )


           这个例子创建一个student表,这个表中有name字段,字符类型列,不允许null(空值)。有chinese、maths和english三个整数类型列。还有个birthday日期类型列。

    展开全文
  • ES Mapping、字段类型Field type详解

    万次阅读 多人点赞 2018-10-15 15:02:18
    字段类型概述 一级分类 二级分类 具体类型 核心类型 字符串类型 string,text,keyword 整数类型 integer,long,short,byte 浮点类型 double,float,half_float,scaled_float 逻辑类型 boolean 日期类型 date 范围类型 ...

     

    字段类型概述
    一级分类	二级分类	具体类型
    核心类型	字符串类型	string,text,keyword
    整数类型	integer,long,short,byte
    浮点类型	double,float,half_float,scaled_float
    逻辑类型	boolean
    日期类型	date
    范围类型	range
    二进制类型	binary
    复合类型	数组类型	array
    对象类型	object
    嵌套类型	nested
    地理类型	地理坐标类型	geo_point
    地理地图	geo_shape
    特殊类型	IP类型	ip
    范围类型	completion
    令牌计数类型	token_count
    附件类型	attachment
    抽取类型	percolator
    

    一、Field datatype(字段数据类型)

    1.1string类型

    ELasticsearch 5.X之后的字段类型不再支持string,由text或keyword取代。 如果仍使用string,会给出警告。

    测试:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "title": {
              "type":  "string"
            }
          }
        }
      }
    }

    结果:

    #! Deprecation: The [string] field is deprecated, please use [text] or [keyword] instead on [title]
    {
      "acknowledged": true,
      "shards_acknowledged": true
    }

    1.2 text类型

    text取代了string,当一个字段是要被全文搜索的,比如Email内容、产品描述,应该使用text类型。设置text类型以后,字段内容会被分析,在生成倒排索引以前,字符串会被分析器分成一个一个词项。text类型的字段不用于排序,很少用于聚合(termsAggregation除外)。

    把full_name字段设为text类型的Mapping如下:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "full_name": {
              "type":  "text"
            }
          }
        }
      }
    }

    1.3 keyword类型

    keyword类型适用于索引结构化的字段,比如email地址、主机名、状态码和标签。如果字段需要进行过滤(比如查找已发布博客中status属性为published的文章)、排序、聚合。keyword类型的字段只能通过精确值搜索到。

    1.4 数字类型

    对于数字类型,ELasticsearch支持以下几种:

    类型取值范围
    long-2^63至2^63-1
    integer-2^31至2^31-1
    short-32,768至32768
    byte-128至127
    double64位双精度IEEE 754浮点类型
    float32位单精度IEEE 754浮点类型
    half_float16位半精度IEEE 754浮点类型
    scaled_float缩放类型的的浮点数(比如价格只需要精确到分,price为57.34的字段缩放因子为100,存起来就是5734)

    对于float、half_float和scaled_float,-0.0和+0.0是不同的值,使用term查询查找-0.0不会匹配+0.0,同样range查询中上边界是-0.0不会匹配+0.0,下边界是+0.0不会匹配-0.0。

    对于数字类型的数据,选择以上数据类型的注意事项:

    1. 在满足需求的情况下,尽可能选择范围小的数据类型。比如,某个字段的取值最大值不会超过100,那么选择byte类型即可。迄今为止吉尼斯记录的人类的年龄的最大值为134岁,对于年龄字段,short足矣。字段的长度越短,索引和搜索的效率越高。
    2. 优先考虑使用带缩放因子的浮点类型。

    例子:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "number_of_bytes": {
              "type": "integer"
            },
            "time_in_seconds": {
              "type": "float"
            },
            "price": {
              "type": "scaled_float",
              "scaling_factor": 100
            }
          }
        }
      }
    }

    1.5 Object类型

    JSON天生具有层级关系,文档会包含嵌套的对象:

    PUT my_index/my_type/1
    { 
      "region": "US",
      "manager": { 
        "age":     30,
        "name": { 
          "first": "John",
          "last":  "Smith"
        }
      }
    }

    上面的文档中,整体是一个JSON,JSON中包含一个manager,manager又包含一个name。最终,文档会被索引成一平的key-value对:

    {
      "region":             "US",
      "manager.age":        30,
      "manager.name.first": "John",
      "manager.name.last":  "Smith"
    }

    上面文档结构的Mapping如下:

    PUT my_index
    {
      "mappings": {
        "my_type": { 
          "properties": {
            "region": {
              "type": "keyword"
            },
            "manager": { 
              "properties": {
                "age":  { "type": "integer" },
                "name": { 
                  "properties": {
                    "first": { "type": "text" },
                    "last":  { "type": "text" }
                  }
                }
              }
            }
          }
        }
      }
    }

    1.6 date类型

    JSON中没有日期类型,所以在ELasticsearch中,日期类型可以是以下几种:

    1. 日期格式的字符串:e.g. “2015-01-01” or “2015/01/01 12:10:30”.
    2. long类型的毫秒数( milliseconds-since-the-epoch)
    3. integer的秒数(seconds-since-the-epoch)

    日期格式可以自定义,如果没有自定义,默认格式如下:

    "strict_date_optional_time||epoch_millis"

    例子:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "date": {
              "type": "date" 
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    { "date": "2015-01-01" } 
    
    PUT my_index/my_type/2
    { "date": "2015-01-01T12:10:30Z" } 
    
    PUT my_index/my_type/3
    { "date": 1420070400001 } 
    
    GET my_index/_search
    {
      "sort": { "date": "asc"} 
    }

    查看三个日期类型:

    {
      "took": 0,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
      },
      "hits": {
        "total": 3,
        "max_score": 1,
        "hits": [
          {
            "_index": "my_index",
            "_type": "my_type",
            "_id": "2",
            "_score": 1,
            "_source": {
              "date": "2015-01-01T12:10:30Z"
            }
          },
          {
            "_index": "my_index",
            "_type": "my_type",
            "_id": "1",
            "_score": 1,
            "_source": {
              "date": "2015-01-01"
            }
          },
          {
            "_index": "my_index",
            "_type": "my_type",
            "_id": "3",
            "_score": 1,
            "_source": {
              "date": 1420070400001
            }
          }
        ]
      }
    }

    排序结果:

    {
      "took": 2,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
      },
      "hits": {
        "total": 3,
        "max_score": null,
        "hits": [
          {
            "_index": "my_index",
            "_type": "my_type",
            "_id": "1",
            "_score": null,
            "_source": {
              "date": "2015-01-01"
            },
            "sort": [
              1420070400000
            ]
          },
          {
            "_index": "my_index",
            "_type": "my_type",
            "_id": "3",
            "_score": null,
            "_source": {
              "date": 1420070400001
            },
            "sort": [
              1420070400001
            ]
          },
          {
            "_index": "my_index",
            "_type": "my_type",
            "_id": "2",
            "_score": null,
            "_source": {
              "date": "2015-01-01T12:10:30Z"
            },
            "sort": [
              1420114230000
            ]
          }
        ]
      }
    }

    1.7 Array类型

    ELasticsearch没有专用的数组类型,默认情况下任何字段都可以包含一个或者多个值,但是一个数组中的值要是同一种类型。例如:

    1. 字符数组: [ “one”, “two” ]
    2. 整型数组:[1,3]
    3. 嵌套数组:[1,[2,3]],等价于[1,2,3]
    4. 对象数组:[ { “name”: “Mary”, “age”: 12 }, { “name”: “John”, “age”: 10 }]

    注意事项:

    • 动态添加数据时,数组的第一个值的类型决定整个数组的类型
    • 混合数组类型是不支持的,比如:[1,”abc”]
    • 数组可以包含null值,空数组[ ]会被当做missing field对待。

    1.8 binary类型

    binary类型接受base64编码的字符串,默认不存储也不可搜索。

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "name": {
              "type": "text"
            },
            "blob": {
              "type": "binary"
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "name": "Some binary blob",
      "blob": "U29tZSBiaW5hcnkgYmxvYg==" 
    }

    搜索blog字段:

    GET my_index/_search
    {
      "query": {
        "match": {
          "blob": "test" 
        }
      }
    }
    
    返回结果:
    {
      "error": {
        "root_cause": [
          {
            "type": "query_shard_exception",
            "reason": "Binary fields do not support searching",
            "index_uuid": "fgA7UM5XSS-56JO4F4fYug",
            "index": "my_index"
          }
        ],
        "type": "search_phase_execution_exception",
        "reason": "all shards failed",
        "phase": "query",
        "grouped": true,
        "failed_shards": [
          {
            "shard": 0,
            "index": "my_index",
            "node": "3dQd1RRVTMiKdTckM68nPQ",
            "reason": {
              "type": "query_shard_exception",
              "reason": "Binary fields do not support searching",
              "index_uuid": "fgA7UM5XSS-56JO4F4fYug",
              "index": "my_index"
            }
          }
        ]
      },
      "status": 400
    }

    Base64加密、解码工具:http://www1.tc711.com/tool/BASE64.htm

    1.9 ip类型

    ip类型的字段用于存储IPV4或者IPV6的地址。

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "ip_addr": {
              "type": "ip"
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "ip_addr": "192.168.1.1"
    }
    
    GET my_index/_search
    {
      "query": {
        "term": {
          "ip_addr": "192.168.0.0/16"
        }
      }
    }

    1.10 range类型

    range类型支持以下几种:

    类型范围
    integer_range-2^31至2^31-1
    float_range32-bit IEEE 754
    long_range-2^63至2^63-1
    double_range64-bit IEEE 754
    date_range64位整数,毫秒计时

    range类型的使用场景:比如前端的时间选择表单、年龄范围选择表单等。 
    例子:

    PUT range_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "expected_attendees": {
              "type": "integer_range"
            },
            "time_frame": {
              "type": "date_range", 
              "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
            }
          }
        }
      }
    }
    
    PUT range_index/my_type/1
    {
      "expected_attendees" : { 
        "gte" : 10,
        "lte" : 20
      },
      "time_frame" : { 
        "gte" : "2015-10-31 12:00:00", 
        "lte" : "2015-11-01"
      }
    }

    上面代码创建了一个range_index索引,expected_attendees的人数为10到20,时间是2015-10-31 12:00:00至2015-11-01。

    查询:

    POST range_index/_search
    {
      "query" : {
        "range" : {
          "time_frame" : { 
            "gte" : "2015-08-01",
            "lte" : "2015-12-01",
            "relation" : "within" 
          }
        }
      }
    }

    查询结果:

    {
      "took": 2,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
      },
      "hits": {
        "total": 1,
        "max_score": 1,
        "hits": [
          {
            "_index": "range_index",
            "_type": "my_type",
            "_id": "1",
            "_score": 1,
            "_source": {
              "expected_attendees": {
                "gte": 10,
                "lte": 20
              },
              "time_frame": {
                "gte": "2015-10-31 12:00:00",
                "lte": "2015-11-01"
              }
            }
          }
        ]
      }
    }

    1.11 nested类型

    nested嵌套类型是object中的一个特例,可以让array类型的Object独立索引和查询。 使用Object类型有时会出现问题,比如文档 my_index/my_type/1的结构如下:

    PUT my_index/my_type/1
    {
      "group" : "fans",
      "user" : [ 
        {
          "first" : "John",
          "last" :  "Smith"
        },
        {
          "first" : "Alice",
          "last" :  "White"
        }
      ]
    }

    user字段会被动态添加为Object类型。 
    最后会被转换为以下平整的形式:

    {
      "group" :        "fans",
      "user.first" : [ "alice", "john" ],
      "user.last" :  [ "smith", "white" ]
    }

    user.first和user.last会被平铺为多值字段,Alice和White之间的关联关系会消失。上面的文档会不正确的匹配以下查询(虽然能搜索到,实际上不存在Alice Smith):

    GET my_index/_search
    {
      "query": {
        "bool": {
          "must": [
            { "match": { "user.first": "Alice" }},
            { "match": { "user.last":  "Smith" }}
          ]
        }
      }
    }

    使用nested字段类型解决Object类型的不足:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "user": {
              "type": "nested" 
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "group" : "fans",
      "user" : [
        {
          "first" : "John",
          "last" :  "Smith"
        },
        {
          "first" : "Alice",
          "last" :  "White"
        }
      ]
    }
    
    GET my_index/_search
    {
      "query": {
        "nested": {
          "path": "user",
          "query": {
            "bool": {
              "must": [
                { "match": { "user.first": "Alice" }},
                { "match": { "user.last":  "Smith" }} 
              ]
            }
          }
        }
      }
    }
    
    GET my_index/_search
    {
      "query": {
        "nested": {
          "path": "user",
          "query": {
            "bool": {
              "must": [
                { "match": { "user.first": "Alice" }},
                { "match": { "user.last":  "White" }} 
              ]
            }
          },
          "inner_hits": { 
            "highlight": {
              "fields": {
                "user.first": {}
              }
            }
          }
        }
      }
    }

    1.12token_count类型

    token_count用于统计词频:

    
    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "name": { 
              "type": "text",
              "fields": {
                "length": { 
                  "type":     "token_count",
                  "analyzer": "standard"
                }
              }
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    { "name": "John Smith" }
    
    PUT my_index/my_type/2
    { "name": "Rachel Alice Williams" }
    
    GET my_index/_search
    {
      "query": {
        "term": {
          "name.length": 3 
        }
      }
    }

    1.13 geo point 类型

    地理位置信息类型用于存储地理位置信息的经纬度:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "location": {
              "type": "geo_point"
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "text": "Geo-point as an object",
      "location": { 
        "lat": 41.12,
        "lon": -71.34
      }
    }
    
    PUT my_index/my_type/2
    {
      "text": "Geo-point as a string",
      "location": "41.12,-71.34" 
    }
    
    PUT my_index/my_type/3
    {
      "text": "Geo-point as a geohash",
      "location": "drm3btev3e86" 
    }
    
    PUT my_index/my_type/4
    {
      "text": "Geo-point as an array",
      "location": [ -71.34, 41.12 ] 
    }
    
    GET my_index/_search
    {
      "query": {
        "geo_bounding_box": { 
          "location": {
            "top_left": {
              "lat": 42,
              "lon": -72
            },
            "bottom_right": {
              "lat": 40,
              "lon": -74
            }
          }
        }
      }
    }

    二、Meta-Fields(元数据)

    2.1 _all

    _all字段是把其它字段拼接在一起的超级字段,所有的字段用空格分开,_all字段会被解析和索引,但是不存储。当你只想返回包含某个关键字的文档但是不明确地搜某个字段的时候就需要使用_all字段。 
    例子:

    PUT my_index/blog/1 
    {
      "title":    "Master Java",
      "content":     "learn java",
      "author": "Tom"
    }

    _all字段包含:[ “Master”, “Java”, “learn”, “Tom” ]

    搜索:

    GET my_index/_search
    {
      "query": {
        "match": {
          "_all": "Java"
        }
      }
    }

    返回结果:

    {
      "took": 1,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
      },
      "hits": {
        "total": 1,
        "max_score": 0.39063013,
        "hits": [
          {
            "_index": "my_index",
            "_type": "blog",
            "_id": "1",
            "_score": 0.39063013,
            "_source": {
              "title": "Master Java",
              "content": "learn java",
              "author": "Tom"
            }
          }
        ]
      }
    }

    使用copy_to自定义_all字段:

    PUT myindex
    {
      "mappings": {
        "mytype": {
          "properties": {
            "title": {
              "type":    "text",
              "copy_to": "full_content" 
            },
            "content": {
              "type":    "text",
              "copy_to": "full_content" 
            },
            "full_content": {
              "type":    "text"
            }
          }
        }
      }
    }
    
    PUT myindex/mytype/1
    {
      "title": "Master Java",
      "content": "learn Java"
    }
    
    GET myindex/_search
    {
      "query": {
        "match": {
          "full_content": "java"
        }
      }
    }

    2.2 _field_names

    _field_names字段用来存储文档中的所有非空字段的名字,这个字段常用于exists查询。例子如下:

    PUT my_index/my_type/1
    {
      "title": "This is a document"
    }
    
    PUT my_index/my_type/2?refresh=true
    {
      "title": "This is another document",
      "body": "This document has a body"
    }
    
    GET my_index/_search
    {
      "query": {
        "terms": {
          "_field_names": [ "body" ] 
        }
      }
    }

    结果会返回第二条文档,因为第一条文档没有title字段。 
    同样,可以使用exists查询:

    GET my_index/_search
    {
        "query": {
            "exists" : { "field" : "body" }
        }
    }

    2.3 _id

    每条被索引的文档都有一个_type和_id字段,_id可以用于term查询、temrs查询、match查询、query_string查询、simple_query_string查询,但是不能用于聚合、脚本和排序。例子如下:

    PUT my_index/my_type/1
    {
      "text": "Document with ID 1"
    }
    
    PUT my_index/my_type/2
    {
      "text": "Document with ID 2"
    }
    
    GET my_index/_search
    {
      "query": {
        "terms": {
          "_id": [ "1", "2" ] 
        }
      }
    }
    

    2.4 _index

    多索引查询时,有时候只需要在特地索引名上进行查询,_index字段提供了便利,也就是说可以对索引名进行term查询、terms查询、聚合分析、使用脚本和排序。

    _index是一个虚拟字段,不会真的加到Lucene索引中,对_index进行term、terms查询(也包括match、query_string、simple_query_string),但是不支持prefix、wildcard、regexp和fuzzy查询。

    举例,2个索引2条文档

    
    PUT index_1/my_type/1
    {
      "text": "Document in index 1"
    }
    
    PUT index_2/my_type/2
    {
      "text": "Document in index 2"
    }

    对索引名做查询、聚合、排序并使用脚本新增字段:

    GET index_1,index_2/_search
    {
      "query": {
        "terms": {
          "_index": ["index_1", "index_2"] 
        }
      },
      "aggs": {
        "indices": {
          "terms": {
            "field": "_index", 
            "size": 10
          }
        }
      },
      "sort": [
        {
          "_index": { 
            "order": "asc"
          }
        }
      ],
      "script_fields": {
        "index_name": {
          "script": {
            "lang": "painless",
            "inline": "doc['_index']" 
          }
        }
      }
    }
    

    2.4 _meta

    忽略

    2.5 _parent

    _parent用于指定同一索引中文档的父子关系。下面例子中现在mapping中指定文档的父子关系,然后索引父文档,索引子文档时指定父id,最后根据子文档查询父文档。

    PUT my_index
    {
      "mappings": {
        "my_parent": {},
        "my_child": {
          "_parent": {
            "type": "my_parent" 
          }
        }
      }
    }
    
    
    PUT my_index/my_parent/1 
    {
      "text": "This is a parent document"
    }
    
    PUT my_index/my_child/2?parent=1 
    {
      "text": "This is a child document"
    }
    
    PUT my_index/my_child/3?parent=1&refresh=true 
    {
      "text": "This is another child document"
    }
    
    
    GET my_index/my_parent/_search
    {
      "query": {
        "has_child": { 
          "type": "my_child",
          "query": {
            "match": {
              "text": "child document"
            }
          }
        }
      }
    }

    2.6 _routing

    路由参数,ELasticsearch通过以下公式计算文档应该分到哪个分片上:

    shard_num = hash(_routing) % num_primary_shards

    默认的_routing值是文档的_id或者_parent,通过_routing参数可以设置自定义路由。例如,想把user1发布的博客存储到同一个分片上,索引时指定routing参数,查询时在指定路由上查询:

    PUT my_index/my_type/1?routing=user1&refresh=true 
    {
      "title": "This is a document"
    }
    
    GET my_index/my_type/1?routing=user1

    在查询的时候通过routing参数查询:

    GET my_index/_search
    {
      "query": {
        "terms": {
          "_routing": [ "user1" ] 
        }
      }
    }
    
    GET my_index/_search?routing=user1,user2 
    {
      "query": {
        "match": {
          "title": "document"
        }
      }
    }
    

    在Mapping中指定routing为必须的:

    PUT my_index2
    {
      "mappings": {
        "my_type": {
          "_routing": {
            "required": true 
          }
        }
      }
    }
    
    PUT my_index2/my_type/1 
    {
      "text": "No routing value provided"
    }

    2.7 _source

    存储的文档的原始值。默认_source字段是开启的,也可以关闭:

    PUT tweets
    {
      "mappings": {
        "tweet": {
          "_source": {
            "enabled": false
          }
        }
      }
    }

    但是一般情况下不要关闭,除法你不想做一些操作:

    • 使用update、update_by_query、reindex
    • 使用高亮
    • 数据备份、改变mapping、升级索引
    • 通过原始字段debug查询或者聚合

    2.8 _type

    每条被索引的文档都有一个_type和_id字段,可以根据_type进行查询、聚合、脚本和排序。例子如下:

    PUT my_index/type_1/1
    {
      "text": "Document with type 1"
    }
    
    PUT my_index/type_2/2?refresh=true
    {
      "text": "Document with type 2"
    }
    
    GET my_index/_search
    {
      "query": {
        "terms": {
          "_type": [ "type_1", "type_2" ] 
        }
      },
      "aggs": {
        "types": {
          "terms": {
            "field": "_type", 
            "size": 10
          }
        }
      },
      "sort": [
        {
          "_type": { 
            "order": "desc"
          }
        }
      ],
      "script_fields": {
        "type": {
          "script": {
            "lang": "painless",
            "inline": "doc['_type']" 
          }
        }
      }
    }

    2.9 _uid

    _uid和_type和_index的组合。和_type一样,可用于查询、聚合、脚本和排序。例子如下:

    PUT my_index/my_type/1
    {
      "text": "Document with ID 1"
    }
    
    PUT my_index/my_type/2?refresh=true
    {
      "text": "Document with ID 2"
    }
    
    GET my_index/_search
    {
      "query": {
        "terms": {
          "_uid": [ "my_type#1", "my_type#2" ] 
        }
      },
      "aggs": {
        "UIDs": {
          "terms": {
            "field": "_uid", 
            "size": 10
          }
        }
      },
      "sort": [
        {
          "_uid": { 
            "order": "desc"
          }
        }
      ],
      "script_fields": {
        "UID": {
          "script": {
             "lang": "painless",
             "inline": "doc['_uid']" 
          }
        }
      }
    }

    三、Mapping参数

    3.1 analyzer

    指定分词器(分析器更合理),对索引和查询都有效。如下,指定ik分词的配置:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "content": {
              "type": "text",
              "analyzer": "ik_max_word",
              "search_analyzer": "ik_max_word"
            }
          }
        }
      }
    }

    3.2 normalizer

    normalizer用于解析前的标准化配置,比如把所有的字符转化为小写等。例子:

    PUT index
    {
      "settings": {
        "analysis": {
          "normalizer": {
            "my_normalizer": {
              "type": "custom",
              "char_filter": [],
              "filter": ["lowercase", "asciifolding"]
            }
          }
        }
      },
      "mappings": {
        "type": {
          "properties": {
            "foo": {
              "type": "keyword",
              "normalizer": "my_normalizer"
            }
          }
        }
      }
    }
    
    PUT index/type/1
    {
      "foo": "BÀR"
    }
    
    PUT index/type/2
    {
      "foo": "bar"
    }
    
    PUT index/type/3
    {
      "foo": "baz"
    }
    
    POST index/_refresh
    
    GET index/_search
    {
      "query": {
        "match": {
          "foo": "BAR"
        }
      }
    }

    BÀR经过normalizer过滤以后转换为bar,文档1和文档2会被搜索到。

    3.3 boost

    boost字段用于设置字段的权重,比如,关键字出现在title字段的权重是出现在content字段中权重的2倍,设置mapping如下,其中content字段的默认权重是1.

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "title": {
              "type": "text",
              "boost": 2 
            },
            "content": {
              "type": "text"
            }
          }
        }
      }
    }

    同样,在查询时指定权重也是一样的:

    POST _search
    {
        "query": {
            "match" : {
                "title": {
                    "query": "quick brown fox",
                    "boost": 2
                }
            }
        }
    }

    推荐在查询时指定boost,第一中在mapping中写死,如果不重新索引文档,权重无法修改,使用查询可以实现同样的效果。

    3.4 coerce

    coerce属性用于清除脏数据,coerce的默认值是true。整型数字5有可能会被写成字符串“5”或者浮点数5.0.coerce属性可以用来清除脏数据:

    • 字符串会被强制转换为整数
    • 浮点数被强制转换为整数
    
    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "number_one": {
              "type": "integer"
            },
            "number_two": {
              "type": "integer",
              "coerce": false
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "number_one": "10" 
    }
    
    PUT my_index/my_type/2
    {
      "number_two": "10" 
    }
    

    mapping中指定number_one字段是integer类型,虽然插入的数据类型是String,但依然可以插入成功。number_two字段关闭了coerce,因此插入失败。

    3.5 copy_to

    copy_to属性用于配置自定义的_all字段。换言之,就是多个字段可以合并成一个超级字段。比如,first_name和last_name可以合并为full_name字段。

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "first_name": {
              "type": "text",
              "copy_to": "full_name" 
            },
            "last_name": {
              "type": "text",
              "copy_to": "full_name" 
            },
            "full_name": {
              "type": "text"
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "first_name": "John",
      "last_name": "Smith"
    }
    
    GET my_index/_search
    {
      "query": {
        "match": {
          "full_name": { 
            "query": "John Smith",
            "operator": "and"
          }
        }
      }
    }

    3.6 doc_values

    doc_values是为了加快排序、聚合操作,在建立倒排索引的时候,额外增加一个列式存储映射,是一个空间换时间的做法。默认是开启的,对于确定不需要聚合或者排序的字段可以关闭。

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "status_code": { 
              "type":       "keyword"
            },
            "session_id": { 
              "type":       "keyword",
              "doc_values": false
            }
          }
        }
      }
    }

    注:text类型不支持doc_values。

    3.7 dynamic

    dynamic属性用于检测新发现的字段,有三个取值:

    • true:新发现的字段添加到映射中。(默认)
    • flase:新检测的字段被忽略。必须显式添加新字段。
    • strict:如果检测到新字段,就会引发异常并拒绝文档。

    例子:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "dynamic": false, 
          "properties": {
            "user": { 
              "properties": {
                "name": {
                  "type": "text"
                },
                "social_networks": { 
                  "dynamic": true,
                  "properties": {}
                }
              }
            }
          }
        }
      }
    }

    PS:取值为strict,非布尔值要加引号。

    3.8 enabled

    ELasticseaech默认会索引所有的字段,enabled设为false的字段,es会跳过字段内容,该字段只能从_source中获取,但是不可搜。而且字段可以是任意类型。

    PUT my_index
    {
      "mappings": {
        "session": {
          "properties": {
            "user_id": {
              "type":  "keyword"
            },
            "last_updated": {
              "type": "date"
            },
            "session_data": { 
              "enabled": false
            }
          }
        }
      }
    }
    
    PUT my_index/session/session_1
    {
      "user_id": "kimchy",
      "session_data": { 
        "arbitrary_object": {
          "some_array": [ "foo", "bar", { "baz": 2 } ]
        }
      },
      "last_updated": "2015-12-06T18:20:22"
    }
    
    PUT my_index/session/session_2
    {
      "user_id": "jpountz",
      "session_data": "none", 
      "last_updated": "2015-12-06T18:22:13"
    }

    3.9 fielddata

    搜索要解决的问题是“包含查询关键词的文档有哪些?”,聚合恰恰相反,聚合要解决的问题是“文档包含哪些词项”,大多数字段再索引时生成doc_values,但是text字段不支持doc_values。

    取而代之,text字段在查询时会生成一个fielddata的数据结构,fielddata在字段首次被聚合、排序、或者使用脚本的时候生成。ELasticsearch通过读取磁盘上的倒排记录表重新生成文档词项关系,最后在Java堆内存中排序。

    text字段的fielddata属性默认是关闭的,开启fielddata非常消耗内存。在你开启text字段以前,想清楚为什么要在text类型的字段上做聚合、排序操作。大多数情况下这么做是没有意义的。

    “New York”会被分析成“new”和“york”,在text类型上聚合会分成“new”和“york”2个桶,也许你需要的是一个“New York”。这是可以加一个不分析的keyword字段:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "my_field": { 
              "type": "text",
              "fields": {
                "keyword": { 
                  "type": "keyword"
                }
              }
            }
          }
        }
      }
    }

    上面的mapping中实现了通过my_field字段做全文搜索,my_field.keyword做聚合、排序和使用脚本。

    3.10 format

    format属性主要用于格式化日期:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "date": {
              "type":   "date",
              "format": "yyyy-MM-dd"
            }
          }
        }
      }
    }

    更多内置的日期格式:https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-date-format.html

    3.11 ignore_above

    ignore_above用于指定字段索引和存储的长度最大值,超过最大值的会被忽略:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "message": {
              "type": "keyword",
              "ignore_above": 15
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1 
    {
      "message": "Syntax error"
    }
    
    PUT my_index/my_type/2 
    {
      "message": "Syntax error with some long stacktrace"
    }
    
    GET my_index/_search 
    {
      "size": 0, 
      "aggs": {
        "messages": {
          "terms": {
            "field": "message"
          }
        }
      }
    }

    mapping中指定了ignore_above字段的最大长度为15,第一个文档的字段长小于15,因此索引成功,第二个超过15,因此不索引,返回结果只有”Syntax error”,结果如下:

    {
      "took": 2,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
      },
      "hits": {
        "total": 2,
        "max_score": 0,
        "hits": []
      },
      "aggregations": {
        "messages": {
          "doc_count_error_upper_bound": 0,
          "sum_other_doc_count": 0,
          "buckets": []
        }
      }
    }

    3.12 ignore_malformed

    ignore_malformed可以忽略不规则数据,对于login字段,有人可能填写的是date类型,也有人填写的是邮件格式。给一个字段索引不合适的数据类型发生异常,导致整个文档索引失败。如果ignore_malformed参数设为true,异常会被忽略,出异常的字段不会被索引,其它字段正常索引。

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "number_one": {
              "type": "integer",
              "ignore_malformed": true
            },
            "number_two": {
              "type": "integer"
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "text":       "Some text value",
      "number_one": "foo" 
    }
    
    PUT my_index/my_type/2
    {
      "text":       "Some text value",
      "number_two": "foo" 
    }

    上面的例子中number_one接受integer类型,ignore_malformed属性设为true,因此文档一种number_one字段虽然是字符串但依然能写入成功;number_two接受integer类型,默认ignore_malformed属性为false,因此写入失败。

    3.13 include_in_all

    include_in_all属性用于指定字段是否包含在_all字段里面,默认开启,除索引时index属性为no。 
    例子如下,title和content字段包含在_all字段里,date不包含。

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "title": { 
              "type": "text"
            },
            "content": { 
              "type": "text"
            },
            "date": { 
              "type": "date",
              "include_in_all": false
            }
          }
        }
      }
    }

    include_in_all也可用于字段级别,如下my_type下的所有字段都排除在_all字段之外,author.first_name 和author.last_name 包含在in _all中:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "include_in_all": false, 
          "properties": {
            "title":          { "type": "text" },
            "author": {
              "include_in_all": true, 
              "properties": {
                "first_name": { "type": "text" },
                "last_name":  { "type": "text" }
              }
            },
            "editor": {
              "properties": {
                "first_name": { "type": "text" }, 
                "last_name":  { "type": "text", "include_in_all": true } 
              }
            }
          }
        }
      }
    }

    3.14 index

    index属性指定字段是否索引,不索引也就不可搜索,取值可以为true或者false。

    3.15 index_options

    index_options控制索引时存储哪些信息到倒排索引中,接受以下配置:

    参数作用
    docs只存储文档编号
    freqs存储文档编号和词项频率
    positions文档编号、词项频率、词项的位置被存储,偏移位置可用于临近搜索和短语查询
    offsets文档编号、词项频率、词项的位置、词项开始和结束的字符位置都被存储,offsets设为true会使用Postings highlighter

    3.16 fields

    fields可以让同一文本有多种不同的索引方式,比如一个String类型的字段,可以使用text类型做全文检索,使用keyword类型做聚合和排序。

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "city": {
              "type": "text",
              "fields": {
                "raw": { 
                  "type":  "keyword"
                }
              }
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "city": "New York"
    }
    
    PUT my_index/my_type/2
    {
      "city": "York"
    }
    
    GET my_index/_search
    {
      "query": {
        "match": {
          "city": "york" 
        }
      },
      "sort": {
        "city.raw": "asc" 
      },
      "aggs": {
        "Cities": {
          "terms": {
            "field": "city.raw" 
          }
        }
      }
    }

    3.17 norms

    norms参数用于标准化文档,以便查询时计算文档的相关性。norms虽然对评分有用,但是会消耗较多的磁盘空间,如果不需要对某个字段进行评分,最好不要开启norms。

    3.18 null_value

    值为null的字段不索引也不可以搜索,null_value参数可以让值为null的字段显式的可索引、可搜索。例子:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "status_code": {
              "type":       "keyword",
              "null_value": "NULL" 
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "status_code": null
    }
    
    PUT my_index/my_type/2
    {
      "status_code": [] 
    }
    
    GET my_index/_search
    {
      "query": {
        "term": {
          "status_code": "NULL" 
        }
      }
    }

    文档1可以被搜索到,因为status_code的值为null,文档2不可以被搜索到,因为status_code为空数组,但是不是null。

    3.19 position_increment_gap

    为了支持近似或者短语查询,text字段被解析的时候会考虑此项的位置信息。举例,一个字段的值为数组类型:

     "names": [ "John Abraham", "Lincoln Smith"]

    为了区别第一个字段和第二个字段,Abraham和Lincoln在索引中有一个间距,默认是100。例子如下,这是查询”Abraham Lincoln”是查不到的:

    PUT my_index/groups/1
    {
        "names": [ "John Abraham", "Lincoln Smith"]
    }
    
    GET my_index/groups/_search
    {
        "query": {
            "match_phrase": {
                "names": {
                    "query": "Abraham Lincoln" 
                }
            }
        }
    }

    指定间距大于100可以查询到:

    GET my_index/groups/_search
    {
        "query": {
            "match_phrase": {
                "names": {
                    "query": "Abraham Lincoln",
                    "slop": 101 
                }
            }
        }
    }

    在mapping中通过position_increment_gap参数指定间距:

    PUT my_index
    {
      "mappings": {
        "groups": {
          "properties": {
            "names": {
              "type": "text",
              "position_increment_gap": 0 
            }
          }
        }
      }
    }

    3.20 properties

    Object或者nested类型,下面还有嵌套类型,可以通过properties参数指定。

    PUT my_index
    {
      "mappings": {
        "my_type": { 
          "properties": {
            "manager": { 
              "properties": {
                "age":  { "type": "integer" },
                "name": { "type": "text"  }
              }
            },
            "employees": { 
              "type": "nested",
              "properties": {
                "age":  { "type": "integer" },
                "name": { "type": "text"  }
              }
            }
          }
        }
      }
    }

    对应的文档结构:

    PUT my_index/my_type/1 
    {
      "region": "US",
      "manager": {
        "name": "Alice White",
        "age": 30
      },
      "employees": [
        {
          "name": "John Smith",
          "age": 34
        },
        {
          "name": "Peter Brown",
          "age": 26
        }
      ]
    }
    

    可以对manager.name、manager.age做搜索、聚合等操作。

    GET my_index/_search
    {
      "query": {
        "match": {
          "manager.name": "Alice White" 
        }
      },
      "aggs": {
        "Employees": {
          "nested": {
            "path": "employees"
          },
          "aggs": {
            "Employee Ages": {
              "histogram": {
                "field": "employees.age", 
                "interval": 5
              }
            }
          }
        }
      }
    }

    3.21 search_analyzer

    大多数情况下索引和搜索的时候应该指定相同的分析器,确保query解析以后和索引中的词项一致。但是有时候也需要指定不同的分析器,例如使用edge_ngram过滤器实现自动补全。

    默认情况下查询会使用analyzer属性指定的分析器,但也可以被search_analyzer覆盖。例子:

    PUT my_index
    {
      "settings": {
        "analysis": {
          "filter": {
            "autocomplete_filter": {
              "type": "edge_ngram",
              "min_gram": 1,
              "max_gram": 20
            }
          },
          "analyzer": {
            "autocomplete": { 
              "type": "custom",
              "tokenizer": "standard",
              "filter": [
                "lowercase",
                "autocomplete_filter"
              ]
            }
          }
        }
      },
      "mappings": {
        "my_type": {
          "properties": {
            "text": {
              "type": "text",
              "analyzer": "autocomplete", 
              "search_analyzer": "standard" 
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "text": "Quick Brown Fox" 
    }
    
    GET my_index/_search
    {
      "query": {
        "match": {
          "text": {
            "query": "Quick Br", 
            "operator": "and"
          }
        }
      }
    }

    3.22 similarity

    similarity参数用于指定文档评分模型,参数有三个:

    • BM25 :ES和Lucene默认的评分模型
    • classic :TF/IDF评分
    • boolean:布尔模型评分 
      例子:
    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "default_field": { 
              "type": "text"
            },
            "classic_field": {
              "type": "text",
              "similarity": "classic" 
            },
            "boolean_sim_field": {
              "type": "text",
              "similarity": "boolean" 
            }
          }
        }
      }
    }

    default_field自动使用BM25评分模型,classic_field使用TF/IDF经典评分模型,boolean_sim_field使用布尔评分模型。

    3.23 store

    默认情况下,自动是被索引的也可以搜索,但是不存储,这也没关系,因为_source字段里面保存了一份原始文档。在某些情况下,store参数有意义,比如一个文档里面有title、date和超大的content字段,如果只想获取title和date,可以这样:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "title": {
              "type": "text",
              "store": true 
            },
            "date": {
              "type": "date",
              "store": true 
            },
            "content": {
              "type": "text"
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "title":   "Some short title",
      "date":    "2015-01-01",
      "content": "A very long content field..."
    }
    
    GET my_index/_search
    {
      "stored_fields": [ "title", "date" ] 
    }

    查询结果:

    {
      "took": 1,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "failed": 0
      },
      "hits": {
        "total": 1,
        "max_score": 1,
        "hits": [
          {
            "_index": "my_index",
            "_type": "my_type",
            "_id": "1",
            "_score": 1,
            "fields": {
              "date": [
                "2015-01-01T00:00:00.000Z"
              ],
              "title": [
                "Some short title"
              ]
            }
          }
        ]
      }
    }

    Stored fields返回的总是数组,如果想返回原始字段,还是要从_source中取。

    3.24 term_vector

    词向量包含了文本被解析以后的以下信息:

    • 词项集合
    • 词项位置
    • 词项的起始字符映射到原始文档中的位置。

    term_vector参数有以下取值:

    参数取值含义
    no默认值,不存储词向量
    yes只存储词项集合
    with_positions存储词项和词项位置
    with_offsets词项和字符偏移位置
    with_positions_offsets存储词项、词项位置、字符偏移位置

    例子:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "properties": {
            "text": {
              "type":        "text",
              "term_vector": "with_positions_offsets"
            }
          }
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "text": "Quick brown fox"
    }
    
    GET my_index/_search
    {
      "query": {
        "match": {
          "text": "brown fox"
        }
      },
      "highlight": {
        "fields": {
          "text": {} 
        }
      }
    }

    四、动态Mapping

    4.1 default mapping

    在mapping中使用default字段,那么其它字段会自动继承default中的设置。

    PUT my_index
    {
      "mappings": {
        "_default_": { 
          "_all": {
            "enabled": false
          }
        },
        "user": {}, 
        "blogpost": { 
          "_all": {
            "enabled": true
          }
        }
      }
    }

    上面的mapping中,default中关闭了all字段,user会继承_default中的配置,因此user中的all字段也是关闭的,blogpost中开启_all,覆盖了_default的默认配置。

    default被更新以后,只会对后面新加的文档产生作用。

    4.2 Dynamic field mapping

    文档中有一个之前没有出现过的字段被添加到ELasticsearch之后,文档的type mapping中会自动添加一个新的字段。这个可以通过dynamic属性去控制,dynamic属性为false会忽略新增的字段、dynamic属性为strict会抛出异常。如果dynamic为true的话,ELasticsearch会自动根据字段的值推测出来类型进而确定mapping:

    JSON格式的数据自动推测的字段类型
    null没有字段被添加
    true or falseboolean类型
    floating类型数字floating类型
    integerlong类型
    JSON对象object类型
    数组由数组中第一个非空值决定
    string有可能是date类型(开启日期检测)、double或long类型、text类型、keyword类型

    日期检测默认是检测符合以下日期格式的字符串:

    [ "strict_date_optional_time","yyyy/MM/dd HH:mm:ss Z||yyyy/MM/dd Z"]

    例子:

    PUT my_index/my_type/1
    {
      "create_date": "2015/09/02"
    }
    
    GET my_index/_mapping

    mapping 如下,可以看到create_date为date类型:

    {
      "my_index": {
        "mappings": {
          "my_type": {
            "properties": {
              "create_date": {
                "type": "date",
                "format": "yyyy/MM/dd HH:mm:ss||yyyy/MM/dd||epoch_millis"
              }
            }
          }
        }
      }
    }

    关闭日期检测:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "date_detection": false
        }
      }
    }
    
    PUT my_index/my_type/1 
    {
      "create": "2015/09/02"
    }

    再次查看mapping,create字段已不再是date类型:

    GET my_index/_mapping
    返回结果:
    {
      "my_index": {
        "mappings": {
          "my_type": {
            "date_detection": false,
            "properties": {
              "create": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              }
            }
          }
        }
      }
    }

    自定义日期检测的格式:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "dynamic_date_formats": ["MM/dd/yyyy"]
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "create_date": "09/25/2015"
    }

    开启数字类型自动检测:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "numeric_detection": true
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "my_float":   "1.0", 
      "my_integer": "1" 
    }

    4.3 Dynamic templates

    动态模板可以根据字段名称设置mapping,如下对于string类型的字段,设置mapping为:

      "mapping": { "type": "long"}

    但是匹配字段名称为long_*格式的,不匹配*_text格式的:

    PUT my_index
    {
      "mappings": {
        "my_type": {
          "dynamic_templates": [
            {
              "longs_as_strings": {
                "match_mapping_type": "string",
                "match":   "long_*",
                "unmatch": "*_text",
                "mapping": {
                  "type": "long"
                }
              }
            }
          ]
        }
      }
    }
    
    PUT my_index/my_type/1
    {
      "long_num": "5", 
      "long_text": "foo" 
    }

    写入文档以后,long_num字段为long类型,long_text扔为string类型。

    4.4 Override default template

    可以通过default字段覆盖所有索引的mapping配置,例子:

    PUT _template/disable_all_field
    {
      "order": 0,
      "template": "*", 
      "mappings": {
        "_default_": { 
          "_all": { 
            "enabled": false
          }
        }
      }
    }
    展开全文
  • ORACLE数据库字段类型说明

    千次阅读 2018-04-03 17:08:36
    ORACLE数据库字段类型说明 目前Oracle 数据库大概有26个字段类型,大体分为六类,分别是字符串类型、数字数据类型、日期时间数据类型、大型对象(LOB)数据类型、RAW和LONG RAW数据类型、ROWID和UROWID数据...
    
    ORACLE数据库字段类型说明

    目前Oracle 数据库大概有26个字段类型,大体分为六类,分别是字符串类型、数字数据类型、日期时间数据类型、
    大型对象(LOB)数据类型、RAW和LONG RAW数据类型、ROWID和UROWID数据类型。
    当然Oracle还提供用户自定义的数据类型,但在我这篇不做讨论。
    ===============
    字符串类型
    ===============
    Char
    char数据类型存储固定长度的字符值。一个CHAR数据类型可以包括1到2000个字符。如果对CHAR没有明确地说明长度,
    它的默认长度则设置为1。 如果对某个CHAR类型变量赋值,其长度小于规定的长度,那么Oracle自动用空格填充。
    注意:如果给了一个比固定长度更长的值,其尾部带有空格,则空格会被删除到固定的长度。如果值太大Oracle会返回一个错误,

    Varchar
    用于保存变长的字符串数据。其中最大字节长度由(size)指定。每行长度可变,最大长度为每行4000字节。
    设置长度(size)前需考虑字符集为单字节或多字节。
    注意:varchar是被废弃的类型,oracle目前都推荐使用varchar2。虽然varchar也可以用,但不确保未来的版本是否还支持

    Varchar2
    用于保存变长的字符串数据。其中最大字节长度由(size)指定。每行长度可变,最大长度为每行4000字节。
    设置长度(size)前需考虑字符集为单字节或多字节。由于VARCHAR2数据类型只存储为该列所赋的字符(不加空格),
    所以VARCHAR2需要的存储空间比CHAR数据类型要小。
    区别:varchar2把所有字符都占两字节处理(一般情况下),
    varchar只对汉字和全角等字符占两字节,数字,英文字符等都是一个字节;
    VARCHAR2把空串等同于null处理,而varchar仍按照空串处理;大部分情况下建议使用varchar2类型,可以保证更好的兼容性。

    Nchar
    Unicode数据类型,根据字符集而定的固定长度字符串,最大长度2000bytes。

    Nvarchar2
    Unicode数据类型,根据字符集而定的可变长度字符串,最大长度4000bytes。

    Long
    可变长字符列,最大长度限制为2GB,用于不需要作字符串搜索的长串数据。
    说明:此类型是一个遗留下来的而且将来不会被支持的数据类型,逐渐被BLOB,CLOB,NCLOB等大的数据类型所取代。

    =============== 
    数字类型
    =============== 
    Number
    NUMBER数据类型精度可以高达38位,它有两个限定符,如:column NUMBER(precision,scale)。precision表示数字中的有效位。
    如果没有指定precision的话,Oracle将使用38 作为精度。scale表示小数点右边的位数,scale默认设置为0。
    如果把scale设成负数,Oracle将把该数字取舍到小数点左边的指定位数。

    Decimal
    Oracle只是在语法上支持decimal类型,但是在底层实际上它就是number类型,
    支持decimal类型是为了能把数据从Oracle数据库移到其他数据库中。

    Float
    FLOAT类型也是NUMBER的子类型。其格式Float(n),数 n 指示位的精度,可以存储的值的数目。N 值的范围可以从 1 到 126。
    若要从二进制转换为十进制的精度,请将n 乘以 0.30103。要从十进制转换为二进制的精度,请用 3.32193 乘小数精度。
    126 位二进制精度的最大值是大约相当于 38 位小数精度。

    BINARY_FLOAT
    BINARY_FLOAT 是一种 32 位,单精度浮点数字数据类型。每个 BINARY_FLOAT 值需要5 字节存储空间,
    其中 1 字节用于存储数据值的长度。支持 NUMBER 数据类型所提供的基本功能。但采用二进制精度,而NUMBER 采用十进制精度。
    因此能够提供更快的数学运算速度,且能减少占用的存储空间。

    BINARY_DOUBLE
    BINARY_DOUBLE 是一种 64 位,双精度浮点数字数据类型。每个 BINARY_DOUBLE 值需要9 字节存储空间,
    其中 1 字节用于存储数据值的长度。支持 NUMBER 数据类型所提供的基本功能。但采用二进制精度,而NUMBER 采用十进制精度。
    因此能够提供更快的数学运算速度,且能减少占用的存储空间。

    =============== 
    日期数据类型
    =============== 
    Date
    ORACLE最常用的日期类型,它可以保存日期和时间,常用日期处理都可以采用这种类型。
    DATE表示的日期范围可以是公元前4712年1月1日至公元9999年12月31日。
    date类型在数据库中的存储固定为7个字节, 第1字节:世纪+100、 第2字节:年、第3字节:月、第4字节:天、
    第5字节:小时+1、第6字节:分+1、第7字节:秒+1。

    Timestamp
    ORACLE常用的日期类型,它与date的区别是不仅可以保存日期和时间,还能保存小数秒,小数位数可以指定为0-9,默认为6位,
    所以最高精度 可以到ns(纳秒),数据库内部用7或者11个字节存储,如果精度为0,则用7字节存储,与date类型功能相同,
    如果精度大于0则用11字节存储。第1字节:世纪+100、第2字节:年、第3字节:月、第4字节:天、 第5字节:小时+1、第6字节:分+1、
    第7字节:秒+1、 第8-11字节:纳秒,采用4个字节存储,内部运算类型为整形
    注:TIMESTAMP日期类型如果与数值进行加减运算会自动转换为DATE型,也就是说小数秒会自动去除。

    TIMESTAMP WITH TIME ZONE
    对TIMESTAMP进行了扩展,用于存储时区。时间戳以及时区位移值,其中fractional_seconds_precision是数字在第二日期时间字段的
    小数部分数字的所有值。可接受的值是0到9。默认是6。默认格式是确定明确的NLS_DATE_FORMAT参数或隐式的NLS_TERRITORY参数。
    大小固定为13字节。此数据类型包含日期时间字段YEAR,MONTH,日,小时,分钟,秒TIMEZONE_HOUR和TIMEZONE_MINUTE。
    它有一个明确的分数秒和时区。

    TIMESTAMP WITH LOCAL TIME ZONE
    所有的TIMESTAMP WITH TIME ZONE值,但下列情况除外:数据标准化数据库的时区时,存储在数据库中。当数据被检索,
    用户可以看到在会话时区中的数据。默认格式是确定明确的NLS_DATE_FORMAT参数或隐式的NLS_TERRITORY参数。
    的大小不同的7至11个字节,取决于精度。

    INTERVAL YEAR TO MONTH
    存储期间年数和月的时间,其中year_precision是数字的年份日期时间字段的数量。可接受的值是0到9。默认是2。大小固定为5个字节。

    INTERVAL DAY TO SECOND
    其格式为:INTERVAL DAY [(day_precision)] TO SECOND [(fractional_seconds)],是存储一段时间以天,小时,分钟和秒,
    其中day_precision是数字在DAY日期时间字段的最大数量。可接受的值是0到9。默认是2。fractional_seconds_precision是数字中的
    第二个字段的小数部分的数量。可接受的值是0到9。默认是6。大小固定为11个字节。

    INTERVAL YEAR TO MONTH
    Oracle语法:INTERVAL YEAR [(year_precision )] TO MONTH,用来表示一段时间差,
    只精确到年和月. year_precision是数字年的时间段,接受的值为0到9。默认值是2。大小固定为5个字节。

    =============== 
    大型对象(LOB)数据类型
    =============== 
    Clob
    最大4G,存储单字节字符型数据。适用于存储超长文本。

    Nclob
    最大4G,存储多字节国家字符型数据。适用于存储超长文本。

    Blob
    最大4G,存储二进制数据。适用于存储图像、视频、音频等。

    BFile
    最大长度是4GB,在数据库外部保存的大型二进制对象文件,最大长度是4GB。这种外部的LOB类型,通过数据库记录变化情况,
    但是数据的具体保存是在数据库外部进行的。 Oracle 可以读取、查询BFILE,但是不能写入,不参与事务。

    =============== 
    RAW和LONG RAW数据类型
    =============== 
    RAW
    raw(n)格式,其中n=1 to 2000,可变长二进制数据,在具体定义字段的时候必须指明最大长度n,
    Oracle 用这种格式来保存较小的图形文件或带格式的文本文件,如Miceosoft Word文档。raw是一种较老的数据类型,
    将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。

    LONG RAW
    最大长度是2GB。可变长二进制数据,最大长度是2GB。Oracle 用这种格式来保存较大的图形文件或带格式的文本文件,
    如Miceosoft Word文档,以及音频、视频等非文本文件。在同一张表中不能同时有long类型和long raw类型,
    long raw也是一种较老的数据类型,将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。

    =============== 
    ROWID和UROWID数据类型
    =============== 
    Rowid
    ROWID为该表行的唯一标识,是一个伪列,可以用在SELECT中,但不可以用INSERT, UPDATE来修改该值。
    ROWID列,Oracle使用ROWID列来建立内部索引。你可以引用ROWID的值,但ROWID并不存放在数据库中,
    你可以创建一个表包含ROWID数据类型。但Oracle不保证该值是合法的rowids。用户必须确保该rowid值是真实合法的。

    Urowid
    UROWID支持逻辑和物理的rowids,列UROWID类型可以存储各种rowids, 从8.1以后的Oracle才有UROWID类型,
    它也可以用来保存以前的ROWID类型数据信息。

    =============== 
    特殊数据类型
    =============== 
    Xmltype
    XMLType是Oracle从9i开始特有的数据类型,是一个继承了Blob的强大存在,可以用来存储xml并提供了相当多的操作函数,
    用来直接读取xml文档和管理节点。理论上可以保存2G大小的数据。作为XML数据的特殊存储类型。
    Xmltype提供了适合的保存、检索和操作的支持。

    Xmlindex
    XMLIndex 索引可用于 SQL/XML 函数 XMLExists()、XMLTable() 和 XMLQuery(),而且它在查询的任何部分都有效;
    它并不限于用在 WHERE 子句中。而您可能用于 XML 数据的其他任何索引都无法做到这一点。
    XMLIndex 因此可提高对 SELECT 列表数据和 FROM 列表数据的访问速度,对 XML 片段提取尤为有用。基于函数的索引和 CTXXPath 索引。
    您无需预先了解将在查询中使用的XPath 表达式。XMLIndex 完全是通用的,而基于函数的索引则不同。可将 XMLIndex 索引用于基于 XML
    模式或非基于模式的数据。它可用于二进制 XML 和非结构化存储模型。B 树索引仅适用于以对象关系方式存储(结构化存储)的基于模式的
    数据;它对于存储在二进制XML 或CLOB 实例中的基于 XML 模式的数据效率低下。可使用 XMLIndex 索引通过 XPath 表达式进行搜索,
    这些表达式的目标是集合(即文档中出现多次的节点)。而函数索引则不然。

    展开全文
  • Elasticsearch6.x字段类型

    千次阅读 2018-09-28 15:56:59
    12.1 字段类型概述 一级分类 二级分类 具体类型 核心类型 字符串类型 string,text,keyword 整数类型 integer,long,short,byte 浮点类型 double,float,half_float,scaled_float 逻辑类型 ...
  • mysql字段类型优化

    千次阅读 2016-09-20 17:08:32
    ①存储人的年龄应该使用哪种数据类型?答:使用tinyint类型(无符号型) ②存储乌龟的年龄应该使用哪种数据类型?答:使用smallinit类型(无符号型) ③存储一个1500万数据的数据表其主键id应该选择哪种数据类型?...
  • ElasticSearch 6.x 学习笔记:12.字段类型

    万次阅读 多人点赞 2018-01-12 23:03:45
    12.1 字段类型概述 一级分类 二级分类 具体类型 核心类型 字符串类型 string,text,keyword 整数类型 integer,long,short,byte 浮点类型 double,float,half_float,scaled_floa
  • ES7-字段类型

    千次阅读 2018-07-02 21:35:00
    1.ElasticSearch中字段类型 2.字符串类型 string string类型在ElasticSearch 旧版本中使用较多,从ElasticSearch 5.x开始不再支持string,由text和keyword类型替代。 text 当一个字段是要被...
  • ES常用的数据类型可分为3大类 核⼼数据类型 复杂数据类型 专⽤数据类型 核心数据类型 (1)字符串 text ⽤于全⽂索引,搜索时会自动使用分词器进⾏分词再匹配 keyword 不分词,搜索时需要匹配完整的值 (2)...
  • 数据库之字段数据类型

    千次阅读 热门讨论 2017-08-08 10:53:54
    字段的数据类型 1.整数数据类型: bigint:整数值超过int数据范围时才可以使用 int:是将一个数值向下取整为最接近的整数的函数 smallint:需要 2 个字节存储的整数。 TINYINT : TINYINT 型的字段如果设置为...
  • 文章目录字段类型1、字段类型作用2、整数类型3、显示宽度4、小数类型(浮点型)5、小数类型(定点型)6、字符串类型(定长型)7、字符串类型(变长型)8、字符串类型(文本字符串)9、字符串类型(枚举)10、字符串...
  • mysql 字段类型有哪些

    千次阅读 2017-05-24 13:52:56
    对于字段类型不是很了解,转载过来 学习一下,原文地址:http://www.cnblogs.com/lijiageng/p/5661357.html int型包括(tinyint, smallint, mediumint, int, bigint)  tinyint是1个字节表达范围就是2...
  • 类型和成员基础在C#中,一个类型内部可以定义多种成员:常量、字段、实例构造器、类型构造器(静态构造器)、方法、操作符重载、转换操作符、属性、事件、类型类型的可见性有public和internal(默认)两种,前者...
  • 问题 某天,在处理数据时,发现Spark sql (版本:Spark-1.6.3 )在进行 join 时,...A 表中的 BigInt 类型和 B表中的 String 类型关联,关联出来的结果重复了,不是我们想要的结果。 表一:t_test_bigint creat...
  • 1.1数据类型 1)字符类型 2)数值数据类型 3)日期时间数据类型 4)LOB数据类型 1.2创建数据表 1).直接设计表 2)利用现有的表或者视图建立新表(create table语句嵌套子查询) 1.3数据表的特性 1)存储参数 2)...
  • 最近在统计用户年龄,并且需要分组来计数: SELECT IFNULL(count(id),0)num1 from fweb_auth_user_info where TIMESTAMPDIFF(YEAR,birthday,now()) < 18 UNION All SELECT IFNULL(count(id),0)num2 from fweb_...
  • 一,修改字段默认值 alter table表名drop constraint约束名字; ------说明:删除表的字段的原有约束 alter table表名add constraint约束名字DEFAULT默认值为字段名称;...三,修改字段类型: alter tabl...
  • 什么鬼???怎么多了个.0 问题应该是导Data包的时候导的是uitl的包,换成sql的就不会这样   如果不想换怎么办呢 那就在前端用日期格式化标签把取出来的数据格式化成你想要的,如下 引入标签: &lt;%@ ...
  • PLSQL 定义含有多个字段的数组类型变量 首先我们来看一下怎样在PLSQL中定义一个只含有一个字段的数组: 在这里我们创建一个用户姓名数组 -- PLSQL 定义含有单个字段的数组类型变量 DECLARE TYPE user_name_type IS...
  • 当前用户人生阶段表LifeStage,有用户唯一ID字段,UID,用户人生阶段stage,其 中stage字段为各个人生阶段标签英文逗号分隔拼接内容,如:已买房,计划买车,并且每 个用户的内容不同,请使用Hive SQL 统计每个人生阶段的用户...
  • 我通过js向后台发送请求,查询数据库中的字段。其中有一个字段是date时间类型的, 查询结果在jsp页面中显示的不是时间而是Object。 ![图片说明](https://img-ask.csdn.net/upload/201509/24/1443075048_555.png)
  • 连续型字段,离散型字段例如:为什么年龄是连续型字段? 例如:为什么年龄是连续型字段? 我们举个例子,为什么年龄是连续型而不是离散型?区分这两者的关键点在于有穷性,离散型的字段是可以列举出所有情况的,如在...
  • 对于字符串类型的数据字段,大多数情况下,django使用空字符串代表空值 blank 如果该值为True,则在验证时该字段值可以为空; null为数据库存储层面可以为空,而blank为表单验证层面可以填写空值 ...
  • System.out.println("字段:"+f.getName()+" 类型为:"+f.getType().getName()+" 值为:"+ f.get(obj)); } } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalAccessException e) ...
  • Presto查询hive字段为json类型的方法

    千次阅读 2019-08-29 18:16:46
    -- employee表的xjson字段,只有一条数据 [{"name":"王二","sex":"男","age":"25"},{"name":"李四","sex":"男","age":"47"}] select get_json_object(xjson,'$.[0].age') from employee limit 1; ...
  • 日期字段格式都是一样的2015-05-05。其类型是varchar2(20),想要根据某一个月份来进行查询,不知道怎么写sql语句。。 我试了什么to_char(to_date(date,'yyyy-mm-dd hh24:mi:ss'),'yyyymm')=201505;总也不行,不是...
  • 不同类型不同字段如何实现深拷贝(可配置) 突发奇想,如果给我两个实体 A 与 B 他们的字段是这样的,实现将A对象的值赋值给B对象 public class A { public string Name { set; get; } public int Age { set; ...
  • 建立一个学生类,包括私有字段:学号、姓名、班级、年龄,包括公共属性:学号、姓名、班级、年龄 实例化4个学生对象,并存储到学生类型数组中 用户输入要查询的学号,搜索数组中是否有相应学生,如果有,在屏幕输出...
  • 遇到的问题:element UI form 表单中number 类型字段校验时,不能准备的进行校验 查看了一下element UI版本,发现v2.4版本以前的均有bug 解决办法:更新element UI 版本到v2.4以上,并且加上number 类型 <...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,548
精华内容 32,219
关键字:

年龄的字段类型是什么