Skip to content



Before you create an index, make sure that the relative tag or edge type is created. For how to create tags or edge types, see CREATE TAG and CREATE EDGE.

For how to create full-text indexes, see Deploy full-text index.

Must-read for using indexes

The concept and using restrictions of indexes are comparatively complex. Before you use indexes, you must read the following sections carefully.

You can use CREATE INDEX to add native indexes for the existing tags, edge types, or properties. They are usually called as tag indexes, edge type indexes, and property indexes.

  • Tag indexes and edge type indexes apply to queries related to the tag and the edge type, but do not apply to queries that are based on certain properties on the tag. For example, you can use LOOKUP to retrieve all the vertices with the tag player.
  • Property indexes apply to property-based queries. For example, you can use the age property to retrieve the VID of all vertices that meet age == 19.

If a property index i_TA is created for the property A of the tag T and i_T for the tag T, the indexes can be replaced as follows (the same for edge type indexes):

  • The query engine can use i_TA to replace i_T.
  • In the MATCH and LOOKUP statements, i_T may replace i_TA for querying properties.

    Legacy version compatibility

    In previous releases, the tag or edge type index in the LOOKUP statement cannot replace the property index for property queries.

Although the same results can be obtained by using alternative indexes for queries, the query performance varies according to the selected index.


Indexes can dramatically reduce the write performance. The performance can be greatly reduced. DO NOT use indexes in production environments unless you are fully aware of their influences on your service.

Long indexes decrease the scan performance of the Storage Service and use more memory. We suggest that you set the indexing length the same as that of the longest string to be indexed. For variable-length string-type properties, the longest index length is 256 bytes; for fixed-length string-type properties, the longest index length is the length of the index itself.


If you must use indexes, we suggest that you:

  1. Import the data into NebulaGraph.

  2. Create indexes.

  3. Rebuild indexes.

  4. After the index is created and the data is imported, you can use LOOKUP or MATCH to retrieve the data. You do not need to specify which indexes to use in a query, NebulaGraph figures that out by itself.


If you create an index before importing the data, the importing speed will be extremely slow due to the reduction in the write performance.

Keep --disable_auto_compaction = false during daily incremental writing.

The newly created index will not take effect immediately. Trying to use a newly created index (such as LOOKUP orREBUILD INDEX) may fail and return can't find xxx in the space because the creation is implemented asynchronously. To make sure the follow-up operations work as expected, Wait for two heartbeat cycles, i.e., 20 seconds. To change the heartbeat interval, modify the heartbeat_interval_secs in the configuration files for all services.


After creating a new index, or dropping the old index and creating a new one with the same name again, you must REBUILD INDEX. Otherwise, these data cannot be returned in the MATCH and LOOKUP statements.


CREATE {TAG | EDGE} INDEX [IF NOT EXISTS] <index_name> ON {<tag_name> | <edge_name>} ([<prop_name_list>]) [COMMENT '<comment>'];
Parameter Description
TAG | EDGE Specifies the index type that you want to create.
IF NOT EXISTS Detects if the index that you want to create exists. If it does not exist, a new one will be created.
<index_name> 1. The name of the index. It must be unique in a graph space. A recommended way of naming is i_tagName_propName.
2. By default, the name only supports 1-4 byte UTF-8 encoded characters, including English letters (case sensitive), numbers, Chinese characters, etc. However, it cannot include special characters other than the underscore (_), and cannot start with a number.
3. To use special characters, reserved keywords, or start with a number, quote the entire name with backticks (`) and do not include periods (.) within the pair of backticks (`). For more information, see Keywords and reserved words.
1. If you name an index in Chinese and encounter a SyntaxError, you need to quote the Chinese characters with backticks (`).
2. To include a backtick (`) in an index name, use a backslash to escape the backtick, such as \`; to include a backslash, the backslash itself also needs to be escaped, such as \ .
<tag_name> | <edge_name> Specifies the name of the tag or edge associated with the index.
<prop_name_list> To index a variable-length string property, you must use prop_name(length) to specify the index length, and the maximum index length is 256. To index a tag or an edge type, ignore the prop_name_list.
COMMENT The remarks of the index. The maximum length is 256 bytes. By default, there will be no comments on an index.

Create tag/edge type indexes

nebula> CREATE TAG INDEX IF NOT EXISTS player_index on player();
nebula> CREATE EDGE INDEX IF NOT EXISTS follow_index on follow();

After indexing a tag or an edge type, you can use the LOOKUP statement to retrieve the VID of all vertices with the tag, or the source vertex ID, destination vertex ID, and ranks of all edges with the edge type. For more information, see LOOKUP.

Create single-property indexes

nebula> CREATE TAG INDEX IF NOT EXISTS player_index_0 on player(name(10));

The preceding example creates an index for the name property on all vertices carrying the player tag. This example creates an index using the first 10 characters of the name property.

# To index a variable-length string property, you need to specify the index length.
nebula> CREATE TAG IF NOT EXISTS var_string(p1 string);
nebula> CREATE TAG INDEX IF NOT EXISTS var ON var_string(p1(10));

# To index a fixed-length string property, you do not need to specify the index length.
nebula> CREATE TAG IF NOT EXISTS fix_string(p1 FIXED_STRING(10));
nebula> CREATE TAG INDEX IF NOT EXISTS fix ON fix_string(p1);
nebula> CREATE EDGE INDEX IF NOT EXISTS follow_index_0 on follow(degree);

Create composite property indexes

An index on multiple properties on a tag (or an edge type) is called a composite property index.

nebula> CREATE TAG INDEX IF NOT EXISTS player_index_1 on player(name(10), age);


Creating composite property indexes across multiple tags or edge types is not supported.


NebulaGraph follows the left matching principle to select indexes.

Last update: December 28, 2023