rroonga 2.1.2-x86-mingw32 → 2.1.3-x86-mingw32

data/vendor/local/share/doc/groonga/source/spec.txt

@@ -1,12 +0,0 @@
-.. -*- rst -*-
-
-.. highlightlang:: none
-
-Specification
-=============
-
-.. toctree::
-   :maxdepth: 1
-   :glob:
-
-   spec/*

data/vendor/local/share/doc/groonga/source/suggest/completion.txt

@@ -1,195 +0,0 @@
-.. -*- rst -*-
-
-.. highlightlang:: none
-
-.. groonga-command
-.. % groonga-suggest-create-dataset /tmp/groonga-databases/completion query
-.. database: completion
-
-Completion
-==========
-
-This section describes about the following completion
-features:
-
-* How it works
-* How to use
-* How to learn
-
-How it works
-------------
-
-The completion feature uses three searches to compute
-completed words:
-
-  1. Prefix RK search against registered words.
-  2. Cooccurrence search against learned data.
-  3. Prefix search against registered words. (optional)
-
-Prefix RK search
-^^^^^^^^^^^^^^^^
-
-RK means Romaji and Katakana. Prefix RK search can find
-registered words that start with user's input by romaji,
-katakana or hiragana. It's useful for searching in Japanese.
-
-For example, there is a registered word "日本". And "ニホン"
-(it must be katakana) is registered as its reading. An user
-can find "日本" by "ni", "二" or "に".
-
-Cooccurrence search
-^^^^^^^^^^^^^^^^^^^
-
-Cooccurrence search can find registered words from user's
-partial input. It uses user input sequences that will be
-learned from query logs, access logs and so on.
-
-For example, there is the following user input sequence:
-
-+----------+----------+
-|  input   |  submit  |
-+==========+==========+
-|s         |no        |
-+----------+----------+
-|se        |no        |
-+----------+----------+
-|sea       |no        |
-+----------+----------+
-|sear      |no        |
-+----------+----------+
-|searc     |no        |
-+----------+----------+
-|search    |yes       |
-+----------+----------+
-|e         |no        |
-+----------+----------+
-|en        |no        |
-+----------+----------+
-|eng       |no        |
-+----------+----------+
-|engi      |no        |
-+----------+----------+
-|engin     |no        |
-+----------+----------+
-|engine    |no        |
-+----------+----------+
-|enginen   |no (typo!)|
-+----------+----------+
-|engine    |yes       |
-+----------+----------+
-
-Groonga creates the following completion pairs:
-
-+----------+--------------------+
-|  input   |   completed word   |
-+==========+====================+
-|s         |search              |
-+----------+--------------------+
-|se        |search              |
-+----------+--------------------+
-|sea       |search              |
-+----------+--------------------+
-|sear      |search              |
-+----------+--------------------+
-|searc     |search              |
-+----------+--------------------+
-|e         |engine              |
-+----------+--------------------+
-|en        |engine              |
-+----------+--------------------+
-|eng       |engine              |
-+----------+--------------------+
-|engi      |engine              |
-+----------+--------------------+
-|engin     |engine              |
-+----------+--------------------+
-|engine    |engine              |
-+----------+--------------------+
-|enginen   |engine              |
-+----------+--------------------+
-
-All user not-submitted inputs (e.g. "s", "se" and so on)
-before each an user submission maps to the submitted input
-(e.g. "search").
-
-To be precise, this description isn't correct because it
-omits about time stamp. Groonga doesn't case about "all user
-not-submitted inputs before each an user
-submission". Groonga just case about "all user not-submitted
-inputs within a minute from an user submission before each
-an user submission". Groonga doesn't treat user inputs
-before a minute ago.
-
-If an user inputs "sea" and cooccurrence search returns
-"search" because "sea" is in input column and corresponding
-completed word column value is "search".
-
-Prefix search
-^^^^^^^^^^^^^
-
-Prefix search can find registered word that start with
-user's input. This search doesn't care about romaji,
-katakana and hiragana not like Prefix RK search.
-
-This search isn't always ran. It's just ran when it's
-requested explicitly or both prefix RK search and
-cooccurrence search return nothing.
-
-For example, there is a registered word "search". An user
-can find "search" by "s", "se", "sea", "sear", "searc" and
-"search".
-
-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": "e"},
-.. {"sequence": "1", "time": 1312950803.96857, "item": "en"},
-.. {"sequence": "1", "time": 1312950804.26057, "item": "eng"},
-.. {"sequence": "1", "time": 1312950804.56057, "item": "engi"},
-.. {"sequence": "1", "time": 1312950804.76057, "item": "engin"},
-.. {"sequence": "1", "time": 1312950805.86057, "item": "engine", "type": "submit"}
-.. ]
-
-Groonga provides :doc:`/reference/commands/suggest` command to use
-completion. `--type complete` option requests completion.
-
-For example, here is an command to get completion results by
-"en":
-
-.. groonga-command
-.. include:: ../example/completion-1.log
-.. suggest --table item_query --column kana --types complete --frequency_threshold 1 --query en
-
-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: e
-  2. 2011-08-10T13:33:23+09:00: en
-  3. 2011-08-10T13:33:24+09:00: eng
-  4. 2011-08-10T13:33:24+09:00: engi
-  5. 2011-08-10T13:33:24+09:00: engin
-  6. 2011-08-10T13:33:25+09:00: engine (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": "e"},
-  {"sequence": "1", "time": 1312950803.96857, "item": "en"},
-  {"sequence": "1", "time": 1312950804.26057, "item": "eng"},
-  {"sequence": "1", "time": 1312950804.56057, "item": "engi"},
-  {"sequence": "1", "time": 1312950804.76057, "item": "engin"},
-  {"sequence": "1", "time": 1312950805.86057, "item": "engine", "type": "submit"}
-  ]

data/vendor/local/share/doc/groonga/source/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/correction-1.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/source/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/source/suggest/suggestion.txt

@@ -1,115 +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/suggestion-1.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"}
-  ]

data/vendor/local/share/doc/groonga/source/suggest/tutorial.txt

@@ -1,8 +0,0 @@
-.. -*- rst -*-
-
-.. highlightlang:: none
-
-Tutorial
-========
-
-TODO...

data/vendor/local/share/doc/groonga/source/suggest.txt

@@ -1,17 +0,0 @@
-.. -*- rst -*-
-
-.. highlightlang:: none
-
-Suggest
-=======
-
-Groonga has the suggest feature. This section describes how to use it and how it works.
-
-.. toctree::
-   :maxdepth: 2
-
-   suggest/introduction
-   suggest/tutorial
-   suggest/completion
-   suggest/correction
-   suggest/suggestion