MaxCompute limits - MaxCompute - Alibaba Cloud Documentation Center

This topic describes the limits on using MaxCompute.

Before using MaxCompute, familiarize yourself with its usage limits to ensure your business runs smoothly. The limits are as follows:

Purchase limits on subscription computing resources
Limits on pay-as-you-go computing resources (Standard Edition)
Purchase limits on concurrency for subscription data transfer services
Limits on data transfer services (uploads and downloads)
Shared resource groups
SQL limits
MapReduce limits
PyODPS limits
Job submission limits

Subscription computing resource quota

The default purchase quota for MaxCompute subscription computing resources is 2,000 CUs.

To purchase more than 2,000 CUs, use your Alibaba Cloud account to submit a ticket. We will review your application within three business days and notify you of the result by text message.

Pay-as-you-go Standard Edition resource limits

MaxCompute limits the pay-as-you-go Standard Edition computing resources (CUs) that a single user can use per region. This limit prevents a single user from monopolizing cluster resources and blocking other users from submitting jobs.

Country or area	Region	CU limit
Regions in China	China (Hangzhou), China (Shanghai), China (Beijing), China (Zhangjiakou), China (Ulanqab), China (Shenzhen), China (Shanghai) Finance, China (Beijing) Gov, China (Shenzhen) Finance	2,000
Regions in China	China (Chengdu), China (Hong Kong)	500
Other countries or areas	Singapore (Singapore), Malaysia (Kuala Lumpur), Indonesia (Jakarta), Japan (Tokyo), Germany (Frankfurt), US (Silicon Valley), US (Virginia), UK (London), UAE (Dubai)	500

Important

These CU limits are maximums, not guarantees. MaxCompute may exceed these limits to accelerate queries.

Subscription Tunnel service slot purchase limits

The default purchase limit for subscription Tunnel service slots in MaxCompute is 500. To purchase more than 500 slots, submit a ticket.

Tunnel: Upload and download limits

For limits on data uploads and downloads in MaxCompute, see Tunnel overview.

To learn more about data uploads and downloads, see Data upload scenarios and tools.

Shared resource groups

The following table lists the maximum number of shared slots available per project in each region. Shared resource groups are free of charge.

Site	Region	Slots
China	China (Hangzhou)	300
China	China East 1 Finance	50
China	China (Shanghai)	600
China	China East 2 Finance	50
China	China (Beijing)	300
China	China North 2 Ali Gov	100
China	China (Zhangjiakou)	300
China	China (Ulanqab)	300
China	China (Shenzhen)	150
China	China South 1 Finance	50
China	China (Chengdu)	150
China	China (Hong Kong)	50
Asia Pacific	Singapore	100
Asia Pacific	Malaysia (Kuala Lumpur)	50
Asia Pacific	Indonesia (Jakarta)	50
Asia Pacific	Japan (Tokyo)	50
Europe and Americas	Germany (Frankfurt)	50
Europe and Americas	US (Silicon Valley)	100
Europe and Americas	US (Virginia)	50
Europe and Americas	UK (London)	50
Middle East and India	UAE (Dubai)	50

SQL limits

These limits apply to SQL jobs in MaxCompute.

Item	Limit	Category	Description
Table name length	128 bytes	Length limit	A table name cannot contain special characters, must start with a letter, and can only contain letters (a-z, A-Z), digits, and underscores (_).
Column name length	128 bytes	Length limit	Column names are case-insensitive, cannot contain special characters, and can include only letters (a-z, A-Z), digits, underscores (_), or Chinese characters. We recommend starting column names with a letter. Column names cannot exceed 128 bytes. If you enable BigQuery compatible mode with the `SET odps.sql.bigquery.compatible=true;` command, the maximum column name length increases to 256 bytes.
Comment length	1,024 bytes	Length limit	A comment must be a valid string that does not exceed 1,024 bytes.
Columns per table	1,200	Quantity limit	A table supports a maximum of 1,200 columns.
Partitions per table	60,000	Quantity limit	A table supports a maximum of 60,000 partitions.
Partition levels per table	6	Quantity limit	A table supports a maximum of six partition levels.
Screen display	10,000 rows	Quantity limit	A SELECT statement can display a maximum of 10,000 rows on the screen.
Destination tables for`INSERT`	256	Quantity limit	A `MULTI-INSERT` statement can write to a maximum of 256 destination tables.
`UNION ALL`	256	Quantity limit	A`UNION ALL` statement can combine a maximum of 256 tables.
`MAPJOIN`	128	Quantity limit	In a`MAPJOIN` operation, you can join a maximum of 128 small tables.
`MAPJOIN` memory limit	512 MB	Quantity limit	In a`MAPJOIN` operation, all small tables combined cannot exceed 512 MB of memory.
`ptinsubq (partition in subquery)`	1,000 rows	Quantity limit	If a subquery contains a partition column, the subquery can return a maximum of 1,000 rows.
SQL statement length	2 MB	Length limit	A SQL statement cannot exceed 2 MB. This limit also applies to SQL statements run through an SDK.
Cell size	8 MB	Quantity limit	The data in a single table cell cannot exceed 8 MB.
Number of parameters in an IN clause	1,024	Quantity limit	The recommended maximum number of parameters in an`IN` clause is 1,024, such as `in (1,2,3...,1024)`. An `in(…)` clause with too many parameters can degrade compilation performance. The value 1,024 is a recommendation, not a strict limit.
`jobconf.json` size	1 MB	Length limit	The size of `jobconf.json` is 1 MB. When a table contains a large number of partitions, the size may exceed `jobconf.json`, exceeding 1 MB.
Views	Not writable	Operation limit	Views are read-only and do not support`INSERT` operations.
Column data type	Cannot be modified	Operation limit	You cannot modify the data type or position of an existing column.
Java user-defined function (UDF)	Cannot be`ABSTRACT` or`STATIC`.	Operation limit	A Java UDF cannot be defined as`ABSTRACT` or`STATIC`.
Maximum number of partitions to query	10,000	Quantity limit	A query can scan a maximum of 10,000 partitions.
SQL execution plan size	1 MB	Length limit	The execution plan generated by MaxCompute SQL cannot exceed 1 MB. If it does, the job fails and returns the following error:`FAILED: ODPS-0010000:System internal error - The Size of Plan is too large`.
Maximum job execution duration	72 hours	Runtime duration limit	By default, the maximum execution duration for a single SQL job is 24 hours. You can extend this limit to 72 hours by using the following command. The system automatically terminates any job that runs longer than 72 hours. `SET odps.sql.job.max.time.hours=72;`
Partition creation frequency	120 times/15 seconds	Frequency limit	You can execute the `ALTER TABLE <table_name> ADD PARTITION <pt_spec>` operation a maximum of 120 times every 15 seconds.

For more information about SQL, see SQL.

MapReduce limits

The following table lists the limits for developing MapReduce jobs in MaxCompute.

Limit	Value	Category	Configuration parameter	Default	Configurable
Memory per instance	256 MB–12 GB	Memory	`odps.stage.mapper(reducer).mem` and `odps.stage.mapper(reducer).jvm.mem`	2,048 MB + 1,024 MB	Yes
Resources per job	256	Quantity	—	—	No
Inputs per job	1,024	Quantity	—	—	No
Outputs per job	256	Quantity	—	—	No
Distinct tables across all inputs	64	Quantity	—	—	No
Custom counters per job	64	Quantity	—	—	No
Map instances per job	1–100,000	Quantity	`odps.stage.mapper.num`	Calculated from split size	Yes
Reduce instances per job	0–2,000	Quantity	`odps.stage.reducer.num`	1/4 of map instances	Yes
Retries per failed instance	3	Quantity	—	—	No
Local debug: map instances	2 (default), max 100	Quantity	—	2	No
Local debug: reduce instances	1 (default), max 100	Quantity	—	1	No
Local debug: downloaded records per input	100 (default), max 10,000	Quantity	—	100	No
Repeated reads of one resource per instance	64	Quantity	—	—	No
Total resource size per job	2 GB	Length	—	—	No
Split size	≥ 1	Length	`odps.stage.mapper.split.size`	256 MB	Yes
STRING column content length	8 MB	Length	—	—	No
Worker execution timeout	1–3,600 seconds	Time	`odps.function.timeout`	600 seconds	Yes
Supported field types in table resources	BIGINT, DOUBLE, STRING, DATETIME, BOOLEAN	Data type	—	—	No

For more information about MapReduce, see MapReduce.

PyODPS limitations

The following limitations apply when developing PyODPS jobs in MaxCompute using DataWorks:

A PyODPS node can process a maximum of 50 MB of local data and consume up to 1 GB of memory. If a node exceeds these limits, the system terminates the job. To avoid this, avoid adding unnecessary Python data processing code to your PyODPS jobs.
For a more efficient development and debugging experience, we recommend writing your code in a local IDE instead of directly in the DataWorks user interface.
To prevent excessive load on the DataWorks gateway, DataWorks limits memory and CPU usage for PyODPS. The Got killed error indicates that your process was terminated for exceeding the memory limit. To prevent this, avoid performing data operations locally. These limits do not apply to SQL or DataFrame jobs (except for to_pandas) initiated by PyODPS.
The following features are limited because packages such as matplotlib are unavailable:
- The DataFrame plot function is unavailable.
- DataFrame user-defined functions (UDFs) must be submitted to MaxCompute for execution. Due to Python sandbox restrictions, the only supported third-party libraries are pure Python libraries and NumPy. You cannot use pandas directly in UDFs.
- For code outside of UDFs, you can use the pre-installed NumPy and pandas packages in DataWorks. Third-party packages that contain binary code are not supported.
For compatibility reasons, DataWorks sets options.tunnel.use_instance_tunnel to False by default. To enable InstanceTunnel globally, you must manually set this value to True.
Due to implementation reasons, the Python atexit package is not supported. Use a try-finally block instead.

For more information about PyODPS, see PyODPS.

Concurrent job limits

The following table lists the maximum number of concurrent jobs in a single MaxCompute project for each region.

Region	Maximum concurrent jobs
China (Hangzhou), China (Shanghai), China (Beijing), China (Zhangjiakou), China (Ulanqab), China (Shenzhen), and China (Chengdu)	2,500
China (Hong Kong), Singapore, Malaysia (Kuala Lumpur), Indonesia (Jakarta), Japan (Tokyo), Germany (Frankfurt), US (Silicon Valley), US (Virginia), UK (London), and UAE (Dubai)	1,000

Submitting a job that exceeds the concurrency limit for a MaxCompute project returns an error. For example: com.aliyun.odps.OdpsException: Request rejected by flow control. You have exceeded the limit for the number of tasks you can run concurrently in this project. Please try later.