rroonga 7.0.2-x86-mingw32 → 7.1.1-x86-mingw32

data/vendor/local/share/doc/groonga/ja/html/_sources/reference/suggest/correction.txt

@@ -1,148 +0,0 @@
-.. -*- rst -*-
-
-.. highlightlang:: none
-
-.. groonga-command
-.. % groonga-suggest-create-dataset /tmp/groonga-databases/correction query
-.. database: correction
-
-Correction
-==========
-
-This section describes about the following correction
-features:
-
-* How it works
-* How to use
-* How to learn
-
-How it works
-------------
-
-The correction feature uses three searches to compute corrected
-words:
-
-  1. Cooccurrence search against learned data.
-  2. Similar search against registered words. (optional)
-
-Cooccurrence search
-^^^^^^^^^^^^^^^^^^^
-
-Cooccurrence search can find registered words from user's
-wrong input. It uses user submit sequences that will be
-learned from query logs, access logs and so on.
-
-For example, there are the following user submissions:
-
-+-------------------+---------------------------+
-|  query            |    time                   |
-+===================+===========================+
-| serach (typo!)    | 2011-08-10T22:20:50+09:00 |
-+-------------------+---------------------------+
-| search (fixed!)   | 2011-08-10T22:20:52+09:00 |
-+-------------------+---------------------------+
-
-Groonga creates the following correction pair from the above
-submissions:
-
-+----------+--------------------+
-|  input   |   corrected word   |
-+==========+====================+
-|serach    |search              |
-+----------+--------------------+
-
-Groonga treats continuous submissions within a minute as
-input correction by user. Not submitted user input sequence
-between two submissions isn't used as learned data for
-correction.
-
-If an user inputs "serach" and cooccurrence search returns
-"search" because "serach" is in input column and
-corresponding corrected word column value is "search".
-
-Similar search
-^^^^^^^^^^^^^^
-
-Similar search can find registered words that has one or
-more the same tokens as user input. TokenBigram tokenizer is
-used for tokenization because suggest dataset schema
-created by :doc:`/reference/executables/groonga-suggest-create-dataset`
-uses TokenBigram tokenizer as the default tokenizer.
-
-For example, there is a registered query "search engine". An
-user can find "search engine" by "web search service",
-"sound engine" and so on. Because "search engine" and "web
-search engine" have the same token "search" and "search
-engine" and "sound engine" have the same token "engine".
-
-"search engine" is tokenized to "search" and "engine"
-tokens. (Groonga's TokenBigram tokenizer doesn't tokenize
-two characters for continuous alphabets and continuous
-digits for reducing search
-noise. TokenBigramSplitSymbolAlphaDigit tokenizer should be
-used to ensure tokenizing to two characters.) "web search
-service" is tokenized to "web", "search" and
-"service". "sound engine" is tokenized to "sound" and
-"engine".
-
-How to use
-----------
-
-.. groonga-command
-.. load --table event_query --each 'suggest_preparer(_id, type, item, sequence, time, pair_query)'
-.. [
-.. {"sequence": "1", "time": 1312950803.86057, "item": "s"},
-.. {"sequence": "1", "time": 1312950803.96857, "item": "sa"},
-.. {"sequence": "1", "time": 1312950804.26057, "item": "sae"},
-.. {"sequence": "1", "time": 1312950804.56057, "item": "saer"},
-.. {"sequence": "1", "time": 1312950804.76057, "item": "saerc"},
-.. {"sequence": "1", "time": 1312950805.76057, "item": "saerch", "type": "submit"},
-.. {"sequence": "1", "time": 1312950809.76057, "item": "serch"},
-.. {"sequence": "1", "time": 1312950810.86057, "item": "search", "type": "submit"}
-.. ]
-
-Groonga provides :doc:`/reference/commands/suggest` command to use
-correction. `--type correct` option requests corrections.
-
-For example, here is an command to get correction results by
-"saerch":
-
-.. groonga-command
-.. include:: ../../example/reference/suggest/correction/select.log
-.. suggest --table item_query --column kana --types correction --frequency_threshold 1 --query saerch
-
-How it learns
--------------
-
-Cooccurrence search uses learned data. They are based on
-query logs, access logs and so on. To create learned data,
-groonga needs user submit inputs with time stamp.
-
-For example, an user wants to search by "search" but the
-user has typo "saerch" before inputs the correct query. The
-user inputs the query with the following sequence:
-
-  1. 2011-08-10T13:33:23+09:00: s
-  2. 2011-08-10T13:33:23+09:00: sa
-  3. 2011-08-10T13:33:24+09:00: sae
-  4. 2011-08-10T13:33:24+09:00: saer
-  5. 2011-08-10T13:33:24+09:00: saerc
-  6. 2011-08-10T13:33:25+09:00: saerch (submit!)
-  7. 2011-08-10T13:33:29+09:00: serch (correcting...)
-  8. 2011-08-10T13:33:30+09:00: search (submit!)
-
-Groonga can be learned from the input sequence by the
-following command::
-
-  load --table event_query --each 'suggest_preparer(_id, type, item, sequence, time, pair_query)'
-  [
-  {"sequence": "1", "time": 1312950803.86057, "item": "s"},
-  {"sequence": "1", "time": 1312950803.96857, "item": "sa"},
-  {"sequence": "1", "time": 1312950804.26057, "item": "sae"},
-  {"sequence": "1", "time": 1312950804.56057, "item": "saer"},
-  {"sequence": "1", "time": 1312950804.76057, "item": "saerc"},
-  {"sequence": "1", "time": 1312950805.76057, "item": "saerch", "type": "submit"},
-  {"sequence": "1", "time": 1312950809.76057, "item": "serch"},
-  {"sequence": "1", "time": 1312950810.86057, "item": "search", "type": "submit"}
-  ]
-

data/vendor/local/share/doc/groonga/ja/html/_sources/reference/suggest/introduction.txt

@@ -1,96 +0,0 @@
-.. -*- rst -*-
-
-.. highlightlang:: none
-
-Introduction
-============
-
-The suggest feature in Groonga provides the following features:
-
-* Completion
-* Correction
-* Suggestion
-
-Completion
-----------
-
-Completion helps user input. If user inputs a partial word,
-Groonga can return complete words from registered
-words.
-
-For example, there are registered words:
-
-* "groonga"
-* "complete"
-* "correction"
-* "suggest"
-
-An user inputs "co" and groonga returns "complete" and
-"correction" because they starts with "co".
-
-An user inputs "sug" and groonga returns "suggest" because
-"suggest" starts with "sug".
-
-An user inputs "ab" and groonga returns nothing because no
-word starts with "ab".
-
-Correction
-----------
-
-Correction also helps user input. If user inputs a wrong
-word, groonga can return correct words from registered
-correction pairs.
-
-For example, there are registered correction pairs:
-
-+------------+--------------+
-| wrong word | correct word |
-+============+==============+
-| grroonga   | groonga      |
-+------------+--------------+
-| gronga     | groonga      |
-+------------+--------------+
-| gronnga    | groonga      |
-+------------+--------------+
-
-An user inputs "gronga" and groonga returns "groonga" because
-"gronga" is in wrong word and corresponding correct word is
-"groonga".
-
-An user inputs "roonga" and groonga returns nothing because
-"roonga" isn't in wrong word.
-
-Suggestion
-----------
-
-Suggestion helps that user filters many found documents. If
-user inputs a query, groonga can return new queries that has
-more additional keywords from registered related query
-pairs.
-
-For example, there are registered related query pairs:
-
-+----------------------------+--------------------------+
-|          keyword           |      related query       |
-+============================+==========================+
-| groonga                    | groonga search engine    |
-+----------------------------+--------------------------+
-| search                     | Google search            |
-+----------------------------+--------------------------+
-| speed                      | groonga speed            |
-+----------------------------+--------------------------+
-
-An user inputs "groonga" and groonga returns "groonga search
-engine" because "groonga" is in keyword column and related
-query column is "groonga search engine".
-
-An user inputs "MySQL" and groonga returns nothing because
-"MySQL" isn't in keyword column values.
-
-Learning
---------
-
-The suggest feature requires registered data before using
-the feature. Those data can be registered from user inputs.
-Gronnga-suggest-httpd and groonga-suggest-learner commands
-are provided for the propose.

data/vendor/local/share/doc/groonga/ja/html/_sources/reference/suggest/suggestion.txt

@@ -1,132 +0,0 @@
-.. -*- rst -*-
-
-.. highlightlang:: none
-
-.. groonga-command
-.. % groonga-suggest-create-dataset /tmp/groonga-databases/suggestion query
-.. database: suggestion
-
-Suggestion
-==========
-
-This section describes about the following completion
-features:
-
-* How it works
-* How to use
-* How to learn
-
-How it works
-------------
-
-The suggestion feature uses a search to compute suggested
-words:
-
-  1. Cooccurrence search against learned data.
-
-Cooccurrence search
-^^^^^^^^^^^^^^^^^^^
-
-Cooccurrence search can find related words from user's
-input. It uses user submissions that will be learned
-from query logs, access logs and so on.
-
-For example, there are the following user submissions:
-
-+----------------------+
-|  query               |
-+======================+
-| search engine        |
-+----------------------+
-| web search realtime  |
-+----------------------+
-
-Groonga creates the following suggestion pairs:
-
-+----------+------------------------------------+
-|  input   |          suggested words           |
-+==========+====================================+
-|search    |search engine                       |
-+----------+------------------------------------+
-|engine    |search engine                       |
-+----------+------------------------------------+
-|web       |web search realtime                 |
-+----------+------------------------------------+
-|search    |web search realtime                 |
-+----------+------------------------------------+
-|realtime  |web search realtime                 |
-+----------+------------------------------------+
-
-Those pairs are created by the following steps:
-
-  1. Tokenizes user input query by TokenDelimit tokenizer
-     that uses a space as token delimiter. (e.g. "search
-     engine" is tokenized to two tokens "search" and
-     "engine".)
-  2. Creates a pair that is consists of a token and original
-     query for each token.
-
-If an user inputs "search" and cooccurrence search returns
-"search engine" and "web search realtime" because "search" is
-in two input columns and corresponding suggested word
-columns have "search engine" and "web search realtime".
-
-How to use
-----------
-
-.. groonga-command
-.. load --table event_query --each 'suggest_preparer(_id, type, item, sequence, time, pair_query)'
-.. [
-.. {"sequence": "1", "time": 1312950803.86057, "item": "search engine", "type": "submit"},
-.. {"sequence": "1", "time": 1312950808.86057, "item": "web search realtime", "type": "submit"}
-.. ]
-
-Groonga provides :doc:`/reference/commands/suggest` command to use
-suggestion. `--type suggest` option requests suggestion
-
-For example, here is an command to get suggestion results by
-"search":
-
-.. groonga-command
-.. include:: ../../example/reference/suggest/suggest/select.log
-.. suggest --table item_query --column kana --types suggest --frequency_threshold 1 --query search
-
-How it learns
--------------
-
-Cooccurrence search uses learned data. They are based on
-query logs, access logs and so on. To create learned data,
-groonga needs user input sequence with time stamp and user
-submit input with time stamp.
-
-For example, an user wants to search by "engine". The user
-inputs the query with the following sequence:
-
-  1. 2011-08-10T13:33:23+09:00: search engine (submit)
-  2. 2011-08-10T13:33:28+09:00: web search realtime (submit)
-
-Groonga can be learned from the submissions by the
-following command::
-
-  load --table event_query --each 'suggest_preparer(_id, type, item, sequence, time, pair_query)'
-  [
-  {"sequence": "1", "time": 1312950803.86057, "item": "search engine", "type": "submit"},
-  {"sequence": "1", "time": 1312950808.86057, "item": "web search realtime", "type": "submit"}
-  ]
-
-How to extract learning data
-----------------------------
-
-The learning data is stored into item_DATASET and pair_DATASET tables.
-By using select command for such tables, you can all extract learing data.
-
-Here is the query to extract all learning data::
-
-  select item_DATASET --limit -1
-  select pair_DATASET --filter 'freq0 > 0 || freq1 > 0 || freq2 > 0' --limit -1
-
-Without '--limit -1', you can't get all data.
-In pair table, the valid value of freq0, freq1 and freq2 column must be larger than 0.
-
-Don't execute above query via HTTP request because enourmous number of records are fetched.
- 

data/vendor/local/share/doc/groonga/ja/html/_sources/reference/tables.txt

@@ -1,216 +0,0 @@
-.. -*- rst -*-
-
-.. highlightlang:: none
-
-Tables
-======
-
-Summary
--------
-
-Table in Groonga manages relation between ID and key. Groonga provides
-four table types. They are ``TABLE_NO_KEY``, ``TABLE_HASH_KEY``,
-``TABLE_PAT_KEY`` and ``TABLE_DAT_KEY``.
-
-All tables except ``TABLE_NO_KEY`` provides both fast ID search by key
-and fast key search by ID. ``TABLE_NO_KEY`` doesn't support
-key. ``TABLE_NO_KEY`` only manages ID. So ``TABLE_NO_KEY`` doesn't
-provides ID search and key search.
-
-Characteristics
----------------
-
-Here is a chracteristic table of all tables in Groonga. (``TABLE_``
-prefix is omitted in the table.)
-
-.. list-table:: Characteristics of all tables
-   :header-rows: 1
-
-   * - Item
-     - ``NO_KEY``
-     - ``HASH_KEY``
-     - ``PAT_KEY``
-     - ``DAT_KEY``
-   * - Data structure
-     - Array
-     - Hash table
-     - Patricia trie
-     - Double array trie
-   * - ID support
-     - o
-     - o
-     - o
-     - o
-   * - Key support
-     - x
-     - o
-     - o
-     - o
-   * - Value support
-     - o
-     - o
-     - o
-     - x
-   * - Key -> ID speed
-
-       * o: fast
-       * x: slow
-     - \-
-     - oo
-     - x
-     - o
-   * - Update speed
-
-       * o: fast
-       * x: slow
-     - ooo
-     - o
-     - o
-     - x
-   * - Size
-
-       * o: small
-       * x: large
-     - ooo
-     - o
-     - oo
-     - x
-   * - Key update
-     - \-
-     - x
-     - x
-     - o
-   * - Common prefix search
-     - \-
-     - x
-     - o
-     - o
-   * - Predictive search
-     - \-
-     - x
-     - o
-     - o
-   * - Range search
-     - \-
-     - x
-     - o
-     - o
-   * - The maximum one key size
-     - \-
-     - 4KiB
-     - 4KiB
-     - 4KiB
-   * - The maximum total size of keys
-     - \-
-     - 4GiB or 1TiB (by specifying ``KEY_LARGE`` flag to
-       :ref:`table-create-flags`)
-     - 4GiB
-     - 4GiB
-   * - The maximum number of records
-     - 1,073,741,815 (2 :sup:`30` - 9)
-     - 536,870,912 (2 :sup:`29`)
-     - 1,073,741,823 (2 :sup:`30` - 1)
-     - 268,435,455 (2 :sup:`28` - 1)
-
-.. _table-no-key:
-
-``TABLE_NO_KEY``
-^^^^^^^^^^^^^^^^
-
-``TABLE_NO_KEY`` is very fast and very small but it doesn't support
-key. ``TABLE_NO_KEY`` is a only table that doesn't support key.
-
-You cannot use ``TABLE_NO_KEY`` for lexicon for fulltext search
-because lexicon stores tokens as key. ``TABLE_NO_KEY`` is useful for
-no key records such as log.
-
-.. _table-hash-key:
-
-``TABLE_HASH_KEY``
-^^^^^^^^^^^^^^^^^^
-
-``TABLE_HASH_KEY`` is fast but it doesn't support advanced search
-functions such as common prefix search and predictive search.
-
-``TABLE_HASH_KEY`` is useful for index for exact search such as tag
-search.
-
-.. _table-pat-key:
-
-``TABLE_PAT_KEY``
-^^^^^^^^^^^^^^^^^
-
-``TABLE_PAT_KEY`` is small and supports advanced search functions.
-
-``TABLE_PAT_KEY`` is useful for lexicon for fulltext search and
-index for range search.
-
-.. _table-dat-key:
-
-``TABLE_DAT_KEY``
-^^^^^^^^^^^^^^^^^
-
-``TABLE_DAT_KEY`` is fast and supports key update but it is large. It
-is not suitable for storing many records. ``TABLE_DAT_KEY`` is a only
-table that supports key update.
-
-``TABLE_DAT_KEY`` is used in Groonga database. Groonga database needs
-to convert object name such as ``ShortText``, ``TokenBigram`` and
-table names to object ID. And Groonga database needs to rename object
-name. Those features are implemented by ``TABLE_DAT_KEY``. The number
-of objects is small. So large data size demerit of ``TABLE_DAT_KEY``
-can be ignored.
-
-Record ID
----------
-
-Record ID is assigned automatically. You cannot assign record ID.
-
-Record ID of deleted record may be reused.
-
-Valid record ID range is between 1 and 1073741823. (1 and 1073741823
-are valid IDs.)
-
-Persistent table and temporary table
-------------------------------------
-
-Table is persistent table or temporary table.
-
-Persistent table
-^^^^^^^^^^^^^^^^
-
-Persistent table is named and registered to database. Records in
-persistent table aren't deleted after closing table or
-database.
-
-Persistent table can be created by
-:doc:`/reference/commands/table_create` command.
-
-Temporary table
-^^^^^^^^^^^^^^^
-
-Temporary table is anonymous. Records in temporary table are deleted
-after closing table. Temporary table is used to store search result,
-sort result, group (drilldown) result and so on. ``TABLE_HASH_KEY`` is
-used for search result and group result. ``TABLE_NO_KEY`` is used for
-sort result.
-
-Limitations
------------
-
-The max number of records is 268435455. You cannot add 268435456 or
-more records in a table.
-
-The max number of a key size is 4096byte. You cannot use 4097byte or
-larger key. You can use column instead of key for 4097byte or larger
-size data. ``Text`` and ``LargeText`` types supports 4097byte or
-larger size data.
-
-The max number of total key size is 4GiB. You need to split a table,
-split a database (sharding) or reduce each key size to handle 4GiB or
-more larger total key size.
-
-See also
---------
-
-* :doc:`/reference/commands/table_create`