精华内容
下载资源
问答
  • fnd_lookup_values表示干什么的

    千次阅读 2012-05-07 14:43:07
    fnd_lookup_values表示干什么的? 1系统给提供的记录一些值的地方,可以用来设计LOV用 2是不是通过lookup_type来... LOOKUP_CODE指的是这个类别下的值 1相当于映射表 hash_map的表实現     1.
    fnd_lookup_values表示干什么的?

    1系统给提供的记录一些值的地方,可以用来设计LOV用

    2是不是通过lookup_type来区别记录的种类

    1对,在系统设置完后,就可以用了:
          lookup_type 是你定义的名字
           LOOKUP_CODE指的是这个类别下的值

    1相当于映射表

    hash_map的表实現
     
     

    1.现状:oracle 通常对一些字段的描述放在table:FND_LOOKUP_VALUES中,当我们知道描述字段栏位值时候,可以通过值进行查询。
    2. table:FND_LOOKUP_VALUES,FND_LOOKUP_TYPES,  view: MFG_LOOKUPS

    3.举例说明:
    A.对物料表MTL_SYSTEM_ITEMS_B中对制造件或购买件关联,对应后台字段为 1,2
    B.执行sql
    SELECT * FROM FND_LOOKUP_VALUES FLV WHERE (FLV.MEANING LIKE '制造' or FLV.MEANING LIKE '购买') order by 1;
    C.根据LOOKUP_TYPE有两行重复及LOOKUP_CODE值为1,2,
    可以推断出:只有两个LOOKUP_TYPE可能是MTL_ITEM_ORIGINATION2,MTL_PLANNING_MAKE_BUY
    D.分别一下执行sql,大致可以推出为MTL_PLANNING_MAKE_BUY,就是所要的;
    SELECT * FROM FND_LOOKUP_VALUES FLV WHERE FLV.LOOKUP_TYPE='MTL_ITEM_ORIGINATION2';

    SELECT * FROM FND_LOOKUP_VALUES FLV WHERE FLV.LOOKUP_TYPE='MTL_PLANNING_MAKE_BUY';
    E.客户化开发尽量用快速编码的方式定义,以便后期维护更容易,当然可以放置各个模块下,
    但是可能受权限限制使开发人员找不到。
    路径为:Application Developer-->Application-->Lookups-->Common

     
    展开全文
  • 这个通知指的是什么

    2010-11-01 00:46:12
    VALUES('$name','$username', '$password')"; mysql_query($query) or die(mysql_error()); mysql_close(); echo "You have successfully registered"; ?> </body> </html> </code></pre> </div>
  • 但是这里speed是什么速率呢?找了半天也没找到合适答案 3.一块网卡,用psutil.net_io_counters(pernic=true)返回来一个字典类型有三个值,解释如下,但是没看明白什么是every network interface installed on...
  • //****************下面这个要求的是最大公约数 /*for(i=0;i;i++) { for(j=i;j;j++) { if(array[i]==array1[j]) { sum=sum*array[i];break; } } } //**************这个是最大公约数的...
  • I mean we know the exact size of the int and it wont vary (perhaps this is important since some hashing libraries use <code>intptr_t</code> or <code>size_t</code> for their hashing return values ...
  • Cardinality指什么

    2008-04-25 22:56:18
    在性能优化向导中经常会出现Cardinality,Cardinality到底是指什么,看看doc准确解释:Cardinality is the number of unique values in a column in re...

    在性能优化向导中经常会出现Cardinality,Cardinality到底是指什么,看看doc的准确解释:

    Cardinality is the number of unique values in a column in relation to the number of rows in the table

    [@more@]

    CREATE_BITMAP_AREA_SIZE

    PropertyDescription
    Parameter typeInteger
    Default value8388608 (8 MB)
    ModifiableNo
    Range of valuesOperating system-dependent
    BasicNo

    Note:

    Oracle does not recommend using the CREATE_BITMAP_AREA_SIZE parameter unless the instance is configured with the shared server option. Oracle recommends that you enable automatic sizing of SQL working areas by setting PGA_AGGREGATE_TARGET instead. CREATE_BITMAP_AREA_SIZE is retained for backward compatibility.

    CREATE_BITMAP_AREA_SIZE is relevant only for systems containing bitmap indexes. It specifies the amount of memory (in bytes) allocated for bitmap creation. The default value is 8 MB. A larger value may speed up index creation.

    Cardinality is the number of unique values in a column in relation to the number of rows in the table. If cardinality is very small, you can set a small value for this parameter. For example, if cardinality is only 2, then the value can be on the order of kilobytes rather than megabytes. As a general rule, the higher the cardinality, the more memory is needed for optimal performance.

    来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/19602/viewspace-1002989/,如需转载,请注明出处,否则将追究法律责任。

    转载于:http://blog.itpub.net/19602/viewspace-1002989/

    展开全文
  • 这个几个概念分别指的是什么?有什么用处?如何配置它们?只有我们熟练地掌握了这些概念,我们才可以正确地使用它们。 Inverted index inverted index(反向索引)是Elasticsearch和任何其他支持全文搜索的...

    当我们学习 Elasticsearch 时,经常会遇到如下的几个概念:

    • Reverted index
    • doc_values
    • source?

    这个几个概念分别指的是什么?有什么用处?如何配置它们?只有我们熟练地掌握了这些概念,我们才可以正确地使用它们。

     

    Inverted index

    Inverted index(反向索引)是 Elasticsearch 和任何其他支持全文搜索的系统的核心数据结构。当一段文字从最原始的文字导入到 Elasticsearch 中,需要经过一个叫做 indexing 的过程。如果大家需要对 analyzer 有更深的认识,可以参阅我之前的文章 “Elasticsearch: analyzer”。

    反向索引类似于你在任何书籍结尾处看到的索引。 它将出现在文档中的术语映射到文档。

    例如,你可以从以下字符串构建反向索引:

    Elasticsearch 从已建立索引的三个文档中构建数据结构。 以下数据结构称为反向索引 (inverted index)

    Term Frequency Document (postings)
    choice 1 3
    day 1 2
    is 3 1,2,3
    it 1 1
    last 1 2
    of 1 2
    of 1 2
    sunday 2 1,2
    the 3 2,3
    tomorrow 1 1
    week 1 2
    yours 1 3

    在这里反向索引指的的是,我们根据 term 来寻找相应的文档 ids。这和常规的根据文档 id 来 寻找 term 相反。

    请注意以下几点:

    • 删除标点符号并将其小写后,文档会按术语进行细分。
    • 术语按字母顺序排序
    • “Frequency” 列捕获该术语在整个文档集中出现的次数

    • 第三列捕获了在其中找到该术语的文档。 此外,它还可能包含找到该术语的确切位置(文档中的偏移)

    在文档中搜索术语时,查找给定术语出现在其中的文档非常快捷。 如果用户搜索术语 “sunday”,那么从 “Term” 列中查找 sunday 将非常快,因为这些术语在索引中进行了排序。 即使有数百万个术语,也可以在对术语进行排序时快速查找它们。

    随后,考虑一种情况,其中用户搜索两个单词,例如 last sunday。 反向索引可用于分别搜索 last 和 sunday 的发生; 文档2包含这两个术语,因此比仅包含一个术语的文档1更好。

    反向索引是执行快速搜索的基础。 同样,很容易查明索引中出现了多少次术语。 这是一个简单的计数汇总。 当然,Elasticsearch在我们在这里解释的简单的反向排索引的基础上使用了很多创新。 它兼顾搜索和分析。

    默认情况下,Elasticsearch 在文档中的所有字段上构建一个反向索引,指向该字段所在的 Elasticsearch 文档。也就是说在每个 Elasticsearch 的Lucene里,有一个位置存放这个 inverted index。

    在 Kibana 中,我们建立一个如下的文档:

    PUT twitter/_doc/1
    {
      "user" : "双榆树-张三",
      "message" : "今儿天气不错啊,出去转转去",
      "uid" : 2,
      "age" : 20,
      "city" : "北京",
      "province" : "北京",
      "country" : "中国",
      "name": {
        "firstname": "三",
        "surname": "张"
      },
      "address" : [
        "中国北京市海淀区",
        "中关村29号"
      ],
      "location" : {
        "lat" : "39.970718",
        "lon" : "116.325747"
      }
    }

    当这个文档被建立好以后,Elastic 就已经帮我们建立好了相应的 inverted index 供我们进行搜索,比如:

    GET twitter/_search
    {
      "query": {
        "match": {
          "user": "张三"
        }
      }
    }

    我们可与得到相应的搜索结果:

    {
      "took" : 0,
      "timed_out" : false,
      "_shards" : {
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        "total" : {
          "value" : 1,
          "relation" : "eq"
        },
        "max_score" : 0.5753642,
        "hits" : [
          {
            "_index" : "twitter",
            "_type" : "_doc",
            "_id" : "1",
            "_score" : 0.5753642,
            "_source" : {
              "user" : "双榆树-张三",
              "message" : "今儿天气不错啊,出去转转去",
              "uid" : 2,
              "age" : 20,
              "city" : "北京",
              "province" : "北京",
              "country" : "中国",
              "name" : {
                "firstname" : "三",
                "surname" : "张"
              },
              "address" : [
                "中国北京市海淀区",
                "中关村29号"
              ],
              "location" : {
                "lat" : "39.970718",
                "lon" : "116.325747"
              }
            }
          }
        ]
      }
    }

    如果我们想不让我们的某个字段不被搜索,也就是说不想为这个字段建立 inverted index,那么我们可以这么做:

    DELETE twitter
    PUT twitter
    {
      "mappings": {
        "properties": {
          "city": {
            "type": "keyword",
            "ignore_above": 256
          },
          "address": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "age": {
            "type": "long"
          },
          "country": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "location": {
            "properties": {
              "lat": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "lon": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              }
            }
          },
          "message": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "name": {
            "properties": {
              "firstname": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "surname": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              }
            }
          },
          "province": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "uid": {
            "type": "long"
          },
          "user": {
            "type": "object",
            "enabled": false
          }
        }
      }
    }
    
    PUT twitter/_doc/1
    {
      "user" : "双榆树-张三",
      "message" : "今儿天气不错啊,出去转转去",
      "uid" : 2,
      "age" : 20,
      "city" : "北京",
      "province" : "北京",
      "country" : "中国",
      "name": {
        "firstname": "三",
        "surname": "张"
      },
      "address" : [
        "中国北京市海淀区",
        "中关村29号"
      ],
      "location" : {
        "lat" : "39.970718",
        "lon" : "116.325747"
      }
    }

    在上面,我们通过 mapping 对 user 字段进行了修改:

     "user": {
            "type": "object",
            "enabled": false
      }

    也就是说这个字段将不被建立索引,我们如果使用这个字段进行搜索的话,不会产生任何的结果:

    GET twitter/_search
    {
      "query": {
        "match": {
          "user": "张三"
        }
      }
    }

    搜索的结果为:

    {
      "took" : 0,
      "timed_out" : false,
      "_shards" : {
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        "total" : {
          "value" : 0,
          "relation" : "eq"
        },
        "max_score" : null,
        "hits" : [ ]
      }
    }

    显然是没有任何的结果。但是如果我们对这个文档进行查询的话:

    GET twitter/_doc/1

    显示的结果是:

    {
      "_index" : "twitter",
      "_type" : "_doc",
      "_id" : "1",
      "_version" : 1,
      "_seq_no" : 0,
      "_primary_term" : 1,
      "found" : true,
      "_source" : {
        "user" : "双榆树-张三",
        "message" : "今儿天气不错啊,出去转转去",
        "uid" : 2,
        "age" : 20,
        "city" : "北京",
        "province" : "北京",
        "country" : "中国",
        "name" : {
          "firstname" : "三",
          "surname" : "张"
        },
        "address" : [
          "中国北京市海淀区",
          "中关村29号"
        ],
        "location" : {
          "lat" : "39.970718",
          "lon" : "116.325747"
        }
      }
    }

    显然 user 的信息是存放于 source 里的。只是它不被我们所搜索而已。

    如果我们不想我们的整个文档被搜索,我们甚至可以直接采用如下的方法:

    DELETE twitter
    
    PUT twitter 
    {
      "mappings": {
        "enabled": false 
      }
    }

    那么整个 twitter 索引将不建立任何的 inverted index,那么我们通过如下的命令:
     

    PUT twitter/_doc/1
    {
      "user" : "双榆树-张三",
      "message" : "今儿天气不错啊,出去转转去",
      "uid" : 2,
      "age" : 20,
      "city" : "北京",
      "province" : "北京",
      "country" : "中国",
      "name": {
        "firstname": "三",
        "surname": "张"
      },
      "address" : [
        "中国北京市海淀区",
        "中关村29号"
      ],
      "location" : {
        "lat" : "39.970718",
        "lon" : "116.325747"
      }
    }
    
    GET twitter/_search
    {
      "query": {
        "match": {
          "city": "北京"
        }
      }
    }

    上面的命令执行的结果是,没有任何搜索的结果。更多阅读,可以参阅 “Mapping parameters: enabled”。

    我们也可以使用如下的方式来使得我们禁止对一个字段进行查询:

    {
      "mappings": {
        "properties": {
          "http_version": {
            "type": "keyword",
            "index": false
          }
         ...
        }
      }
    }

    上面的设置使得 http_version 不被索引。上面的 mapping 使得我们不能对 http_version 字段进行搜索,从而节省磁盘空间,但是它并不妨碍我们对该字段进行 aggregation 及对 source 的访问。

     

    Source

    在 Elasticsearch 中,通常每个文档的每一个字段都会被存储在 shard 里存放 source 的地方,比如:

    PUT twitter/_doc/2
    {
      "user" : "双榆树-张三",
      "message" : "今儿天气不错啊,出去转转去",
      "uid" : 2,
      "age" : 20,
      "city" : "北京",
      "province" : "北京",
      "country" : "中国",
      "name": {
        "firstname": "三",
        "surname": "张"
      },
      "address" : [
        "中国北京市海淀区",
        "中关村29号"
      ],
      "location" : {
        "lat" : "39.970718",
        "lon" : "116.325747"
      }
    }

    在这里,我们创建了一个 id 为2的文档。我们可以通过如下的命令来获得它的所有的存储的信息。

    GET twitter/_doc/2

    它将返回:

    {
      "_index" : "twitter",
      "_type" : "_doc",
      "_id" : "2",
      "_version" : 1,
      "_seq_no" : 1,
      "_primary_term" : 1,
      "found" : true,
      "_source" : {
        "user" : "双榆树-张三",
        "message" : "今儿天气不错啊,出去转转去",
        "uid" : 2,
        "age" : 20,
        "city" : "北京",
        "province" : "北京",
        "country" : "中国",
        "name" : {
          "firstname" : "三",
          "surname" : "张"
        },
        "address" : [
          "中国北京市海淀区",
          "中关村29号"
        ],
        "location" : {
          "lat" : "39.970718",
          "lon" : "116.325747"
        }
      }
    }

    在上面的 _source 里我们可以看到 Elasticsearch 为我们所存下的所有的字段。如果我们不想存储任何的字段,那么我们可以做如下的设置:

    DELETE twitter
    
    PUT twitter
    {
      "mappings": {
        "_source": {
          "enabled": false
        }
      }
    }

    那么我们使用如下的命令来创建一个 id 为1的文档:

    PUT twitter/_doc/1
    {
      "user" : "双榆树-张三",
      "message" : "今儿天气不错啊,出去转转去",
      "uid" : 2,
      "age" : 20,
      "city" : "北京",
      "province" : "北京",
      "country" : "中国",
      "name": {
        "firstname": "三",
        "surname": "张"
      },
      "address" : [
        "中国北京市海淀区",
        "中关村29号"
      ],
      "location" : {
        "lat" : "39.970718",
        "lon" : "116.325747"
      }
    }

    那么同样地,我们来查询一下这个文档:

    GET twitter/_doc/1

    显示的结果为:

    {
      "_index" : "twitter",
      "_type" : "_doc",
      "_id" : "1",
      "_version" : 1,
      "_seq_no" : 0,
      "_primary_term" : 1,
      "found" : true
    }
    

    显然我们的文档是被找到了,但是我们看不到任何的 source。那么我们能对这个文档进行搜索吗?尝试如下的命令:

    GET twitter/_search
    {
      "query": {
        "match": {
          "city": "北京"
        }
      }
    }

    显示的结果为:

    {
      "took" : 0,
      "timed_out" : false,
      "_shards" : {
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        "total" : {
          "value" : 1,
          "relation" : "eq"
        },
        "max_score" : 0.5753642,
        "hits" : [
          {
            "_index" : "twitter",
            "_type" : "_doc",
            "_id" : "1",
            "_score" : 0.5753642
          }
        ]
      }
    }
    

    显然这个文档 id 为1的文档可以被正确地搜索,也就是说它有完好的 inverted index 供我们查询,虽然它没有它的 source。

    那么我们如何有选择地进行存储我们想要的字段呢?这种情况适用于我们想节省自己的存储空间,只存储那些我们需要的字段到source里去。我们可以做如下的设置:

    DELETE twitter
    
    PUT twitter
    {
      "mappings": {
        "_source": {
          "includes": [
            "*.lat",
            "address",
            "name.*"
          ],
          "excludes": [
            "name.surname"
          ]
        }    
      }
    }

    在上面,我们使用 include 来包含我们想要的字段,同时我们通过 exclude 来去除那些不需要的字段。我们尝试如下的文档输入:

    PUT twitter/_doc/1
    {
      "user" : "双榆树-张三",
      "message" : "今儿天气不错啊,出去转转去",
      "uid" : 2,
      "age" : 20,
      "city" : "北京",
      "province" : "北京",
      "country" : "中国",
      "name": {
        "firstname": "三",
        "surname": "张"
      },
      "address" : [
        "中国北京市海淀区",
        "中关村29号"
      ],
      "location" : {
        "lat" : "39.970718",
        "lon" : "116.325747"
      }
    }

    通过如下的命令来进行查询,我们可以看到:

    GET twitter/_doc/1

    结果是:

    {
      "_index" : "twitter",
      "_type" : "_doc",
      "_id" : "1",
      "_version" : 1,
      "_seq_no" : 0,
      "_primary_term" : 1,
      "found" : true,
      "_source" : {
        "address" : [
          "中国北京市海淀区",
          "中关村29号"
        ],
        "name" : {
          "firstname" : "三"
        },
        "location" : {
          "lat" : "39.970718"
        }
      }
    }

    显然,我们只有很少的几个字段被存储下来了。通过这样的方法,我们可以有选择地存储我们想要的字段。

    在实际的使用中,我们在查询文档时,也可以有选择地进行显示我们想要的字段,尽管有很多的字段被存于source中:

    GET twitter/_doc/1?_source=name,location

    在这里,我们只想显示和name及location相关的字段,那么显示的结果为:

    {
      "_index" : "twitter",
      "_type" : "_doc",
      "_id" : "1",
      "_version" : 1,
      "_seq_no" : 0,
      "_primary_term" : 1,
      "found" : true,
      "_source" : {
        "name" : {
          "firstname" : "三"
        },
        "location" : {
          "lat" : "39.970718"
        }
      }
    }
    

    更多的阅读,可以参阅文档“Mapping meta-field: _source

     

    Doc_values

    默认情况下,大多数字段都已编入索引,这使它们可搜索。反向索引允许查询在唯一的术语排序列表中查找搜索词,并从中立即访问包含该词的文档列表。

    sort,aggregtion 和访问脚本中的字段值需要不同的数据访问模式。除了查找术语和查找文档外,我们还需要能够查找文档并查找其在字段中具有的术语。

    Doc values 是在文档索引时构建的磁盘数据结构,这使这种数据访问模式成为可能。它们存储与 _source 相同的值,但以面向列(column)的方式存储,这对于排序和聚合而言更为有效。几乎所有字段类型都支持Doc值,但对字符串字段除外 (text 及annotated_text)。Doc values 告诉你对于给定的文档 ID,字段的值是什么。比如,当我们向Elasticsearch中加入如下的文档:

    PUT cities
    {
      "mappings": {
        "properties": {
          "city": {
            "type": "keyword"
          }
        }
      }
    }
    
    PUT cities/_doc/1
    {
      "city": "Wuhan"
    }
    
    PUT cities/_doc/2
    {
      "city": "Beijing"
    }
    
    PUT cities/_doc/3
    {
      "city": "Shanghai"
    }

    那么将在在 Elasticsearch 中将创建像如下的 doc_values 的一个列存储(Columnar store)表格:

    doc id city
    1 Wuhan
    2 Beijing
    3 Shanghai

    默认情况下,所有支持 doc 值的字段均已启用它们。如果您确定不需要对字段进行排序或汇总,也不需要通过脚本访问字段值,则可以禁用 doc 值以节省磁盘空间:

    比如我们可以通过如下的方式来使得 city 字段不可以做 sort 或 aggregation:

    DELETE twitter
    PUT twitter
    {
      "mappings": {
        "properties": {
          "city": {
            "type": "keyword",
            "doc_values": false,
            "ignore_above": 256
          },
          "address": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "age": {
            "type": "long"
          },
          "country": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "location": {
            "properties": {
              "lat": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "lon": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              }
            }
          },
          "message": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "name": {
            "properties": {
              "firstname": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "surname": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              }
            }
          },
          "province": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "uid": {
            "type": "long"
          },
          "user": {
            "type": "text",
            "fields": {
              "keyword": {
                "type": "keyword",
                "ignore_above": 256
              }
            }
          }
        }
      }
    }

    在上面,我们把 city 字段的 doc_values 设置为 false。

          "city": {
            "type": "keyword",
            "doc_values": false,
            "ignore_above": 256
          },

     

    我们通过如下的方法来创建一个文档:

    PUT twitter/_doc/1
    {
      "user" : "双榆树-张三",
      "message" : "今儿天气不错啊,出去转转去",
      "uid" : 2,
      "age" : 20,
      "city" : "北京",
      "province" : "北京",
      "country" : "中国",
      "name": {
        "firstname": "三",
        "surname": "张"
      },
      "address" : [
        "中国北京市海淀区",
        "中关村29号"
      ],
      "location" : {
        "lat" : "39.970718",
        "lon" : "116.325747"
      }
    }

    那么,当我们使用如下的方法来进行 aggregation 时:

    GET twitter/_search
    {
      "size": 0,
      "aggs": {
        "city_bucket": {
          "terms": {
            "field": "city",
            "size": 10
          }
        }
      }
    }

    在我们的 Kibana 上我们可以看到:

    {
      "error": {
        "root_cause": [
          {
            "type": "illegal_argument_exception",
            "reason": "Can't load fielddata on [city] because fielddata is unsupported on fields of type [keyword]. Use doc values instead."
          }
        ],
        "type": "search_phase_execution_exception",
        "reason": "all shards failed",
        "phase": "query",
        "grouped": true,
        "failed_shards": [
          {
            "shard": 0,
            "index": "twitter",
            "node": "IyyZ30-hRi2rnOpfx4n1-A",
            "reason": {
              "type": "illegal_argument_exception",
              "reason": "Can't load fielddata on [city] because fielddata is unsupported on fields of type [keyword]. Use doc values instead."
            }
          }
        ],
        "caused_by": {
          "type": "illegal_argument_exception",
          "reason": "Can't load fielddata on [city] because fielddata is unsupported on fields of type [keyword]. Use doc values instead.",
          "caused_by": {
            "type": "illegal_argument_exception",
            "reason": "Can't load fielddata on [city] because fielddata is unsupported on fields of type [keyword]. Use doc values instead."
          }
        }
      },
      "status": 400
    }

    显然,我们的操作是失败的。尽管我们不能做 aggregation 及 sort,但是我们还是可以通过如下的命令来得到它的 source:

    GET twitter/_doc/1

    显示结果为:

    {
      "_index" : "twitter",
      "_type" : "_doc",
      "_id" : "1",
      "_version" : 1,
      "_seq_no" : 0,
      "_primary_term" : 1,
      "found" : true,
      "_source" : {
        "user" : "双榆树-张三",
        "message" : "今儿天气不错啊,出去转转去",
        "uid" : 2,
        "age" : 20,
        "city" : "北京",
        "province" : "北京",
        "country" : "中国",
        "name" : {
          "firstname" : "三",
          "surname" : "张"
        },
        "address" : [
          "中国北京市海淀区",
          "中关村29号"
        ],
        "location" : {
          "lat" : "39.970718",
          "lon" : "116.325747"
        }
      }
    }

    更多阅读请参阅 “Mapping parameters: doc_values”。

    其实在实际的 Elasticsearch 存储中,还有一类存储。它就是 store。请详细阅读我的另外一篇文章 “Elasticsearch: 理解 mapping 中的 store 属性”。

    展开全文
  • 文章目录1.概述2.Inverted index3.Source4.Doc_values 1.概述 ...以后会用到的相关知识:索引中某些字段...这个几个概念分别指的是什么?有什么用处?如何配置它们?只有我们熟练地掌握了这些概念,我们才可以正确地使

    在这里插入图片描述

    1.概述

    转载:https://www.cnblogs.com/sanduzxcvbnm/p/12084134.html

    以后会用到的相关知识:索引中某些字段禁止搜索,排序等操作

    当我们学习Elasticsearch时,经常会遇到如下的几个概念:

    Reverted index
    doc_values
    source?
    

    这个几个概念分别指的是什么?有什么用处?如何配置它们?只有我们熟练地掌握了这些概念,我们才可以正确地使用它们。
    在这里插入图片描述

    2.Inverted index

    inverted index(反向索引)是Elasticsearch和任何其他支持全文搜索的系统的核心数据结构。 反向索引类似于您在任何书籍结尾处看到的索引。 它将出现在文档中的术语映射到文档。

    例如,您可以从以下字符串构建反向索引:

    在这里插入图片描述
    Elasticsearch从已建立索引的三个文档中构建数据结构。 以下数据结构称为反向索引(inverted index):

    Term 				Frequency 		Document (postings)
    choice 					1 				3
    day 					1 				2
    is 						3 				1,2,3
    it 						1 				1
    last 					1 				2
    of 						1 				2
    of 						1 				2
    sunday 					2 				1,2
    the 					3 				2,3
    tomorrow 				1 				1
    week 					1 				2
    yours 					1 				3
    

    在这里反向索引指的的是,我们根据term来寻找相应的文档ids。这和常规的根据文档id来寻找term相反。

    请注意以下几点:

    1. 删除标点符号并将其小写后,文档会按术语进行细分。
    2. 术语按字母顺序排序
    3. “Frequency”列捕获该术语在整个文档集中出现的次数
    4. 第三列捕获了在其中找到该术语的文档。 此外,它还可能包含找到该术语的确切位置(文档中的偏移)

    在文档中搜索术语时,查找给定术语出现在其中的文档非常快捷。 如果用户搜索术语“sunday”,那么从“Term”列中查找sunday将非常快,因为这些术语在索引中进行了排序。 即使有数百万个术语,也可以在对术语进行排序时快速查找它们。

    随后,考虑一种情况,其中用户搜索两个单词,例如last sunday。 反向索引可用于分别搜索last和sunday的发生; 文档2包含这两个术语,因此比仅包含一个术语的文档1更好。

    反向索引是执行快速搜索的基础。 同样,很容易查明索引中出现了多少次术语。 这是一个简单的计数汇总。 当然,Elasticsearch在我们在这里解释的简单的反向排索引的基础上使用了很多创新。 它兼顾搜索和分析。

    默认情况下,Elasticsearch在文档中的所有字段上构建一个反向索引,指向该字段所在的Elasticsearch文档。也就是说在每个Elasticsearch的Lucene里,有一个位置存放这个inverted index。

    在Kibana中,我们建立一个如下的文档:

    	PUT twitter/_doc/1
        {
          "user" : "双榆树-张三",
          "message" : "今儿天气不错啊,出去转转去",
          "uid" : 2,
          "age" : 20,
          "city" : "北京",
          "province" : "北京",
          "country" : "中国",
          "name": {
            "firstname": "三",
            "surname": "张"
          },
          "address" : [
            "中国北京市海淀区",
            "中关村29号"
          ],
          "location" : {
            "lat" : "39.970718",
            "lon" : "116.325747"
          }
        }
    

    当这个文档被建立好以后,Elastic就已经帮我们建立好了相应的inverted index供我们进行搜索,比如:

      GET twitter/_search
        {
          "query": {
            "match": {
              "user": "张三"
            }
          }
        }
    

    我们可与得到相应的搜索结果:

        {
          "took" : 0,
          "timed_out" : false,
          "_shards" : {
            "total" : 1,
            "successful" : 1,
            "skipped" : 0,
            "failed" : 0
          },
          "hits" : {
            "total" : {
              "value" : 1,
              "relation" : "eq"
            },
            "max_score" : 0.5753642,
            "hits" : [
              {
                "_index" : "twitter",
                "_type" : "_doc",
                "_id" : "1",
                "_score" : 0.5753642,
                "_source" : {
                  "user" : "双榆树-张三",
                  "message" : "今儿天气不错啊,出去转转去",
                  "uid" : 2,
                  "age" : 20,
                  "city" : "北京",
                  "province" : "北京",
                  "country" : "中国",
                  "name" : {
                    "firstname" : "三",
                    "surname" : "张"
                  },
                  "address" : [
                    "中国北京市海淀区",
                    "中关村29号"
                  ],
                  "location" : {
                    "lat" : "39.970718",
                    "lon" : "116.325747"
                  }
                }
              }
            ]
          }
        }
    

    如果我们想不让我们的某个字段不被搜索,也就是说不想为这个字段建立inverted index,那么我们可以这么做:

    DELETE twitter
        PUT twitter
        {
          "mappings": {
            "properties": {
              "city": {
                "type": "keyword",
                "ignore_above": 256
              },
              "address": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "age": {
                "type": "long"
              },
              "country": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "location": {
                "properties": {
                  "lat": {
                    "type": "text",
                    "fields": {
                      "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  },
                  "lon": {
                    "type": "text",
                    "fields": {
                      "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  }
                }
              },
              "message": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "name": {
                "properties": {
                  "firstname": {
                    "type": "text",
                    "fields": {
                      "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  },
                  "surname": {
                    "type": "text",
                    "fields": {
                      "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  }
                }
              },
              "province": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "uid": {
                "type": "long"
              },
              "user": {
                "type": "object",
                "enabled": false
              }
            }
          }
        }
         
        PUT twitter/_doc/1
        {
          "user" : "双榆树-张三",
          "message" : "今儿天气不错啊,出去转转去",
          "uid" : 2,
          "age" : 20,
          "city" : "北京",
          "province" : "北京",
          "country" : "中国",
          "name": {
            "firstname": "三",
            "surname": "张"
          },
          "address" : [
            "中国北京市海淀区",
            "中关村29号"
          ],
          "location" : {
            "lat" : "39.970718",
            "lon" : "116.325747"
          }
        }
    

    在上面,我们通过mapping对user字段进行了修改:

     "user": {
                "type": "object",
                "enabled": false
          }
    

    也就是说这个字段将不被建立索引,我们如果使用这个字段进行搜索的话,不会产生任何的结果:

     GET twitter/_search
        {
          "query": {
            "match": {
              "user": "张三"
            }
          }
        }
    

    搜索的结果为:

    {
          "took" : 0,
          "timed_out" : false,
          "_shards" : {
            "total" : 1,
            "successful" : 1,
            "skipped" : 0,
            "failed" : 0
          },
          "hits" : {
            "total" : {
              "value" : 0,
              "relation" : "eq"
            },
            "max_score" : null,
            "hits" : [ ]
          }
        }
    
    

    显然是没有任何的结果。但是如果我们对这个文档进行查询的话:

    GET twitter/_doc/1
    
    

    显示的结果是:

     {
          "_index" : "twitter",
          "_type" : "_doc",
          "_id" : "1",
          "_version" : 1,
          "_seq_no" : 0,
          "_primary_term" : 1,
          "found" : true,
          "_source" : {
            "user" : "双榆树-张三",
            "message" : "今儿天气不错啊,出去转转去",
            "uid" : 2,
            "age" : 20,
            "city" : "北京",
            "province" : "北京",
            "country" : "中国",
            "name" : {
              "firstname" : "三",
              "surname" : "张"
            },
            "address" : [
              "中国北京市海淀区",
              "中关村29号"
            ],
            "location" : {
              "lat" : "39.970718",
              "lon" : "116.325747"
            }
          }
        }
    

    显然user的信息是存放于source里的。只是它不被我们所搜索而已。

    如果我们不想我们的整个文档被搜索,我们甚至可以直接采用如下的方法:

        DELETE twitter
         
        PUT twitter 
        {
          "mappings": {
            "enabled": false 
          }
        }
    

    那么整个twitter索引将不建立任何的inverted index,那么我们通过如下的命令:

    PUT twitter/_doc/1
        {
          "user" : "双榆树-张三",
          "message" : "今儿天气不错啊,出去转转去",
          "uid" : 2,
          "age" : 20,
          "city" : "北京",
          "province" : "北京",
          "country" : "中国",
          "name": {
            "firstname": "三",
            "surname": "张"
          },
          "address" : [
            "中国北京市海淀区",
            "中关村29号"
          ],
          "location" : {
            "lat" : "39.970718",
            "lon" : "116.325747"
          }
        }
         
        GET twitter/_search
        {
          "query": {
            "match": {
              "city": "北京"
            }
          }
        }
    

    上面的命令执行的结果是,没有任何搜索的结果。更多阅读,可以参阅“Mapping parameters: enabled”(https://www.elastic.co/guide/en/elasticsearch/reference/current/enabled.html)。

    3.Source

    在Elasticsearch中,通常每个文档的每一个字段都会被存储在shard里存放source的地方,比如:

    PUT twitter/_doc/2
        {
          "user" : "双榆树-张三",
          "message" : "今儿天气不错啊,出去转转去",
          "uid" : 2,
          "age" : 20,
          "city" : "北京",
          "province" : "北京",
          "country" : "中国",
          "name": {
            "firstname": "三",
            "surname": "张"
          },
          "address" : [
            "中国北京市海淀区",
            "中关村29号"
          ],
          "location" : {
            "lat" : "39.970718",
            "lon" : "116.325747"
          }
        }
    

    在这里,我们创建了一个id为2的文档。我们可以通过如下的命令来获得它的所有的存储的信息。

    GET twitter/_doc/2
    

    它将返回:

    {
          "_index" : "twitter",
          "_type" : "_doc",
          "_id" : "2",
          "_version" : 1,
          "_seq_no" : 1,
          "_primary_term" : 1,
          "found" : true,
          "_source" : {
            "user" : "双榆树-张三",
            "message" : "今儿天气不错啊,出去转转去",
            "uid" : 2,
            "age" : 20,
            "city" : "北京",
            "province" : "北京",
            "country" : "中国",
            "name" : {
              "firstname" : "三",
              "surname" : "张"
            },
            "address" : [
              "中国北京市海淀区",
              "中关村29号"
            ],
            "location" : {
              "lat" : "39.970718",
              "lon" : "116.325747"
            }
          }
        }
    

    在上面的_source里我们可以看到Elasticsearch为我们所存下的所有的字段。如果我们不想存储任何的字段,那么我们可以做如下的设置:

    DELETE twitter
         
        PUT twitter
        {
          "mappings": {
            "_source": {
              "enabled": false
            }
          }
        }
    

    那么我们使用如下的命令来创建一个id为1的文档:

    PUT twitter/_doc/1
        {
          "user" : "双榆树-张三",
          "message" : "今儿天气不错啊,出去转转去",
          "uid" : 2,
          "age" : 20,
          "city" : "北京",
          "province" : "北京",
          "country" : "中国",
          "name": {
            "firstname": "三",
            "surname": "张"
          },
          "address" : [
            "中国北京市海淀区",
            "中关村29号"
          ],
          "location" : {
            "lat" : "39.970718",
            "lon" : "116.325747"
          }
        }
    

    那么同样地,我们来查询一下这个文档:

    GET witter/_doc/1
    显示的结果为:
    
        {
          "_index" : "twitter",
          "_type" : "_doc",
          "_id" : "1",
          "_version" : 1,
          "_seq_no" : 0,
          "_primary_term" : 1,
          "found" : true
        }
    

    显然我们的文档是被找到了,但是我们看不到任何的source。那么我们能对这个文档进行搜索吗?尝试如下的命令:

        GET twitter/_search
        {
          "query": {
            "match": {
              "city": "北京"
            }
          }
        }
    显示的结果为:
    
        {
          "took" : 0,
          "timed_out" : false,
          "_shards" : {
            "total" : 1,
            "successful" : 1,
            "skipped" : 0,
            "failed" : 0
          },
          "hits" : {
            "total" : {
              "value" : 1,
              "relation" : "eq"
            },
            "max_score" : 0.5753642,
            "hits" : [
              {
                "_index" : "twitter",
                "_type" : "_doc",
                "_id" : "1",
                "_score" : 0.5753642
              }
            ]
          }
        }
    

    显然这个文档id为1的文档可以被正确地搜索,也就是说它有完好的inverted index供我们查询,虽然它没有字的source。

    那么我们如何有选择地进行存储我们想要的字段呢?这种情况适用于我们想节省自己的存储空间,只存储那些我们需要的字段到source里去。我们可以做如下的设置:

    DELETE twitter

    PUT twitter
    {
    “mappings”: {
    “_source”: {
    “includes”: [
    .lat",
    “address”,
    "name.

    ],
    “excludes”: [
    “name.surname”
    ]
    }
    }
    }

    在上面,我们使用include来包含我们想要的字段,同时我们通过exclude来去除那些不需要的字段。我们尝试如下的文档输入:

       PUT twitter/_doc/1
        {
          "user" : "双榆树-张三",
          "message" : "今儿天气不错啊,出去转转去",
          "uid" : 2,
          "age" : 20,
          "city" : "北京",
          "province" : "北京",
          "country" : "中国",
          "name": {
            "firstname": "三",
            "surname": "张"
          },
          "address" : [
            "中国北京市海淀区",
            "中关村29号"
          ],
          "location" : {
            "lat" : "39.970718",
            "lon" : "116.325747"
          }
        }
    

    通过如下的命令来进行查询,我们可以看到:

    GET twitter/_doc/1
    结果是:
    
        {
          "_index" : "twitter",
          "_type" : "_doc",
          "_id" : "1",
          "_version" : 1,
          "_seq_no" : 0,
          "_primary_term" : 1,
          "found" : true,
          "_source" : {
            "address" : [
              "中国北京市海淀区",
              "中关村29号"
            ],
            "name" : {
              "firstname" : "三"
            },
            "location" : {
              "lat" : "39.970718"
            }
          }
        }
    

    显然,我们只有很少的几个字段被存储下来了。通过这样的方法,我们可以有选择地存储我们想要的字段。

    在实际的使用中,我们在查询文档时,也可以有选择地进行显示我们想要的字段,尽管有很多的字段被存于source中:

    GET twitter/_doc/1?_source=name,location
    

    在这里,我们只想显示和name及location相关的字段,那么显示的结果为:

    {
      "_index" : "twitter",
      "_type" : "_doc",
      "_id" : "1",
      "_version" : 1,
      "_seq_no" : 0,
      "_primary_term" : 1,
      "found" : true,
      "_source" : {
        "name" : {
          "firstname" : "三"
        },
        "location" : {
          "lat" : "39.970718"
        }
      }
    }
    

    更多的阅读,可以参阅文档“Mapping meta-field: _source”(https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-source-field.html)

    4.Doc_values

    默认情况下,大多数字段都已编入索引,这使它们可搜索。反向索引允许查询在唯一的术语排序列表中查找搜索词,并从中立即访问包含该词的文档列表。

    sort,aggregtion和访问脚本中的字段值需要不同的数据访问模式。除了查找术语和查找文档外,我们还需要能够查找文档并查找其在字段中具有的术语。

    Doc values是在文档索引时构建的磁盘数据结构,这使这种数据访问模式成为可能。它们存储与_source相同的值,但以面向列的方式存储,这对于排序和聚合而言更为有效。几乎所有字段类型都支持Doc值,但对字符串字段除外

    默认情况下,所有支持doc值的字段均已启用它们。如果您确定不需要对字段进行排序或汇总,也不需要通过脚本访问字段值,则可以禁用doc值以节省磁盘空间:

    比如我们可以通过如下的方式来使得city字段不可以做sort或aggregation:

    DELETE twitter
    PUT twitter
        {
          "mappings": {
            "properties": {
              "city": {
                "type": "keyword",
                "doc_values": false,
                "ignore_above": 256
              },
              "address": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "age": {
                "type": "long"
              },
              "country": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "location": {
                "properties": {
                  "lat": {
                    "type": "text",
                    "fields": {
                      "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  },
                  "lon": {
                    "type": "text",
                    "fields": {
                      "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  }
                }
              },
              "message": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "name": {
                "properties": {
                  "firstname": {
                    "type": "text",
                    "fields": {
                      "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  },
                  "surname": {
                    "type": "text",
                    "fields": {
                      "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  }
                }
              },
              "province": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "uid": {
                "type": "long"
              },
              "user": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              }
            }
          }
        }
    

    在上面,我们把city字段的doc_values设置为false。

      "city": {
        "type": "keyword",
        "doc_values": false,
        "ignore_above": 256
      },
    

    我们通过如下的方法来创建一个文档:

    PUT twitter/_doc/1
    {
      "user" : "双榆树-张三",
      "message" : "今儿天气不错啊,出去转转去",
      "uid" : 2,
      "age" : 20,
      "city" : "北京",
      "province" : "北京",
      "country" : "中国",
      "name": {
        "firstname": "三",
        "surname": "张"
      },
      "address" : [
        "中国北京市海淀区",
        "中关村29号"
      ],
      "location" : {
        "lat" : "39.970718",
        "lon" : "116.325747"
      }
    }
    

    那么,当我们使用如下的方法来进行aggregation时:

    GET twitter/_search
    {
      "size": 0,
      "aggs": {
        "city_bucket": {
          "terms": {
            "field": "city",
            "size": 10
          }
        }
      }
    }
    

    在我们的Kibana上我们可以看到:

       {
          "error": {
            "root_cause": [
              {
                "type": "illegal_argument_exception",
                "reason": "Can't load fielddata on [city] because fielddata is unsupported on fields of type [keyword]. Use doc values instead."
              }
            ],
            "type": "search_phase_execution_exception",
            "reason": "all shards failed",
            "phase": "query",
            "grouped": true,
            "failed_shards": [
              {
                "shard": 0,
                "index": "twitter",
                "node": "IyyZ30-hRi2rnOpfx4n1-A",
                "reason": {
                  "type": "illegal_argument_exception",
                  "reason": "Can't load fielddata on [city] because fielddata is unsupported on fields of type [keyword]. Use doc values instead."
                }
              }
            ],
            "caused_by": {
              "type": "illegal_argument_exception",
              "reason": "Can't load fielddata on [city] because fielddata is unsupported on fields of type [keyword]. Use doc values instead.",
              "caused_by": {
                "type": "illegal_argument_exception",
                "reason": "Can't load fielddata on [city] because fielddata is unsupported on fields of type [keyword]. Use doc values instead."
              }
            }
          },
          "status": 400
        }
    

    显然,我们的操作是失败的。尽管我们不能做aggregation及sort,但是我们还是可以通过如下的命令来得到它的source:

    GET twitter/_doc/1
    显示结果为:
    
        {
          "_index" : "twitter",
          "_type" : "_doc",
          "_id" : "1",
          "_version" : 1,
          "_seq_no" : 0,
          "_primary_term" : 1,
          "found" : true,
          "_source" : {
            "user" : "双榆树-张三",
            "message" : "今儿天气不错啊,出去转转去",
            "uid" : 2,
            "age" : 20,
            "city" : "北京",
            "province" : "北京",
            "country" : "中国",
            "name" : {
              "firstname" : "三",
              "surname" : "张"
            },
            "address" : [
              "中国北京市海淀区",
              "中关村29号"
            ],
            "location" : {
              "lat" : "39.970718",
              "lon" : "116.325747"
            }
          }
        }
    

    更多阅读请参阅“Mapping parameters: doc_values”(https://www.elastic.co/guide/en/elasticsearch/reference/7.4/doc-values.html)。

    分类: ELK Stack

    展开全文
  • 什么是缺失值?缺失值数据集中某些变量的值有缺少的情况,缺失值也被称为NA(not available)值。...需要注意的是,有些缺失值也会以其他形式出现,比如说用0或无穷大(inf)表示。 缺失值产生的原因...
  • CRUD是什么

    万次阅读 2017-01-12 08:32:31
    CRUD是指在做计算处理时增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)几个单词首字母简写。主要被用在描述软件系统中数据库或者持久层基本操作功能。 CRUD说就是增查改删 C:Create 增加...
  • FAY SEAL背景知识针对波音AMM TASK 20-50-11-910-801 标准力矩这份卡,网上资料基本很全了,大家可以参考阮工文章:B737NG标准力矩值...其实最初Faying Surfaces其实是指老式木船船体木板和木板之间涂抹松...
  • CRUD是什么意思

    万次阅读 2018-05-14 08:14:01
    CRUD是指在做计算处理时增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)几个单词首字母简写。主要被用在描述软件系统中DataBase或者持久层基本操作功能。 CRUD说就是增查改删 C:Create ...
  • 换句话说,dict就是无序,因为语言规范不保证它按照什么顺序出来。要有序,请使用OrderedDict。 但是无序不是说每次输出结果都不同,无序只是结果不保证一定与插入顺序一致而已。 CPython 3.6里对dict有个新...
  • 1、透视表privot_table 当得到一张数据平面表数据时,例如: 要想实现表中一个变量与其他多个变量之间的关系,可以用pivot_...其中最后的aggfunc指的是要求的是什么,可以是求和sum,或max等等,默认是np.mean...
  • 2018/6/01 CRUD是什么

    2018-06-01 08:54:27
    CRUD是指在做计算处理时增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)几个单词首字母简写。主要被用在描述软件系统中DataBase或者持久层基本操作功能。CRUD说就是增查改删C:Create 增加...
  • 主从复制,是指将一台Redis服务器数据,复制到其他Redis服务器。前者称为主节点(master),后者称为从节点(slave),数据复制单向,只能由主节点到从节点。 默认情况下,每台Redis服务器都
  • 时间戳类型,参数6指的是表示秒的数字的小数点右边可以存储6位数字,最多9位。 插入时,如下方式: insert into test4 values(to_timestamp('2013-12-12 23:23:23.112324233','yyyy-mm--dd hh24:mi:ss.ff')); ...
  • DML语句:DML操作是指对数据库中表进行操作,主要包括记录插入(insert),更新(update),删除(delete),查询(select)。记录插入创建表完成后就需要给器插入记录和数据了,插入记录基本语法如下:INSERT tablename...
  • ORA-12514:是什么意思

    2017-03-29 10:56:30
    using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Data.OracleClient; using System.Drawing;... string sql = @"insert... 错误是指在Conn.Open上
  • 代码里也没有错误(咳咳,**萌新没有错误是指代码里没有下划红波浪线**(挠挠头)) ![图片说明](https://img-ask.csdn.net/upload/202005/18/1589775371_102121.png) ``` FPSProjectile.h: // Fill ...
  • @>mysql -u root -p@>... insert into mysql.user(Host,User,Password) values("localhost","test",password("1234"));...注意:此处"localhost",是指该用户只能在本地登录,不能在另外一台机器上...
  • 领域类是什么鬼?领域不是field吗?Oxford Dict中解释是,domain源自于法语domeine,原意是estate, belonging to a lord,后来引进英语主要an area of territory。domain在计算机方向有两个解释:来自于数学术语,...
  • 首先说下 Byte 和 bit1...M宽度,使用默认就行,默认为3,定义宽度没太大意义使用zerofill 可以查看到宽度怎样存Insert into (num) values(1);Num显示 0011.TINYINT 有符号值: -2^7到2^7-1; 无符号值: 0到2^8-1;...
  • ELEMENT" 是元素的声明,说明你要定义的是一个元素; 声明后面的"DESCRIPTION",是元素的名称; "(#PCDATA, DEFINITION)*>"则是该元素的使用规则。规则定义了元素可以包含的内容以及相互的关系。下面的表格概要列...
  • 其中,sep指的是打印的各元素用什么隔开(默认为空格‘\t’),end指的是打印的这一行末尾是什么(默认为换行符’\n’),我们可以设定Sep与end的值 print(1,2,3) print('abc') ''' 1 2 3 abc ''' 设定sep的值时 ...
  • 做自己CEO

    2020-06-29 14:02:24
    目录前言做自己CEO做自己CEO是指什么什么要做自己CEO如何做自己CEO定义自己愿景、使命和价值观愿景 (Vision)使命 (Mission)价值观 (Values)CEO思维经营思维计划思维财务思维投资思维执行力进度监控管理...
  • JavaScript中纯函数

    2016-12-15 17:01:13
    纯函数是指 不依赖于且不改变它作用域之外变量状态 函数。 也就是说, 纯函数返回值只由它调用时参数决定 ,它执行不依赖于系统状态(比如:何时、何处调用它——译者注)。 纯函数 ...

空空如也

空空如也

1 2 3 4 5
收藏数 95
精华内容 38
关键字:

values指的是什么