RubyGems - rroonga - Versions diffs - 7.0.2-x64-mingw32 → 7.1.1-x64-mingw32 - Mend

rroonga 7.0.2-x64-mingw32 → 7.1.1-x64-mingw32

Files changed (1237) hide show

data/vendor/local/share/doc/groonga/ja/html/_sources/reference/indexing.txt DELETED Viewed

@@ -1,112 +0,0 @@
-.. -*- rst -*-
-.. highlightlang:: none
-.. groonga-command
-.. database: indexing
-Indexing
-========
-Groonga supports both online index construction and offline
-index construction since 2.0.0.
-.. _online-index-construction:
-Online index construction
--------------------------
-In online index construction, registered documents can be
-searchable quickly while indexing. But indexing requires
-more cost rather than indexing by offline index
-construction.
-Online index construction is suitable for a search system
-that values freshness. For example, a search system for
-tweets, news, blog posts and so on will value
-freshness. Online index construction can make fresh
-documents searchable and keep searchable while indexing.
-.. _offline-index-construction:
-Offline index construction
---------------------------
-In offline index construction, indexing cost is less than
-indexing cost by online index construction. Indexing time
-will be shorter. Index will be smaller. Resources required
-for indexing will be smaller. But a registering document
-cannot be searchable until all registered documents are
-indexed.
-Offline index construction is suitable for a search system
-that values less required resources. If a search system
-doesn't value freshness, offline index construction will be
-suitable. For example, a reference manual search system
-doesn't value freshness because a reference manual will be
-updated only at a release.
-How to use
-----------
-Groonga uses online index construction by default. We
-register a document, we can search it quickly.
-Groonga uses offline index construction by adding an index
-to a column that already has data.
-We define a schema:
-.. groonga-command
-.. include:: ../example/reference/indexing-schema.log
-.. table_create Tweets TABLE_NO_KEY
-.. column_create Tweets content COLUMN_SCALAR ShortText
-.. table_create Lexicon TABLE_HASH_KEY ShortText --default_tokenizer TokenBigram --normalizer NormalizerAuto
-We register data:
-.. groonga-command
-.. include:: ../example/reference/indexing-data.log
-.. load --table Tweets
-.. [
-.. {"content":"Hello!"},
-.. {"content":"I just start it!"},
-.. {"content":"I'm sleepy... Have a nice day... Good night..."}
-.. ]
-We can search with sequential search when we don't have index:
-.. groonga-command
-.. include:: ../example/reference/indexing-search-without-index.log
-.. select Tweets --match_columns content --query 'good nice'
-We create index for ``Tweets.content``. Already registered
-data in ``Tweets.content`` are indexed by offline index
-construction:
-.. groonga-command
-.. include:: ../example/reference/indexing-offline-index-construction.log
-.. column_create Lexicon tweet COLUMN_INDEX|WITH_POSITION Tweets content
-We search with index. We get a matched record:
-.. groonga-command
-.. include:: ../example/reference/indexing-search-after-offline-index-construction.log
-.. select Tweets --match_columns content --query 'good nice'
-We register data again. They are indexed by online index
-construction:
-.. groonga-command
-.. include:: ../example/reference/indexing-online-index-construction.log
-.. load --table Tweets
-.. [
-.. {"content":"Good morning! Nice day."},
-.. {"content":"Let's go shopping."}
-.. ]
-We can also get newly registered records by searching:
-.. groonga-command
-.. include:: ../example/reference/indexing-search-after-online-index-construction.log
-.. select Tweets --match_columns content --query 'good nice'

data/vendor/local/share/doc/groonga/ja/html/_sources/reference/log.txt DELETED Viewed

@@ -1,236 +0,0 @@
-.. -*- rst -*-
-.. highlightlang:: none
-Log
-===
-Groonga has two log files. They are process log and query
-log. Process log is for all of :doc:`executables/groonga`
-works. Query log is just for query processing.
-.. _process-log:
-Process log
------------
-Process log is enabled by default. Log path can be customized by
-:option:`groonga --log-path` option. Each log has its log level. If a
-log is smaller than Groonga process' log level, it's not logged. Log
-level can be customized by :option:`groonga -l` or
-:doc:`commands/log_level`.
-Format
-^^^^^^
-Process log uses the following format::
-  #{TIME_STAMP}|#{L}| #{MESSAGE}
-Some multi-process based applications such as
-:doc:`/reference/executables/groonga-httpd` and `PGroonga
-<https://pgroonga.github.io/>`_ use the following format::
-  #{TIME_STAMP}|#{L}|#{PID}: #{MESSAGE}
-TIME_STAMP
-  It's time stamp uses the following format::
-    YYYY-MM-DD hh:mm:ss.SSSSSS
-  YYYY
-    Year with four digits.
-  MM
-    Month with two digits.
-  DD
-    Day with two digits.
-  hh
-    Hour with two digits.
-  mm
-    Minute with two digits.
-  ss
-    Second with two digits.
-  SSSSSS
-    Microsecond with six digits.
-  Example::
-    2011-07-05 06:25:18.345734
-L
-  Log level with a character. Here is a character and log
-  level map.
-  E
-    Emergency
-  A
-    Alert
-  C
-    Critical
-  e
-    Error
-  w
-    Warning
-  n
-    Notification
-  i
-    Information
-  d
-    Debug
-  \-
-    Dump
-  Example::
-    E
-PID
-  The process ID.
-  Example::
-    1129
-MESSAGE
-  Details about the log with free format.
-  Example::
-    log opened.
-Example::
-  2011-07-05 08:35:09.276421|n| grn_init
-  2011-07-05 08:35:09.276553|n| RLIMIT_NOFILE(4096,4096)
-Example with PID::
-  2011-07-05 08:35:09.276421|n|1129: grn_init
-  2011-07-05 08:35:09.276553|n|1129: RLIMIT_NOFILE(4096,4096)
-.. _query-log:
-Query log
----------
-Query log is disabled by default. It can be enabled by
-:option:`groonga --query-log-path` option.
-Format
-^^^^^^
-Query log uses the following formats::
-  #{TIME_STAMP}|#{MESSAGE}
-  #{TIME_STAMP}|#{ID}|>#{QUERY}
-  #{TIME_STAMP}|#{ID}|:#{ELAPSED_TIME} #{PROGRESS}
-  #{TIME_STAMP}|#{ID}|<#{ELAPSED_TIME} #{RETURN_CODE}
-TIME_STAMP
-  It's time stamp uses the following format::
-    YYYY-MM-DD hh:mm:ss.SSSSSS
-  YYYY
-    Year with four digits.
-  MM
-    Month with two digits.
-  DD
-    Day with two digits.
-  hh
-    Hour with two digits.
-  mm
-    Minute with two digits.
-  ss
-    Second with two digits.
-  SSSSSS
-    Microsecond with six digits.
-  Example::
-    2011-07-05 06:25:18.345734
-ID
-  ID of a thread. Groonga process creates threads to process
-  requests concurrently. Each thread outputs some logs for a
-  request. This ID can be used to extract a log sequence by
-  a thread.
-  Example::
-    45ea3034
->
-  A character that indicates query is started.
-:
-  A character that indicates query is processing.
-<
-  A character that indicates query is finished.
-MESSAGE
-  Details about the log with free format.
-  Example::
-    query log opened.
-QUERY
-  A query to be processed.
-  Example::
-    select users --match_columns hobby --query music
-ELAPSED_TIME
-  Elapsed time in nanoseconds since query is started.
-  Example::
-    000000000075770
-    (It means 75,770 nanoseconds.)
-PROGRESS
-  A processed work at the time.
-  Example::
-    select(313401)
-    (It means that 'select' is processed and 313,401 records are remained.)
-RETURN_CODE
-  A return code for the query.
-  Example::
-    rc=0
-    (It means return code is 0. 0 means GRN_SUCCESS.)
-Example::
-  2011-07-05 06:25:19.458756|45ea3034|>select Properties --limit 0
-  2011-07-05 06:25:19.458829|45ea3034|:000000000072779 select(19)
-  2011-07-05 06:25:19.458856|45ea3034|:000000000099998 output(0)
-  2011-07-05 06:25:19.458875|45ea3034|<000000000119062 rc=0
-  2011-07-05 06:25:19.458986|45ea3034|>quit

data/vendor/local/share/doc/groonga/ja/html/_sources/reference/normalizers.txt DELETED Viewed

@@ -1,133 +0,0 @@
-.. -*- rst -*-
-.. highlightlang:: none
-.. groonga-command
-.. database: normalisers
-Normalizers
-===========
-Summary
--------
-Groonga has normalizer module that normalizes text. It is used when
-tokenizing text and storing table key. For example, ``A`` and ``a``
-are processed as the same character after normalization.
-Normalizer module can be added as a plugin. You can customize text
-normalization by registering your normalizer plugins to Groonga.
-A normalizer module is attached to a table. A table can have zero or
-one normalizer module. You can attach a normalizer module to a table
-by :ref:`table-create-normalizer` option in
-:doc:`/reference/commands/table_create`.
-Here is an example ``table_create`` that uses ``NormalizerAuto``
-normalizer module:
-.. groonga-command
-.. include:: ../example/reference/normalizers/example-table-create.log
-.. table_create Dictionary TABLE_HASH_KEY ShortText --normalizer NormalizerAuto
-.. note::
-   Groonga 2.0.9 or earlier doesn't have ``--normalizer`` option in
-   ``table_create``. ``KEY_NORMALIZE`` flag was used instead.
-   You can open an old database by Groonga 2.1.0 or later. An old
-   database means that the database is created by Groonga 2.0.9 or
-   earlier. But you cannot open the opened old database by Groonga
-   2.0.9 or earlier. Once you open the old database by Groonga 2.1.0
-   or later, ``KEY_NORMALIZE`` flag information in the old database is
-   converted to normalizer information. So Groonga 2.0.9 or earlier
-   cannot find ``KEY_NORMALIZE`` flag information in the opened old
-   database.
-Keys of a table that has a normalizer module are normalized:
-.. groonga-command
-.. include:: ../example/reference/normalizers/example-load.log
-.. load --table Dictionary
-.. [
-.. {"_key": "Apple"},
-.. {"_key": "black"},
-.. {"_key": "COLOR"}
-.. ]
-.. select Dictionary
-``NormalizerAuto`` normalizer normalizes a text as a downcased text.
-For example, ``"Apple"`` is normalized to ``"apple"``, ``"black"`` is
-normalized to ``"black"`` and ``"COLOR"`` is normalized to
-``"color"``.
-If a table is a lexicon for fulltext search, tokenized tokens are
-normalized. Because tokens are stored as table keys. Table keys are
-normalized as described above.
-Built-in normalizers
---------------------
-Here is a list of built-in normalizers:
-  * ``NormalizerAuto``
-  * ``NormalizerNFKC51``
-.. _normalizer-auto:
-``NormalizerAuto``
-^^^^^^^^^^^^^^^^^^
-Normally you should use ``NormalizerAuto``
-normalizer. ``NormalizerAuto`` was the normalizer for Groonga 2.0.9 or
-earlier. ``KEY_NORMALIZE`` flag in ``table_create`` on Groonga 2.0.9
-or earlier equals to ``--normalizer NormalizerAuto`` option in
-``table_create`` on Groonga 2.1.0 or later.
-``NormalizerAuto`` supports all encoding. It uses Unicode NFKC
-(Normalization Form Compatibility Composition) for UTF-8 encoding
-text. It uses encoding specific original normalization for other
-encodings. The results of those original normalization are similar to
-NFKC.
-For example, half-width katakana (such as U+FF76 HALFWIDTH KATAKANA
-LETTER KA) + half-width katakana voiced sound mark (U+FF9E HALFWIDTH
-KATAKANA VOICED SOUND MARK) is normalized to full-width katakana with
-voiced sound mark (U+30AC KATAKANA LETTER GA). The former is two
-characters but the latter is one character.
-Here is an example that uses ``NormalizerAuto`` normalizer:
-.. groonga-command
-.. include:: ../example/reference/normalizers/normalizer-auto.log
-.. table_create NormalLexicon TABLE_HASH_KEY ShortText --normalizer NormalizerAuto
-.. _normalizer-nfkc51:
-``NormalizerNFKC51``
-^^^^^^^^^^^^^^^^^^^^
-``NormalizerNFKC51`` normalizes texts by Unicode NFKC (Normalization
-Form Compatibility Composition) for Unicode version 5.1. It supports
-only UTF-8 encoding.
-Normally you don't need to use ``NormalizerNFKC51`` explicitly. You can
-use ``NormalizerAuto`` instead.
-Here is an example that uses ``NormalizerNFKC51`` normalizer:
-.. groonga-command
-.. include:: ../example/reference/normalizers/normalizer-nfkc51.log
-.. table_create NFKC51Lexicon TABLE_HASH_KEY ShortText --normalizer NormalizerNFKC51
-Additional normalizers
-----------------------
-There are additional normalizers:
-  * `groonga-normalizer-mysql <https://github.com/groonga/groonga-normalizer-mysql>`_
-See also
---------
-* :doc:`/reference/commands/table_create`