• Downloads
  • Services
  • Resources

    • Documentation
    • Cheatsheets
    • Courses
    • Free Config Review
    • Blog
    • Forum
  • About

    • Manticore Search
    • Clients
  • Contact
  • ☝ Introduction
  • ❗ Read this first
  • ✔ Installation
    • Docker
    • RedHat and Centos
    • Debian and Ubuntu
    • MacOS
    • Windows
    • Old Linuxes
    • Compiling from sources
    • Migration from Sphinx
  • ⚡ Quick start guide
  • ✔ Starting the server
    • In Linux
    • Manually
    • In Docker
    • In Windows
    • In MacOS
  • ▪️ Creating a table
    • Data types
      • Row-wise and columnar attribute storages
    • Creating a local table
      • ✔ Real-time table
      • Plain table
      • Plain and real-time table settings
      • Percolate table
      • Template table
    • NLP and tokenization
      • Data tokenization
      • Supported languages
      • CJK
      • Low-level tokenization
      • Wildcard searching settings
      • Ignoring stop words
      • Word forms
      • Exceptions
      • Morphology
      • Advanced HTML tokenization
    • Creating a distributed table
      • Creating a local distributed table
      • Remote tables
  • ▪️ Listing tables
  • ▪️ Deleting a table
  • ▪️ Emptying a table
  • ▪️ Creating a cluster
    • Adding a new node
    • Remote nodes
      • Mirroring
      • Load balancing
    • Setting up replication
      • Creating a replication cluster
      • Joining a replication cluster
      • Deleting a replication cluster
      • Adding and removing a table from a replication cluster
      • Managing replication nodes
      • Replication cluster status
      • Restarting a cluster
      • Cluster recovery
  • ✔ Connecting to the server
    • MySQL protocol
    • HTTP
    • SQL over HTTP
  • ▪️ Data creation and modification
    • ▪️ Adding documents to a table
      • ✔ Adding documents to a real-time table
      • Adding rules to a percolate table
    • ▪️ Adding data from external storages
      • Plain tables creation
      • Fetching from databases
        • Introduction
        • Database connection
        • Execution of fetch queries
        • Processing fetched data
        • Ranged queries
      • Fetching from XML stream
      • Fetching from CSV,TSV
      • Main+delta schema
      • Adding data from tables
        • Merging tables
        • Killlists in plain tables
        • Attaching a plain table to RT table
        • Importing RT table
      • Rotating a table
    • ✔ Updating documents
      • REPLACE vs UPDATE
      • REPLACE
      • UPDATE
    • ▪️ Deleting documents
    • ▪️ Transactions
  • ✔ Searching
    • Intro
    • Full-text matching
      • Basic usage
      • Operators
      • Escaping
      • Search profiling
      • Boolean optimization
    • Search results
    • Filters
    • Expressions
    • Search options
    • Highlighting
    • Sorting and ranking
    • Pagination
    • Distributed searching
    • Multi-queries
    • Sub-selects
    • Grouping
    • Faceted search
    • Geo search
    • Percolate query
    • Autocomplete
    • Spell correction
    • Query cache
    • Collations
    • Cost-based optimizer
  • ▪️ Updating table schema and settings
  • ▪️ Functions
    • Mathematical functions
    • Searching and ranking functions
    • Type casting functions
    • Functions to handle arrays and conditions
    • Date and time functions
    • Geo-spatial functions
    • String functions
    • Other functions
  • ▪️ Securing and compacting a table
    • Backup and restore
    • Few words about RT table structure
    • Flushing RAM chunk to a new disk chunk
    • Flushing RT table to disk
    • Compacting a table
    • Isolation during flushing and merging
    • Freezing a table
    • Flushing attributes
    • Flushing hostnames
  • ▪️ Security
    • SSL
    • Read-only
  • ▪️ Logging
    • Query logging
    • Server logging
    • Binary logging
    • Docker logging
    • Rotating query and server logs
  • ▪️ Node info and management
    • Node status
    • SHOW META
    • SHOW THREADS
    • SHOW QUERIES
    • KILL
    • SHOW WARNINGS
    • SHOW VARIABLES
    • SHOW COLLATION
    • Profiling
      • Query profiling
      • Query plan
    • Table settings and status
      • SHOW TABLE STATUS
      • SHOW TABLE SETTINGS
  • ▪️ Server settings
    • Searchd
    • Common
    • Special suffixes
    • Scripted configuration
    • Comments
    • Inheritance of table and source declarations
    • Setting variables online
  • ▪️ Extensions
    • SphinxSE
    • FEDERATED
    • UDFs and Plugins
      • Listing plugins
      • UDF
        • Creating a function
        • Deleting a function
      • Plugins
        • Creating a plugin
        • Deleting a plugin
        • Reloading plugins
        • Ranker plugins
        • Token filter plugins
  • ▪️ Miscellaneous tools
  • ▪️ OpenAPI specification
  • ▪️ Telemetry
  • ▪️ Changelog
  • 🐞 Reporting bugs
  • 📖 References
    • Previous versions

Read this first

About this manual

The manual is arranged as a reflection of the most likely way you would use Manticore:

  • starting from some basic information about it and how to install and connect
  • through some essential things like adding documents and running searches
  • to some performance optimization tips and tricks and extending Manticore with help of plugins and custom functions
Do not skip ✔️

Key sections of the manual are marked with sign ✔️ in the menu for your convenience since their corresponding functionality is most used. If you are new to Manticore we highly recommend to not skip them.

Quick start guide

If you are looking for a quick understanding of how Manticore works in general ⚡ Quick start guide section should be good to read.

Using examples

Each query example has a little icon 📋 in the top-right corner:

Copy example

You can use it to copy examples to clipboard. If the query is an HTTP request it will be copied as a CURL command. You can configure the host/port if you press ⚙️.

Search in this manual

We love search and we've made our best to make searching in this manual as convenient as possible. Of course it's backed by Manticore Search. Besides using the search bar which requires opening the manual first there is a very easy way to find something by just opening mnt.cr/your-search-keyword :

mnt.cr quick manual search

Best practices

There are few things you need to understand about Manticore Search that can help you follow the best practices of using it.

Real-time table vs plain table

  • Real-time table allows adding, updating and deleting documents with immediate availability of the changes.
  • Plain table is a mostly immutable data structure and a basic element used by real-time tables. Plain table stores a set of documents, their common dictionary and indexation settings. One real-time table can consist of multiple plain tables (chunks), but besides that Manticore provides direct access to building plain tables using tool indexer. It makes sense when your data is mostly immutable, therefore you don't need a real-time table for that.

Real-time mode vs plain mode

Manticore Search works in two modes:

  • Real-time mode (RT mode). This is a default one and allows to manage your data schema imperatively:
    • allows managing your data schema online using SQL commands CREATE/ALTER/DROP TABLE and their equivalents in non-SQL clients
    • in the configuration file you need to define only server-related settings including data_dir
  • Plain mode allows to define your data schemas in a configuration file, i.e. provides declarative kind of schema management. It makes sense in three cases:
    • when you only deal with plain tables
    • or when your data schema is very stable and you don't need replication (as it's available only in the RT mode)
    • when you have to make your data schema portable (e.g. for easier deployment of it on a new server)

You cannot combine the 2 modes and need to decide which one you want to follow by specifying data_dir in your configuration file (which is the default behaviour). If you are unsure our recommendation is to follow the RT mode as if even you need a plain table you can build it with a separate plain table config and import to your main Manticore instance.

Real-time tables can be used in both RT and plain modes. In the RT mode a real-time table is defined with a CREATE TABLE command, while in the plain mode it is defined in the configuration file. Plain (offline) tables are supported only in the plain mode. Plain tables cannot be created in the RT mode, but existing plain tables made in the plain mode can be converted to real-time tables and imported in the RT mode.

SQL vs JSON

Manticore provides multiple ways and interfaces to manage your schemas and data, but the two main are:

  • SQL. This is a native Manticore's language which enables all Manticore's functionality. The best practice is to use SQL to:
    • manage your schemas and do other DBA routines as it's the easiest way to do that
    • design your queries as SQL is much closer to natural language than the JSON DSL which is important when you design something new. You can use Manticore SQL via any MySQL client or /sql.
  • JSON. Most functionality is also available via JSON domain specific language. This is especially useful when you integrate Manticore with your application as with JSON you can do it more programmatically than with SQL. The best practice is to first explore how to do something via SQL and then use JSON to integrate it into your application.
Installation

Installation

Read this first Docker