What are the limits of OpenSearch High-performance Search Edition-OpenSearch(Open Search)-阿里云帮助中心

System limits

Item	Limit
Number of clusters per user	Not limited
Total documents per user	Theoretically not limited — determined by your storage capacity quota
Total page views (PVs) per user	Theoretically not limited — determined by the number of logical computing units (LCUs) allocated to your account
Character encoding	UTF-8

Cluster limits

The following table lists limits for shared and exclusive clusters.

Item	Shared cluster	Exclusive cluster
Cluster name length	30 characters	30 characters
Field name length	30 characters	30 characters
Sort expression name length	30 characters	30 characters
Number of fields	256	512
Source table name length	16 characters	16 characters
Index field name length	64 characters	64 characters
INT fields	256	—
TIMESTAMP fields	4	—
GEO_POINT fields	2	—
LITERAL fields (cannot be used to create composite indexes)	256	—
TEXT or SHORT_TEXT fields	32	64
Numerical analysis indexes	4	8
Composite indexes	4	8
Fields per composite index	8	—
Numerical analysis indexes on INT fields	4	8
Numerical analysis indexes on GEO_POINT fields	2	—
Numerical analysis indexes on TIMESTAMP fields	4	—
Indexes on a single TEXT or SHORT_TEXT field	4	8
Indexes on a single LITERAL field	256	—
Keyword analysis indexes on INT fields	256	—
Vector indexes	0	2
Total data sources	20	—

Storage-optimized exclusive clusters have two additional restrictions:

A single cluster cannot exceed eight tables.

The query analysis feature is not supported, and query results are not displayed.

Field limits

Field type	Limit
INT64	−2^63 to 2^63−1
FLOAT	±3.40282e+038
DOUBLE	±1.79769e+308
LITERAL	Up to 65,535 bytes
TEXT	Up to 65,536 words
SHORT_TEXT	Up to 100 bytes. Fields exceeding 100 bytes are truncated.
LITERAL_ARRAY	Up to 65,535 bytes. The built-in delimiter between elements is 2 bytes. Fields exceeding 65,535 bytes are truncated at the last complete element. For best performance, keep each field to 100 elements or fewer.
INT_ARRAY, FLOAT_ARRAY, DOUBLE_ARRAY	Up to 65,535 elements per field when configured as attribute fields. For best performance, keep each field to 100 elements or fewer.

Sort expression limits

Item	Limit
Rough sort expressions	30
Fine sort expressions	30
Feature function items per rough sort expression	4

Search result summary limits

Item	Description	Limit
Segment length	Maximum length of a single summary segment	1–300 bytes
Number of segments	Number of segments included in a search result summary	1–5

Data push limits

API rate limits

Item	Limit
Max documents per API call	1,000. For better throughput, push 100 documents per call and package your documents.
Max API calls per second	500. Requests exceeding this rate fail with the error: `rate exceeds app quota`.

Payload size limits

Item	Limit
Max request size	2 MB. Requests exceeding 2 MB fail with the error: `rate exceeds app quota`.
Max total data size per second	2 MB. If the combined size of API requests in a second exceeds 2 MB, subsequent requests fail.
Max document size	1 MB. Documents exceeding 1 MB are not synchronized and return the error: `The total size of documents exceed`.

Sync limits

Item	Limit
Incremental sync rate for ApsaraDB RDS or PolarDB data sources	2 MB/s. If the rate exceeds 2 MB/s, the system automatically throttles and delays incremental data synchronization.
Incremental sync latency	99% of pushed documents are searchable within 1 second. 99.9% are searchable within 1 minute.

Non-printable reserved characters

The following characters cannot be included in data you push to OpenSearch. If a field value contains any of these characters, the record is not synchronized.

Code	Emacs/Vi display
`"\x1E\n"`	`^^`
`"\x1F\n"`	`^_`
`"\x1C"`	`^\`
`"\x1D"`	`^]`
`"\x03"`	`^C`

Non-printable characters \u0002 and \u0003 are automatically converted to \t.

The engine supports the following character sets: CJK_1 (\xe2[\xba-\xbf][\x80-\xbf]), CJK_2 ([\xe3-\xe9][\x80-\xbf][\x80-\xbf]), FULLWIDTH_1 (\xef[\xbc-\xbe][\x80-\xbf]), and FULLWIDTH_2 (\xef\xbf[\x80-\xaf]).

Search limits

Item	Limit
Max length per clause (non-filter)	1 KB before encoding. Clauses exceeding 1 KB return an error and are discarded.
Max filter clause length	4 KB before encoding. Filter clauses exceeding 4 KB return an error and are discarded.
Max results per page (single request)	500
Max total results per search (including paged queries)	5,000. For more than 5,000 results, use scroll queries.
Max documents in rough sort	1,000,000
Max documents in fine sort	200 (default)

If a search request exhausts the LCUs allocated to your application, it is dropped with the error: code:6015, message:Dropped by over compute resource quota.

Reindexing limits

Item	Limit
Max synchronization rate	20 MB/s

SQL limits

Unsupported features

Feature	Notes
DDL and DML	Not supported
Global memory operations	Not supported. Global memory is capped to prevent out-of-memory (OOM) errors when large result sets are sorted in memory. For example, `SELECT * FROM t ORDER BY id LIMIT 1000000000` fails when data volume exceeds the limit.
Null values	Not supported. Null values produced by operations such as LEFT JOIN are replaced with the specified default value.
LIKE and RLIKE operators	Not supported for large data volumes. Use the `QUERY` function instead.
Data reshuffle across shards	Not supported. Design your offline data distribution based on your query patterns. Limits are imposed when you join or aggregate multiple tables. If a query error occurs, analyze the query plan.

Format and naming rules

Item	Rule
Table and column names	Must start with a letter and can contain only letters, digits, and underscores (`_`). Special characters are not allowed.
UDF names	Cannot conflict with SQL keywords or reserved words. If a conflict exists, escape the UDF name with backticks (` ``).
Constant strings	Must be enclosed in single quotation marks (`'`). To include a literal single quotation mark in a string, escape it as two consecutive single quotation marks (`''`). For details on escaping strings in dynamic parameters, see Dynamic parameters.

Quantity limits

Item	Limit
Statistical operator (per operator)	Max 5,000,000 keys; max 512 MB memory
Default result set size	100 rows. If the outermost SQL statement omits a `LIMIT` clause, `LIMIT 100` is applied automatically.

Operation limits

Item	Limit
ARRAY type	Use UDFs such as `contain` or `notcontain` for comparisons and queries. Operators `=`, `<`, `>`, and `IN` are not supported.
ARRAY type with GROUP BY	The `GROUP BY` clause does not support ARRAY fields. Use `UNNEST` to flatten the array first. This may temporarily increase data volume — evaluate the performance impact before applying to production.
ARRAY type with JOIN	The `JOIN` clause does not support ARRAY fields. Use `MULTICAST` to distribute the array first. This may temporarily increase data volume — evaluate the performance impact before applying to production.
Dynamic parameters	Only constants in expressions can be replaced. Field names, table names, and `LIMIT` values cannot be replaced.
ORDER BY clause	Must be used with a `LIMIT` clause.
UNION operator	Only `UNION ALL` is supported. `UNION` (deduplication) is not supported. The input tables must have identical field names, types, and counts.
Summary table queries	Full table scans are not supported. Specify primary keys when querying a summary table.
Child table queries	Child table fields cannot be returned. Do not use `SELECT *` when querying child tables.
DATE or RANGE index queries	Equal signs (`=`) are not supported. Use the `QUERY` function instead — for example, `QUERY('time', '[1, 10]')`.
Attribute fields	Attributes are created for all fields by default. Fields of the TEXT or SHORT_TEXT type cannot be used in expressions.