This is an automated email from the ASF dual-hosted git repository.
kassiez pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris-website.git
The following commit(s) were added to refs/heads/master by this push:
new 58cc3e22946 [doc](job)Optimize the documentation of job related
statements (#1879)
58cc3e22946 is described below
commit 58cc3e229460bbff513a68fa14e5a87a48f797d5
Author: Hong Liu <[email protected]>
AuthorDate: Thu Jan 23 16:15:10 2025 +0800
[doc](job)Optimize the documentation of job related statements (#1879)
## Versions
- [x] dev
- [x] 3.0
- [x] 2.1
- [ ] 2.0
## Languages
- [x] Chinese
- [x] English
## Docs Checklist
- [ ] Checked by AI
- [ ] Test Cases Built
---------
Co-authored-by: smallhibiscus <844981280>
---
docs/sql-manual/sql-statements/job/CREATE-JOB.md | 179 ++++++++++-----------
docs/sql-manual/sql-statements/job/DROP-JOB.md | 28 ++--
docs/sql-manual/sql-statements/job/PAUSE-JOB.md | 30 ++--
docs/sql-manual/sql-statements/job/RESUME-JOB.md | 30 ++--
.../sql-manual/sql-statements/job/CREATE-JOB.md | 160 +++++++++---------
.../sql-manual/sql-statements/job/DROP-JOB.md | 29 ++--
.../sql-manual/sql-statements/job/PAUSE-JOB.md | 30 ++--
.../sql-manual/sql-statements/job/RESUME-JOB.md | 29 ++--
.../sql-manual/sql-statements/job/CREATE-JOB.md | 167 +++++++++----------
.../sql-manual/sql-statements/job/DROP-JOB.md | 28 ++--
.../sql-manual/sql-statements/job/PAUSE-JOB.md | 31 ++--
.../sql-manual/sql-statements/job/RESUME-JOB.md | 26 +--
.../sql-manual/sql-statements/job/CREATE-JOB.md | 160 +++++++++---------
.../sql-manual/sql-statements/job/DROP-JOB.md | 29 ++--
.../sql-manual/sql-statements/job/PAUSE-JOB.md | 30 ++--
.../sql-manual/sql-statements/job/RESUME-JOB.md | 29 ++--
.../sql-manual/sql-statements/job/CREATE-JOB.md | 174 ++++++++++----------
.../sql-manual/sql-statements/job/DROP-JOB.md | 30 ++--
.../sql-manual/sql-statements/job/PAUSE-JOB.md | 32 ++--
.../sql-manual/sql-statements/job/RESUME-JOB.md | 33 ++--
.../sql-manual/sql-statements/job/CREATE-JOB.md | 179 ++++++++++-----------
.../sql-manual/sql-statements/job/DROP-JOB.md | 28 ++--
.../sql-manual/sql-statements/job/PAUSE-JOB.md | 30 ++--
.../sql-manual/sql-statements/job/RESUME-JOB.md | 30 ++--
24 files changed, 801 insertions(+), 750 deletions(-)
diff --git a/docs/sql-manual/sql-statements/job/CREATE-JOB.md
b/docs/sql-manual/sql-statements/job/CREATE-JOB.md
index f8127931b2c..840a9d8fa08 100644
--- a/docs/sql-manual/sql-statements/job/CREATE-JOB.md
+++ b/docs/sql-manual/sql-statements/job/CREATE-JOB.md
@@ -25,147 +25,140 @@ specific language governing permissions and limitations
under the License.
-->
-:::tip
-
-This statement is supported since 2.1
-
-:::
-
## Description
-Doris Job is a task that runs according to a predefined schedule, triggering
predefined actions at specific times or intervals to help automate certain
tasks. In terms of functionality, it is similar to scheduled tasks on operating
systems (e.g., cron in Linux, scheduled tasks in Windows).↳
-
-There are two types of Jobs: ONE_TIME and RECURRING. The ONE_TIME type of Job
triggers at a specified time point and is mainly used for one-time tasks, while
the RECURRING type of Job triggers at specified time intervals and is used for
periodically recurring tasks. The RECURRING type of Job can specify a start
time and an end time using STARTS\ENDS. If the start time is not specified, the
first execution time is set to the current time plus one scheduling period. If
the end time is spec [...]
-
-#### Job Status
-
-A Job has four states (RUNNING, STOPPED, PAUSED, FINISHED), with the initial
state being RUNNING. A Job in the RUNNING state generates Tasks based on the
specified scheduling period. When a Job completes execution and reaches the end
time, the status changes to FINISHED.
-
-A Job in the RUNNING state can be paused, which means it will no longer
generate Tasks.
+Doris Job is a task that runs according to a set plan. It is used to trigger
predefined operations at a specific time or a specified time interval, so as to
help us automatically perform some tasks. Functionally, it is similar to the
scheduled task on the operating system (such as cron in Linux and scheduled
tasks in Windows).
-A Job in the PAUSED state can be resumed by performing the RESUME operation,
changing the state to RUNNING.
+There are two types of jobs: `ONE_TIME` and `RECURRING`. Among them, the
`ONE_TIME` type of job will be triggered at a specified time point. It is
mainly used for one-time tasks, while the `RECURRING` type of job will be
triggered cyclically within a specified time interval. This method is mainly
used for periodic tasks.
+The `RECURRING` type of job can specify the start time and end time, that is,
`STARTS/ENDS`. If the start time is not specified, the default first execution
time is the current time + one scheduling cycle. If the end time is specified,
the task execution is completed. If the end time is reached (or exceeded, or
the next execution cycle will exceed the end time), it will be updated to the
FINISHED state, and no more tasks will be generated at this time.
-A Job in the STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+There are 4 states for a job (`RUNNING`, `STOPPED`, `PAUSED`, `FINISHED`).
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+The initial state is `RUNNING`. A job in the `RUNNING` state will generate a
TASK for execution according to the established scheduling cycle. When the job
is completed and reaches the end time, the state changes to `FINISHED`.
-#### Task status
+A job in the `PAUSED` state can be resumed through the RESUME operation and
changed to the RUNNING state.
-A Job only describes the job information, and the execution generates Tasks.
The Task status can be PENDING, RUNNING, SUCCESS, FAILED, or CANCELED.
+A job in the `STOPPED` state is actively triggered by the user, and the
running job will be canceled and the job will be deleted.
-PENDING indicates that the trigger time has been reached but resources are
awaited for running. Once resources are allocated, the status changes to
RUNNING. When the execution is successful or fails, the status changes to
SUCCESS or FAILED, respectively.
+A job in the `FINISHED` state will be retained in the system for 24 hours and
will be deleted after 24 hours.
-CANCELED indicates the cancellation status. The final status of a Task is
persisted as SUCCESS or FAILED. Other statuses can be queried while the Task is
running, but they become invisible after a restart. Only the latest 100 Task
records are retained.
+JOB only describes job information. Execution will generate TASK. TASK status
is divided into `PENDING`, `RUNNING`, `SUCCEESS`, `FAILED`, `CANCELED`
+`PENDING` means that the trigger time has arrived but the resource run is
waiting. After the resource is allocated, the status changes to `RUNNING`.
Success/failure of execution changes to `SUCCESS`/`FAILED`.
+`CANCELED` means cancellation status. TASK persists the final status, i.e.
`SUCCESS`/`FAILED`. Other statuses can be checked during operation, but will
not be visible if restarted.
-#### Permissions
+## Syntax
-Currently, only users with the ADMIN role can perform this operation.
+```sql
+CREATE
+ JOB
+ <job_name>
+ ON SCHEDULE <schedule>
+ [ COMMENT <string> ]
+ DO <sql_body>
+```
-#### Related Documentation
+Where:
-- [PAUSE-JOB](../Alter/PAUSE-JOB.md)
-- [RESUME-JOB](../Alter/RESUME-JOB.md)
-- [DROP-JOB](../Drop/DROP-JOB.md)
-- [VIEW-JOB](../../../sql-functions/table-valued-functions/jobs.md),
-- [VIEW-TASKS](../../../sql-functions/table-valued-functions/tasks.md)
+```sql
+schedule:
+ { AT <at_timestamp> | EVERY <interval> [STARTS <start_timestamp> ] [ENDS
<end_timestamp> ] }
+```
-### Grammar
+Where:
```sql
-CREATE
- job
- job_name
- ON SCHEDULE schedule
- [COMMENT 'string']
- DO sql_body;
-
-schedule: {
- AT timestamp
- | EVERY interval
- [STARTS timestamp]
- [ENDS timestamp ]
-}
-
interval:
- quantity { DAY | HOUR | MINUTE |
- WEEK | SECOND }
+ quantity { WEEK | DAY | HOUR | MINUTE }
```
-A valid Job statement must contain the following
+## Required parameters
-- The keyword CREATE JOB plus the job name, which uniquely identifies the
event within a database. The job name must be globally unique, and if a JOB
with the same name already exists, an error will be reported. We reserve the
inner_ prefix for internal use, so users cannot create names starting with
***inner_***.
-- The ON SCHEDULE clause, which specifies the type of Job and when and how
often to trigger it.
-- The DO clause, which specifies the actions that need to be performed when
the Job is triggered.
+**1. `<job_name>`**
+> Job name, which identifies a unique event in a db. The job name must be
globally unique. If a job with the same name already exists, an error will be
reported. We reserve the **inner_** prefix for internal use in the system, so
users cannot create names starting with **inner_**.
-Here is a minimal example:
+**2. `<schedule>`**
+> The ON SCHEDULE clause specifies the type, triggering time and frequency of
the job. It can specify a one-time job or a periodic job.
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1 SELECT *
FROM db2.tbl2;
-```
+**3. `<sql_body>`**
+> The DO clause specifies the operation to be performed when the job is
triggered, that is, a SQL statement.
-This statement means to create a job named my_job to be executed every minute,
and the operation performed is to import the data in db2.tbl2 into db1.tbl1.
+## Optional parameters
-The SCHEDULE statement is used to define the execution time, frequency and
duration of the job, which can specify a one-time job or a periodic job.
-- AT timestamp
+**1. `AT <at_timestamp>`**
+> Format: 'YYYY-MM-DD HH:MM:SS', used for **one-time events**, it specifies
that the event is executed only once at a given date and time timestamp, and
when the execution is completed, the job status will change to FINISHED.
-Format: 'YYYY-MM-DD HH:MM:SS'. Used for one-time events, it specifies that the
event should only be executed once at the given date and time. Once the
execution is complete, the Job status changes to FINISHED.
+**2. `EVERY <interval>`**
+> Indicates a regularly repeated operation, it specifies the execution
frequency of the job, and a time interval must be specified after the keyword,
which can be days, hours, minutes, seconds, or weeks.
-- EVERY
+**3. `STARTS <start_timestamp>`**
+> Format: 'YYYY-MM-DD HH:MM:SS', used to specify the start time of the job. If
not specified, it will be executed from the next time point after the current
time. The start time must be greater than the current time.
- Indicates that the operation is repeated periodically, which specifies the
execution frequency of the job. After the keyword, a time interval should be
specified, which can be days, hours, minutes, seconds, and weeks.
+**4. `ENDS <end_timestamp>`**
+> Format: 'YYYY-MM-DD HH:MM:SS', used to specify the end time of the job. If
not specified, it means permanent execution. The date must be greater than the
current time. If the start time is specified, that is, STARTS, the end time
must be greater than the start time.
- - interval
+## Access Control Requirements
- Used to specify the Job execution frequency, which can be `day`, `hour`,
`minute`, or `week`. For example, 1 `DAY` means the Job will run once every
day, 1 `HOUR` means once every hour, 1 `MINUTE` means once every minute, and `1
The CREATE JOB statement is used to create a job in a database. A job is a task
that can be scheduled to run at specific times or intervals to automate certain
actions.
+The user who executes this SQL command must have at least the following
permissions:
- - STARTS timestamp(optional)
+| Privilege | Object | Notes
|
+|:--------------|:-----------|:------------------------------------------------------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions
to perform this operation |
- Format: 'YYYY-MM-DD HH:MM:SS'. It is used to specify the start time of the
job. If not specified, the job starts executing from the next occurrence based
on the current time. The start time must be greater than the current time.
+## Usage Notes
- - ENDS timestamp(optional)
+- TASK only retains the latest 100 records.
- Format: 'YYYY-MM-DD HH:MM:SS'. It is used to specify the end time of the
job. If not specified, it means the job executes indefinitely. The end date
must be greater than the current time. If a start time (↳STARTS) is specified,
the end time must be greater than the start time.
+- Currently only supports **INSERT internal table** operations, and will
support more operations in the future.
-- DO
+- When the next scheduled task time expires, that is, when the task needs to
be scheduled for execution, if the current JOB still has historical tasks being
executed, the current task scheduling will be skipped. Therefore, it is very
important to control a reasonable execution interval.
- It is used to specify the operation that needs to be performed when the job
is triggered. Currently, all ***INSERT*** operations are supported. We will
support more operations in the future.
+## Examples
-## Example
+- Create a job named my_job, which is executed once every minute. The
operation performed is to import the data in db2.tbl2 into db1.tbl1.
-Create a one-time job, which will be executed once at 2020-01-01 00:00:00, and
the operation performed is to import the data in db2.tbl2 into db1.tbl1.
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1 SELECT
* FROM db2.tbl2;
+ ```
-```sql
+- Create a one-time job that will be executed once at 2020-01-01 00:00:00 to
import the data in db2.tbl2 into db1.tbl1.
-CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO db1.tbl1
SELECT * FROM db2.tbl2;
+ ```sql
+ CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO
db1.tbl1 SELECT * FROM db2.tbl2;
+ ```
-```
+- Create a periodic Job that will start executing at 2020-01-01 00:00:00 and
execute once a day. The operation performed is to import the data in db2.tbl2
into db1.tbl1.
-Create a periodic Job, which will start to execute at 2020-01-01 00:00:00,
once a day, and the operation is to import the data in db2.tbl2 into db1.tbl1.
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
+ ```
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
-```
+- Create a periodic job that will start at 2020-01-01 00:00:00 and execute
once a day. The operation is to import the data in db2.tbl2 into db1.tbl1. The
job ends at 2020-01-01 00:10:00.
-Create a periodic Job, which will start to execute at 2020-01-01 00:00:00, and
execute once a day. The operation performed is to import the data in db2.tbl2
into db1.tbl1. This Job will be executed in 2020 Ends at -01-01 00:10:00.
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' ENDS
'2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add(now(),-1);
+ ```
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' ENDS
'2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add (now(),-1);
-```
+## Best Practices
+
+- Manage jobs reasonably to avoid a large number of jobs being triggered at
the same time, which will cause task accumulation and affect the normal
operation of the system.
+- The task execution interval should be set within a reasonable range, at
least greater than the task execution time.
+
+## Related Documents
-### CONFIG
+- [Pause-JOB](../job/PAUSE-JOB.md)
+- [Resume-JOB](../job/RESUME-JOB.md)
+- [Delete-JOB](../job/DROP-JOB.md)
+- [Query-JOB](../../../sql-manual/sql-functions/table-valued-functions/jobs.md)
+- [Query-TASKS](../../sql-functions/table-valued-functions/jobs.md)
-#### fe.conf
+## CONFIG
-- job_dispatch_timer_job_thread_num: Number of threads used for dispatching
scheduled tasks. Default value is 2. If there are a large number of
periodically executed tasks, this parameter can be increased.
-- job_dispatch_timer_job_queue_size: Size of the queue used for storing
scheduled tasks when there is task accumulation. Default value is 1024. If
there are a large number of tasks triggered at the same time, this parameter
can be increased. Otherwise, the queue may become full and submitting tasks
will be blocked, causing subsequent tasks to be unable to submit.
-- finished_job_cleanup_threshold_time_hour: Time threshold, in hours, for
cleaning up completed tasks. Default value is 24 hours.
-- job_insert_task_consumer_thread_num: Number of threads used for executing
Insert tasks. The value should be greater than 0, otherwise the default value
is 5.
+**fe.conf**
-## Best Practice
+- job_dispatch_timer_job_thread_num, the number of threads used to distribute
timed tasks, the default value is 2, if there are a large number of periodic
execution tasks, you can increase this parameter.
-- Properly manage Jobs to avoid triggering a large number of Jobs
simultaneously, which can lead to task accumulation and affect the normal
operation of the system.
-- Set the execution interval of tasks within a reasonable range, ensuring that
it is at least greater than the task execution time.
+- job_dispatch_timer_job_queue_size, the queue size for storing timed tasks
when tasks are accumulated, the default value is 1024. If a large number of
tasks are triggered at the same time, this parameter can be increased.
Otherwise, the queue will be full, and the submitted task will enter a blocked
state, which will cause subsequent tasks to fail to submit.
-## Keywords
+- finished_job_cleanup_threshold_time_hour, the time threshold for cleaning up
completed tasks, in hours, the default value is 24 hours.
- CREATE, JOB, SCHEDULE
+- job_insert_task_consumer_thread_num = 10; the number of threads used to
execute Insert tasks, the value should be greater than 0, otherwise the default
value is 5.
\ No newline at end of file
diff --git a/docs/sql-manual/sql-statements/job/DROP-JOB.md
b/docs/sql-manual/sql-statements/job/DROP-JOB.md
index 48d228b7749..530a9cb567d 100644
--- a/docs/sql-manual/sql-statements/job/DROP-JOB.md
+++ b/docs/sql-manual/sql-statements/job/DROP-JOB.md
@@ -26,23 +26,31 @@ under the License.
## Description
-User stops a JOB. A stopped job cannot be resumed.
+The user deletes a JOB job. The job will be stopped and deleted immediately.
+
+## Syntax
```sql
-DROP JOB WHERE jobName = 'job_name';
+DROP JOB where jobName = <job_name> ;
```
-## Example
+## Required parameters
+
+**1. `<job_name>`**
+> The `<job_name>` of the task to be deleted.
-1. DROP the job named test1.
+## Access Control Requirements
- ```sql
- DROP JOB where jobName = 'test1';
- ```
+The user who executes this SQL command must have at least the following
permissions:
-## Keywords
+| Privilege | Object | Notes |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions to
perform this operation |
- DROP, JOB
+## Examples
-## Best Practice
+- Delete the job named example.
+ ```sql
+ DROP JOB where jobName='example';
+ ```
\ No newline at end of file
diff --git a/docs/sql-manual/sql-statements/job/PAUSE-JOB.md
b/docs/sql-manual/sql-statements/job/PAUSE-JOB.md
index 08a4f309f62..dc55b74387a 100644
--- a/docs/sql-manual/sql-statements/job/PAUSE-JOB.md
+++ b/docs/sql-manual/sql-statements/job/PAUSE-JOB.md
@@ -24,25 +24,33 @@ specific language governing permissions and limitations
under the License.
-->
-
## Description
-User suspends a JOB. A stopped job can be resumed with RESUME JOB.
+When a user pauses a job in the RUNNING state, the running task will be
interrupted and the job state will be changed to PAUSED. The stopped job can be
resumed by the RESUME operation.
+
+## Syntax
```sql
-PAUSE JOB where jobName = 'job_name';
+PAUSE JOB WHERE jobname = <job_name> ;
```
-## Example
+## Required parameters
+
+**1. `<job_name>`**
+> The name of the job to be paused.
+
+## Access Control Requirements
-1. Pause the job named test1.
+The user who executes this SQL command must have at least the following
permissions:
- ```sql
- PAUSE JOB where jobName = 'test1';
- ```
+| Privilege | Object | Notes |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions to
perform this operation |
-## Keywords
+## Examples
- PAUSE, JOB
+- Pause the job named example.
-## Best Practice
+ ```sql
+ PAUSE JOB where jobname='example';
+ ```
\ No newline at end of file
diff --git a/docs/sql-manual/sql-statements/job/RESUME-JOB.md
b/docs/sql-manual/sql-statements/job/RESUME-JOB.md
index 56836cd86fe..b106837ccb4 100644
--- a/docs/sql-manual/sql-statements/job/RESUME-JOB.md
+++ b/docs/sql-manual/sql-statements/job/RESUME-JOB.md
@@ -24,28 +24,32 @@ specific language governing permissions and limitations
under the License.
-->
-
## Description
-Used to restart a JOB in PAUSE state. The restarted job will continue to be
executed periodically. A JOB in STOP state cannot be resumed.
+Restore the PAUSED job to the RUNNING state. The RUNNING job will be executed
according to the scheduled period.
+
+## Syntax
```sql
-RESUME JOB WHERE jobName = 'job_name';
+RESUME JOB where jobName = <job_name> ;
```
+## Required parameters
-## Example
-
-1. Restart the JOB named test1.
-
- ```sql
- RESUME JOB WHERE jobName = 'test1';
- ```
+**1. `<job_name>`**
+> The `<job_name>` of the recovery task.
-## Keywords
+## Access Control Requirements
- RESUME, JOB
+The user who executes this SQL command must have at least the following
permissions:
-## Best Practice
+| Privilege | Object | Notes |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions to
perform this operation |
+## Example
+- Resume the job named example.
+ ```sql
+ RESUME JOB where jobName= 'example';
+ ```
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/CREATE-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/CREATE-JOB.md
index bc07541fdb1..d3131d5aa44 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/CREATE-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/CREATE-JOB.md
@@ -25,134 +25,135 @@ specific language governing permissions and limitations
under the License.
-->
-
-
-
## 描述
Doris Job 是根据既定计划运行的任务，用于在特定时间或指定时间间隔触发预定义的操作，从而帮助我们自动执行一些任务。从功能上来讲，它类似于操作系统上的
定时任务（如：Linux 中的 cron、Windows 中的计划任务）。
Job 有两种类型：`ONE_TIME` 和 `RECURRING`。其中 `ONE_TIME` 类型的 Job
会在指定的时间点触发，它主要用于一次性任务，而 `RECURRING` 类型的 Job 会在指定的时间间隔内循环触发，此方式主要用于周期性执行的任务。
-`RECURRING` 类型的 Job 可指定开始时间，结束时间，即 `STARTS\ENDS`, 如果不指定开始时间，则默认首次执行时间为当前时间 +
一次调度周期。如果指定结束时间，则 task 执行完成如果达到结束时间（或超过，或下次执行周期会超过结束时间）则更新为 FINISHED 状态，此时不会再产生
Task。
+`RECURRING` 类型的 Job 可指定开始时间，结束时间，即 `STARTS/ENDS`, 如果不指定开始时间，则默认首次执行时间为当前时间 加
一次调度周期。如果指定结束时间，则 task 执行完成如果达到结束时间（或超过，或下次执行周期会超过结束时间）则更新为 FINISHED 状态，此时不会再产生
Task。
-JOB 共 4 种状态（`RUNNING`,`STOPPED`,`PAUSED`,`FINISHED`,），初始状态为 RUNNING，RUNNING
状态的 JOB 会根据既定的调度周期去生成 TASK 执行，Job 执行完成达到结束时间则状态变更为 `FINISHED`.
+JOB 共 4 种状态（`RUNNING`,`STOPPED`,`PAUSED`,`FINISHED`），初始状态为 RUNNING，RUNNING 状态的
JOB 会根据既定的调度周期去生成 TASK 执行，Job 执行完成达到结束时间则状态变更为 `FINISHED`.
-RUNNING 状态的 JOB 可以被 pause，即暂停，此时不会再生成 Task。
+`PAUSED` 状态的 JOB 可以通过 RESUME 操作来恢复运行，更改为 `RUNNING` 状态。
-PAUSE 状态的 JOB 可以通过 RESUME 操作来恢复运行，更改为 RUNNING 状态。
+`STOPPED` 状态的 JOB 由用户主动触发，此时会 Cancel 正在运行中的作业，然后删除 JOB。
-STOP 状态的 JOB 由用户主动触发，此时会 Cancel 正在运行中的作业，然后删除 JOB。
+`Finished` 状态的 JOB 会保留在系统中 24 H，24H 后会被删除。
-Finished 状态的 JOB 会保留在系统中 24 H，24H 后会被删除。
+JOB 只描述作业信息，执行会生成 TASK，TASK 状态分为
`PENDING`，`RUNNING`，`SUCCEESS`,`FAILED`,`CANCELED`.
+`PENDING` 表示到达触发时间了但是等待资源 RUN，分配到资源后状态变更为 `RUNNING`，执行成功/失败即变更为
`SUCCESS`/`FAILED`.
+`CANCELED` 即取消状态，TASK 持久化最终状态，即 `SUCCESS`/`FAILED`，其他状态运行中可以查到，但是如果重启则不可见。
-JOB 只描述作业信息，执行会生成 TASK，TASK 状态分为 PENDING，RUNNING，SUCCEESS,FAILED,CANCELED
-PENDING 表示到达触发时间了但是等待资源 RUN，分配到资源后状态变更为 RUNNING，执行成功/失败即变更为 SUCCESS/FAILED.
-CANCELED 即取消状态，TASK 持久化最终状态，即 SUCCESS/FAILED，其他状态运行中可以查到，但是如果重启则不可见。TASK
只保留最新的 100 条记录。
+## 语法
-#### 权限
-
-- 目前仅支持 ***ADMIN*** 权限执行此操作。
+```sql
-#### 相关文档
+CREATE
+ JOB
+ <job_name>
+ ON SCHEDULE <schedule>
+ [ COMMENT <string> ]
+ DO <sql_body>
+```
+其中：
-- [暂停-JOB](../job/PAUSE-JOB.md)
-- [恢复-JOB](../job/RESUME-JOB.md)
-- [删除-JOB](../job/DROP-JOB.md)
-- [查询-JOB](../../../sql-manual/sql-functions/table-valued-functions/jobs.md)
-- [查询-TASKS](../../sql-functions/table-valued-functions/jobs.md)
+```sql
+schedule:
+ { AT <at_timestamp> | EVERY <interval> [STARTS <start_timestamp> ] [ENDS
<end_timestamp> ] }
+```
-### 语法
+其中：
```sql
-CREATE
- JOB
- job_name
- ON SCHEDULE schedule
- [COMMENT 'string']
- DO sql_body;
-
-schedule: {
- AT timestamp
- | EVERY interval
- [STARTS timestamp ]
- [ENDS timestamp ]
-}
-
interval:
quantity { WEEK | DAY | HOUR | MINUTE }
```
-一条有效的 Job 语句必须包含以下内容
-
-- 关键字 CREATE JOB 加上作业名称，它在一个 db 中标识唯一事件。JOB 名称必须是全局唯一的，如果已经存在同名的
JOB，则会报错。我们保留了 ***inner_*** 前缀在系统内部使用，因此用户不能创建以 ***inner_*** 开头的名称。
-- ON SCHEDULE 子句，它指定了 Job 作业的类型和触发时间以及频率。
-- DO 子句，它指定了 Job 作业触发时需要执行的操作，即一条 SQL 语句。
+## 必选参数
-这是一个最简单的例子：
+**1. `<job_name>`**
+> 作业名称，它在一个 db 中标识唯一事件。JOB 名称必须是全局唯一的，如果已经存在同名的 JOB，则会报错。我们保留了 **inner_**
前缀在系统内部使用，因此用户不能创建以 **inner_** 开头的名称。
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1 SELECT *
FROM db2.tbl2;
-```
+**2. `<schedule>`**
+> ON SCHEDULE 子句，指定了 Job 作业的类型和触发时间以及频率，它可以指定一次性作业或者周期性作业。
-该语句表示创建一个名为 my_job 的作业，每分钟执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1 中。
+**3. `<sql_body>`**
+> DO 子句，它指定了 Job 作业触发时需要执行的操作，即一条 SQL 语句。
-SCHEDULE 语句用于定义作业的执行时间，频率以及持续时间，它可以指定一次性作业或者周期性作业。
-- AT timestamp
+## 可选参数
-格式：'YYYY-MM-DD HH:MM:SS', 用于一次性事件，它指定事件仅在 给定的日期和时间执行一次 timestamp，当执行完成后，JOB
状态会变更为 FINISHED。
+**1. `AT <at_timestamp>`**
+> 格式：'YYYY-MM-DD HH:MM:SS', 用于**一次性事件**，它指定事件仅在 给定的日期和时间执行一次
timestamp，当执行完成后，JOB 状态会变更为 FINISHED。
-- EVERY
+**2. `EVERY <interval>`**
+> 表示定期重复操作，它指定了作业的执行频率，关键字后面要指定一个时间间隔，该时间间隔可以是天、小时、分钟、秒、周。
- 表示定期重复操作，它指定了作业的执行频率，关键字后面要指定一个时间间隔，该时间间隔可以是天、小时、分钟、秒、周。
+**3. `STARTS <start_timestamp>`**
+> 格式：'YYYY-MM-DD HH:MM:SS',用于指定作业的开始时间，如果没有指定，则从当前时间的下一个时间点开始执行。开始时间必须大于当前时间。
- - interval
+**4. `ENDS <end_timestamp>`**
+> 格式：'YYYY-MM-DD HH:MM:SS', 用于指定作业的结束时间，如果没有指定，则表示永久执行。该日期必须大于当前时间，如果指定了开始时间，即
STARTS，则结束时间必须大于开始时间。
- 用于指定作业执行频率，它可以是天、小时、分钟、周。例如：` 1 DAY` 表示每天执行一次，` 1 HOUR` 表示每小时执行一次，` 1
MINUTE` 表示每分钟执行一次，` 1 WEEK` 表示每周执行一次。
+## 权限控制
- - STARTS timestamp（可选字段）
+执行此 SQL 命令的用户必须至少具有以下权限：
- 格式：'YYYY-MM-DD
HH:MM:SS',用于指定作业的开始时间，如果没有指定，则从当前时间的下一个时间点开始执行。开始时间必须大于当前时间。
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
- - ENDS timestamp（可选字段）
+## 注意事项
- 格式：'YYYY-MM-DD HH:MM:SS',
用于指定作业的结束时间，如果没有指定，则表示永久执行。该日期必须大于当前时间，如果指定了开始时间，即 `STARTS`，则结束时间必须大于开始时间。
+- TASK 只保留最新的 100 条记录。
-- DO
+- 目前仅支持 **INSERT 内表** 操作，后续会支持更多的操作。
- 用于指定作业触发时需要执行的操作，目前仅支持 ***INSERT 内表*** 操作。后续我们会支持更多的操作。
+- 当下一个计划任务时间到期，即需要调度任务执行时，如果当前 JOB 仍有历史任务正在执行，则会跳过当前任务调度。因此控制一个合理的执行间隔非常重要。
## 示例
-创建一个一次性的 Job，它会在 2020-01-01 00:00:00 时执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1 中。
+- 创建一个名为 my_job 的作业，每分钟执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1 中。
-```sql
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1
SELECT * FROM db2.tbl2;
+ ```
-CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO db1.tbl1
SELECT * FROM db2.tbl2;
+- 创建一个一次性的 Job，它会在 2020-01-01 00:00:00 时执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1
中。
+
+ ```sql
+ CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO
db1.tbl1 SELECT * FROM db2.tbl2;
+ ```
-```
+- 创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中。
-创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中。
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
+ ```
+
+- 创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中，该 Job 在 2020-01-01 00:10:00 时结束。
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
-```
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00'
ENDS '2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add(now(),-1);
+ ```
-创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中，该 Job 在 2020-01-01 00:10:00 时结束。
+## 最佳实践
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' ENDS
'2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add(now(),-1);
-```
+- 合理的进行 Job 的管理，避免大量的 Job 同时触发，导致任务堆积，从而影响系统的正常运行。
+- 任务的执行间隔应该设置在一个合理的范围，至少应该大于任务执行时间。
-### INSERT JOB
+## 相关文档
-- 目前仅支持 ***INSERT 内表***
-- 当下一个计划任务时间到期，即需要调度任务执行时，如果当前 JOB 仍有历史任务正在执行，则会跳过当前任务调度。因此控制一个合理的执行间隔非常重要。
+- [暂停-JOB](../job/PAUSE-JOB.md)
+- [恢复-JOB](../job/RESUME-JOB.md)
+- [删除-JOB](../job/DROP-JOB.md)
+- [查询-JOB](../../../sql-manual/sql-functions/table-valued-functions/jobs.md)
+- [查询-TASKS](../../sql-functions/table-valued-functions/jobs.md)
-### CONFIG
+## CONFIG
-fe.conf
+**fe.conf**
- job_dispatch_timer_job_thread_num, 用于分发定时任务的线程数，默认值 2，如果含有大量周期执行任务，可以调大这个参数。
@@ -162,11 +163,4 @@ fe.conf
- job_insert_task_consumer_thread_num = 10;用于执行 Insert 任务的线程数，值应该大于 0，否则默认为 5.
-### 最佳实践
-
-- 合理的进行 Job 的管理，避免大量的 Job 同时触发，导致任务堆积，从而影响系统的正常运行。
-- 任务的执行间隔应该设置在一个合理的范围，至少应该大于任务执行时间。
-
-## 关键词
- CREATE, JOB
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/DROP-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/DROP-JOB.md
index d32093f7776..dfaa71ad7c9 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/DROP-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/DROP-JOB.md
@@ -24,28 +24,33 @@ specific language governing permissions and limitations
under the License.
-->
-
-
-
## 描述
用户删除一个 JOB 作业。作业会被立即停止同时删除。
+## 语法
+
```sql
-DROP JOB where jobName='jobname';
+DROP JOB where jobName = <job_name> ;
```
-## 示例
+## 必选参数
-1. 停止名称为 example 的作业。
+**1. `<job_name>`**
+> 删除任务的作业名称。
- ```sql
- DROP JOB where jobName='example';
- ```
+## 权限控制
+
+执行此 SQL 命令的用户必须至少具有以下权限：
-## 关键词
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
- STOP, JOB
+## 示例
-### 最佳实践
+- 删除名称为 example 的作业。
+ ```sql
+ DROP JOB where jobName='example';
+ ```
\ No newline at end of file
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/PAUSE-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/PAUSE-JOB.md
index db331eb15ba..83ad9fc2f53 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/PAUSE-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/PAUSE-JOB.md
@@ -24,30 +24,34 @@ specific language governing permissions and limitations
under the License.
-->
-
-
-
## 描述
用户暂停一个正在 RUNNING 状态的 JOB，正在运行的 TASK 会被中断，JOB 状态变更为 PAUSED。被停止的 JOB 可以通过 RESUME
操作恢复运行。
-使用此命令需要 ADMIN 权限。
+## 语法
```sql
-PAUSE JOB WHERE jobname= 'jobname';
+PAUSE JOB WHERE jobname = <job_name> ;
```
-## 示例
+## 必选参数
-1. 暂停名称为 example 的 JOB。
+**1. `<job_name>`**
+> 暂停任务的作业名称。
-```sql
- PAUSE JOB where jobname='example';
-```
+## 权限控制
+
+执行此 SQL 命令的用户必须至少具有以下权限：
-## 关键词
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
+
+## 示例
- PAUSE, JOB
+- 暂停名称为 example 的 JOB。
-### 最佳实践
+ ```sql
+ PAUSE JOB where jobname='example';
+ ```
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/RESUME-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/RESUME-JOB.md
index 1b6ac6c4bc5..d18911ab1ee 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/RESUME-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/sql-manual/sql-statements/job/RESUME-JOB.md
@@ -24,29 +24,32 @@ specific language governing permissions and limitations
under the License.
-->
-
-
-
-
## 描述
将处于 PAUSED 状态的 JOB 恢复为 RUNNING 状态。RUNNING 状态的 JOB 将会根据既定的调度周期去执行。
+## 语法
+
```sql
-RESUME JOB where jobName = jobName;
+RESUME JOB where jobName = <job_name> ;
```
+## 必选参数
-## 示例
+**1. `<job_name>`**
+> 恢复任务的作业名称。
-1. 恢复运行名称为 example 的 JOB。
+## 权限控制
- ```sql
- RESUME JOB where jobName= 'example';
- ```
+执行此 SQL 命令的用户必须至少具有以下权限：
-## 关键词
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
- RESUME, JOB
+## 示例
-### 最佳实践
+- 恢复运行名称为 example 的 JOB。
+ ```sql
+ RESUME JOB where jobName= 'example';
+ ```
\ No newline at end of file
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/CREATE-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/CREATE-JOB.md
index 70220d70ebe..3d3b703a71a 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/CREATE-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/CREATE-JOB.md
@@ -25,134 +25,135 @@ specific language governing permissions and limitations
under the License.
-->
-
-
-
## 描述
Doris Job 是根据既定计划运行的任务，用于在特定时间或指定时间间隔触发预定义的操作，从而帮助我们自动执行一些任务。从功能上来讲，它类似于操作系统上的
定时任务（如：Linux 中的 cron、Windows 中的计划任务）。
-
Job 有两种类型：`ONE_TIME` 和 `RECURRING`。其中 `ONE_TIME` 类型的 Job
会在指定的时间点触发，它主要用于一次性任务，而 `RECURRING` 类型的 Job 会在指定的时间间隔内循环触发，此方式主要用于周期性执行的任务。
-`RECURRING` 类型的 Job 可指定开始时间，结束时间，即 `STARTS\ENDS`, 如果不指定开始时间，则默认首次执行时间为当前时间 +
一次调度周期。如果指定结束时间，则 task 执行完成如果达到结束时间（或超过，或下次执行周期会超过结束时间）则更新为 FINISHED 状态，此时不会再产生
Task。
+`RECURRING` 类型的 Job 可指定开始时间，结束时间，即 `STARTS/ENDS`, 如果不指定开始时间，则默认首次执行时间为当前时间 加
一次调度周期。如果指定结束时间，则 task 执行完成如果达到结束时间（或超过，或下次执行周期会超过结束时间）则更新为 FINISHED 状态，此时不会再产生
Task。
-JOB 共 4 种状态（`RUNNING`,`STOPPED`,`PAUSED`,`FINISHED`,），初始状态为 RUNNING，RUNNING
状态的 JOB 会根据既定的调度周期去生成 TASK 执行，Job 执行完成达到结束时间则状态变更为 `FINISHED`.
+JOB 共 4 种状态（`RUNNING`,`STOPPED`,`PAUSED`,`FINISHED`），初始状态为 RUNNING，RUNNING 状态的
JOB 会根据既定的调度周期去生成 TASK 执行，Job 执行完成达到结束时间则状态变更为 `FINISHED`.
-RUNNING 状态的 JOB 可以被 pause，即暂停，此时不会再生成 Task。
+`PAUSED` 状态的 JOB 可以通过 RESUME 操作来恢复运行，更改为 `RUNNING` 状态。
-PAUSE 状态的 JOB 可以通过 RESUME 操作来恢复运行，更改为 RUNNING 状态。
+`STOPPED` 状态的 JOB 由用户主动触发，此时会 Cancel 正在运行中的作业，然后删除 JOB。
-STOP 状态的 JOB 由用户主动触发，此时会 Cancel 正在运行中的作业，然后删除 JOB。
+`Finished` 状态的 JOB 会保留在系统中 24 H，24H 后会被删除。
-Finished 状态的 JOB 会保留在系统中 24 H，24H 后会被删除。
+JOB 只描述作业信息，执行会生成 TASK，TASK 状态分为
`PENDING`，`RUNNING`，`SUCCEESS`,`FAILED`,`CANCELED`.
+`PENDING` 表示到达触发时间了但是等待资源 RUN，分配到资源后状态变更为 `RUNNING`，执行成功/失败即变更为
`SUCCESS`/`FAILED`.
+`CANCELED` 即取消状态，TASK 持久化最终状态，即 `SUCCESS`/`FAILED`，其他状态运行中可以查到，但是如果重启则不可见。
-JOB 只描述作业信息，执行会生成 TASK，TASK 状态分为 PENDING，RUNNING，SUCCEESS,FAILED,CANCELED
-PENDING 表示到达触发时间了但是等待资源 RUN，分配到资源后状态变更为 RUNNING，执行成功/失败即变更为 SUCCESS/FAILED.
-CANCELED 即取消状态，TASK 持久化最终状态，即 SUCCESS/FAILED，其他状态运行中可以查到，但是如果重启则不可见。TASK
只保留最新的 100 条记录。
+## 语法
-#### 权限
+```sql
-- 目前仅支持 ***ADMIN*** 权限执行此操作。
+CREATE
+ JOB
+ <job_name>
+ ON SCHEDULE <schedule>
+ [ COMMENT <string> ]
+ DO <sql_body> ;
+```
-#### 相关文档
+其中：
-- [暂停-JOB](../job/PAUSE-JOB.md)
-- [恢复-JOB](../job/RESUME-JOB.md)
-- [删除-JOB](../job/DROP-JOB.md)
-- [查询-JOB](../../../sql-manual/sql-functions/table-valued-functions/jobs.md)
-- [查询-TASKS](../../sql-functions/table-valued-functions/jobs.md)
+```sql
+schedule:
+ { AT <at_timestamp> | EVERY <interval> [STARTS <start_timestamp> ] [ENDS
<end_timestamp> ] }
+```
-### 语法
+其中：
```sql
-CREATE
- JOB
- job_name
- ON SCHEDULE schedule
- [COMMENT 'string']
- DO sql_body;
-
-schedule: {
- AT timestamp
- | EVERY interval
- [STARTS timestamp ]
- [ENDS timestamp ]
-}
-
interval:
quantity { WEEK | DAY | HOUR | MINUTE }
```
-一条有效的 Job 语句必须包含以下内容
+## 必选参数
-- 关键字 CREATE JOB 加上作业名称，它在一个 db 中标识唯一事件。JOB 名称必须是全局唯一的，如果已经存在同名的
JOB，则会报错。我们保留了 ***inner_*** 前缀在系统内部使用，因此用户不能创建以 ***inner_*** 开头的名称。
-- ON SCHEDULE 子句，它指定了 Job 作业的类型和触发时间以及频率。
-- DO 子句，它指定了 Job 作业触发时需要执行的操作，即一条 SQL 语句。
+**1. `<job_name>`**
+> 作业名称，它在一个 db 中标识唯一事件。JOB 名称必须是全局唯一的，如果已经存在同名的 JOB，则会报错。我们保留了 **inner_**
前缀在系统内部使用，因此用户不能创建以 **inner_** 开头的名称。
-这是一个最简单的例子：
+**2. `<schedule>`**
+> ON SCHEDULE 子句，指定了 Job 作业的类型和触发时间以及频率，它可以指定一次性作业或者周期性作业。
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1 SELECT *
FROM db2.tbl2;
-```
+**3. `<sql_body>`**
+> DO 子句，它指定了 Job 作业触发时需要执行的操作，即一条 SQL 语句。
-该语句表示创建一个名为 my_job 的作业，每分钟执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1 中。
+## 可选参数
-SCHEDULE 语句用于定义作业的执行时间，频率以及持续时间，它可以指定一次性作业或者周期性作业。
-- AT timestamp
+**1. `AT <at_timestamp>`**
+> 格式：'YYYY-MM-DD HH:MM:SS', 用于**一次性事件**，它指定事件仅在 给定的日期和时间执行一次
timestamp，当执行完成后，JOB 状态会变更为 FINISHED。
-格式：'YYYY-MM-DD HH:MM:SS', 用于一次性事件，它指定事件仅在 给定的日期和时间执行一次 timestamp，当执行完成后，JOB
状态会变更为 FINISHED。
+**2. `EVERY <interval>`**
+> 表示定期重复操作，它指定了作业的执行频率，关键字后面要指定一个时间间隔，该时间间隔可以是天、小时、分钟、秒、周。
-- EVERY
+**3. `STARTS <start_timestamp>`**
+> 格式：'YYYY-MM-DD HH:MM:SS',用于指定作业的开始时间，如果没有指定，则从当前时间的下一个时间点开始执行。开始时间必须大于当前时间。
- 表示定期重复操作，它指定了作业的执行频率，关键字后面要指定一个时间间隔，该时间间隔可以是天、小时、分钟、秒、周。
+**4. `ENDS <end_timestamp>`**
+> 格式：'YYYY-MM-DD HH:MM:SS', 用于指定作业的结束时间，如果没有指定，则表示永久执行。该日期必须大于当前时间，如果指定了开始时间，即
STARTS，则结束时间必须大于开始时间。
- - interval
+## 权限控制
- 用于指定作业执行频率，它可以是天、小时、分钟、周。例如：` 1 DAY` 表示每天执行一次，` 1 HOUR` 表示每小时执行一次，` 1
MINUTE` 表示每分钟执行一次，` 1 WEEK` 表示每周执行一次。
+执行此 SQL 命令的用户必须至少具有以下权限：
- - STARTS timestamp（可选字段）
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
- 格式：'YYYY-MM-DD
HH:MM:SS',用于指定作业的开始时间，如果没有指定，则从当前时间的下一个时间点开始执行。开始时间必须大于当前时间。
+## 注意事项
- - ENDS timestamp（可选字段）
+- TASK 只保留最新的 100 条记录。
- 格式：'YYYY-MM-DD HH:MM:SS',
用于指定作业的结束时间，如果没有指定，则表示永久执行。该日期必须大于当前时间，如果指定了开始时间，即 `STARTS`，则结束时间必须大于开始时间。
-
-- DO
+- 目前仅支持 **INSERT 内表** 操作，后续会支持更多的操作。
- 用于指定作业触发时需要执行的操作，目前仅支持 ***INSERT 内表*** 操作。后续我们会支持更多的操作。
+- 当下一个计划任务时间到期，即需要调度任务执行时，如果当前 JOB 仍有历史任务正在执行，则会跳过当前任务调度。因此控制一个合理的执行间隔非常重要。
## 示例
-创建一个一次性的 Job，它会在 2020-01-01 00:00:00 时执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1 中。
+- 创建一个名为 my_job 的作业，每分钟执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1 中。
-```sql
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1
SELECT * FROM db2.tbl2;
+ ```
-CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO db1.tbl1
SELECT * FROM db2.tbl2;
+- 创建一个一次性的 Job，它会在 2020-01-01 00:00:00 时执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1
中。
+
+ ```sql
+ CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO
db1.tbl1 SELECT * FROM db2.tbl2;
+ ```
-```
+- 创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中。
-创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中。
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
+ ```
+
+- 创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中，该 Job 在 2020-01-01 00:10:00 时结束。
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
-```
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00'
ENDS '2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add(now(),-1);
+ ```
-创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中，该 Job 在 2020-01-01 00:10:00 时结束。
+## 最佳实践
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' ENDS
'2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add(now(),-1);
-```
+- 合理的进行 Job 的管理，避免大量的 Job 同时触发，导致任务堆积，从而影响系统的正常运行。
+- 任务的执行间隔应该设置在一个合理的范围，至少应该大于任务执行时间。
-### INSERT JOB
+## 相关文档
-- 目前仅支持 ***INSERT 内表***
-- 当下一个计划任务时间到期，即需要调度任务执行时，如果当前 JOB 仍有历史任务正在执行，则会跳过当前任务调度。因此控制一个合理的执行间隔非常重要。
+- [暂停-JOB](../job/PAUSE-JOB.md)
+- [恢复-JOB](../job/RESUME-JOB.md)
+- [删除-JOB](../job/DROP-JOB.md)
+- [查询-JOB](../../../sql-manual/sql-functions/table-valued-functions/jobs.md)
+- [查询-TASKS](../../sql-functions/table-valued-functions/jobs.md)
-### CONFIG
+## CONFIG
-fe.conf
+**fe.conf**
- job_dispatch_timer_job_thread_num, 用于分发定时任务的线程数，默认值 2，如果含有大量周期执行任务，可以调大这个参数。
@@ -162,18 +163,4 @@ fe.conf
- job_insert_task_consumer_thread_num = 10;用于执行 Insert 任务的线程数，值应该大于 0，否则默认为 5.
-- job_dispatch_timer_job_queue_size, 任务堆积时用于存放定时任务的队列大小，默认值 1024.
如果有大量任务同一时间触发，可以调大这个参数。否则会导致队列满，提交任务会进入阻塞状态，从而导致后续任务无法提交。
-
-- finished_job_cleanup_threshold_time_hour, 用于清理已完成的任务的时间阈值，单位为小时，默认值为 24 小时。
-
-- job_insert_task_consumer_thread_num = 10;用于执行 Insert 任务的线程数，值应该大于 0，否则默认为 5.
-
-
-## 最佳实践
-
-- 合理的进行 Job 的管理，避免大量的 Job 同时触发，导致任务堆积，从而影响系统的正常运行。
-- 任务的执行间隔应该设置在一个合理的范围，至少应该大于任务执行时间。
-
-## 关键词
- CREATE, JOB
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/DROP-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/DROP-JOB.md
index ec250f9a94f..dfaa71ad7c9 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/DROP-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/DROP-JOB.md
@@ -24,27 +24,33 @@ specific language governing permissions and limitations
under the License.
-->
-
-
## 描述
用户删除一个 JOB 作业。作业会被立即停止同时删除。
+## 语法
+
```sql
-DROP JOB where jobName='jobname';
+DROP JOB where jobName = <job_name> ;
```
-## 示例
+## 必选参数
-1. 停止名称为 example 的作业。
+**1. `<job_name>`**
+> 删除任务的作业名称。
- ```sql
- DROP JOB where jobName='example';
- ```
+## 权限控制
+
+执行此 SQL 命令的用户必须至少具有以下权限：
-## 关键词
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
- STOP, JOB
+## 示例
-## 最佳实践
+- 删除名称为 example 的作业。
+ ```sql
+ DROP JOB where jobName='example';
+ ```
\ No newline at end of file
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/PAUSE-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/PAUSE-JOB.md
index 27f7651c904..83ad9fc2f53 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/PAUSE-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/PAUSE-JOB.md
@@ -24,31 +24,34 @@ specific language governing permissions and limitations
under the License.
-->
-
-
## 描述
-
用户暂停一个正在 RUNNING 状态的 JOB，正在运行的 TASK 会被中断，JOB 状态变更为 PAUSED。被停止的 JOB 可以通过 RESUME
操作恢复运行。
-
-使用此命令需要 ADMIN 权限。
+## 语法
```sql
-PAUSE JOB WHERE jobname= 'jobname';
+PAUSE JOB WHERE jobname = <job_name> ;
```
-## 示例
+## 必选参数
-1. 暂停名称为 example 的 JOB。
+**1. `<job_name>`**
+> 暂停任务的作业名称。
-```sql
- PAUSE JOB where jobname='example';
-```
+## 权限控制
+
+执行此 SQL 命令的用户必须至少具有以下权限：
-## 关键词
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
+
+## 示例
- PAUSE, JOB
+- 暂停名称为 example 的 JOB。
-## 最佳实践
+ ```sql
+ PAUSE JOB where jobname='example';
+ ```
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/RESUME-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/RESUME-JOB.md
index c5a55924db4..d18911ab1ee 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/RESUME-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/sql-manual/sql-statements/job/RESUME-JOB.md
@@ -24,26 +24,32 @@ specific language governing permissions and limitations
under the License.
-->
-
## 描述
将处于 PAUSED 状态的 JOB 恢复为 RUNNING 状态。RUNNING 状态的 JOB 将会根据既定的调度周期去执行。
+## 语法
+
```sql
-RESUME JOB where jobName = jobName;
+RESUME JOB where jobName = <job_name> ;
```
+## 必选参数
-## 示例
+**1. `<job_name>`**
+> 恢复任务的作业名称。
-1. 恢复运行名称为 example 的 JOB。
+## 权限控制
- ```sql
- RESUME JOB where jobName= 'example';
- ```
+执行此 SQL 命令的用户必须至少具有以下权限：
-## 关键词
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
- RESUME, JOB
+## 示例
-## 最佳实践
+- 恢复运行名称为 example 的 JOB。
+ ```sql
+ RESUME JOB where jobName= 'example';
+ ```
\ No newline at end of file
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/CREATE-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/CREATE-JOB.md
index bc07541fdb1..3d3b703a71a 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/CREATE-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/CREATE-JOB.md
@@ -25,134 +25,135 @@ specific language governing permissions and limitations
under the License.
-->
-
-
-
## 描述
Doris Job 是根据既定计划运行的任务，用于在特定时间或指定时间间隔触发预定义的操作，从而帮助我们自动执行一些任务。从功能上来讲，它类似于操作系统上的
定时任务（如：Linux 中的 cron、Windows 中的计划任务）。
Job 有两种类型：`ONE_TIME` 和 `RECURRING`。其中 `ONE_TIME` 类型的 Job
会在指定的时间点触发，它主要用于一次性任务，而 `RECURRING` 类型的 Job 会在指定的时间间隔内循环触发，此方式主要用于周期性执行的任务。
-`RECURRING` 类型的 Job 可指定开始时间，结束时间，即 `STARTS\ENDS`, 如果不指定开始时间，则默认首次执行时间为当前时间 +
一次调度周期。如果指定结束时间，则 task 执行完成如果达到结束时间（或超过，或下次执行周期会超过结束时间）则更新为 FINISHED 状态，此时不会再产生
Task。
+`RECURRING` 类型的 Job 可指定开始时间，结束时间，即 `STARTS/ENDS`, 如果不指定开始时间，则默认首次执行时间为当前时间 加
一次调度周期。如果指定结束时间，则 task 执行完成如果达到结束时间（或超过，或下次执行周期会超过结束时间）则更新为 FINISHED 状态，此时不会再产生
Task。
-JOB 共 4 种状态（`RUNNING`,`STOPPED`,`PAUSED`,`FINISHED`,），初始状态为 RUNNING，RUNNING
状态的 JOB 会根据既定的调度周期去生成 TASK 执行，Job 执行完成达到结束时间则状态变更为 `FINISHED`.
+JOB 共 4 种状态（`RUNNING`,`STOPPED`,`PAUSED`,`FINISHED`），初始状态为 RUNNING，RUNNING 状态的
JOB 会根据既定的调度周期去生成 TASK 执行，Job 执行完成达到结束时间则状态变更为 `FINISHED`.
-RUNNING 状态的 JOB 可以被 pause，即暂停，此时不会再生成 Task。
+`PAUSED` 状态的 JOB 可以通过 RESUME 操作来恢复运行，更改为 `RUNNING` 状态。
-PAUSE 状态的 JOB 可以通过 RESUME 操作来恢复运行，更改为 RUNNING 状态。
+`STOPPED` 状态的 JOB 由用户主动触发，此时会 Cancel 正在运行中的作业，然后删除 JOB。
-STOP 状态的 JOB 由用户主动触发，此时会 Cancel 正在运行中的作业，然后删除 JOB。
+`Finished` 状态的 JOB 会保留在系统中 24 H，24H 后会被删除。
-Finished 状态的 JOB 会保留在系统中 24 H，24H 后会被删除。
+JOB 只描述作业信息，执行会生成 TASK，TASK 状态分为
`PENDING`，`RUNNING`，`SUCCEESS`,`FAILED`,`CANCELED`.
+`PENDING` 表示到达触发时间了但是等待资源 RUN，分配到资源后状态变更为 `RUNNING`，执行成功/失败即变更为
`SUCCESS`/`FAILED`.
+`CANCELED` 即取消状态，TASK 持久化最终状态，即 `SUCCESS`/`FAILED`，其他状态运行中可以查到，但是如果重启则不可见。
-JOB 只描述作业信息，执行会生成 TASK，TASK 状态分为 PENDING，RUNNING，SUCCEESS,FAILED,CANCELED
-PENDING 表示到达触发时间了但是等待资源 RUN，分配到资源后状态变更为 RUNNING，执行成功/失败即变更为 SUCCESS/FAILED.
-CANCELED 即取消状态，TASK 持久化最终状态，即 SUCCESS/FAILED，其他状态运行中可以查到，但是如果重启则不可见。TASK
只保留最新的 100 条记录。
+## 语法
-#### 权限
-
-- 目前仅支持 ***ADMIN*** 权限执行此操作。
+```sql
-#### 相关文档
+CREATE
+ JOB
+ <job_name>
+ ON SCHEDULE <schedule>
+ [ COMMENT <string> ]
+ DO <sql_body> ;
+```
+其中：
-- [暂停-JOB](../job/PAUSE-JOB.md)
-- [恢复-JOB](../job/RESUME-JOB.md)
-- [删除-JOB](../job/DROP-JOB.md)
-- [查询-JOB](../../../sql-manual/sql-functions/table-valued-functions/jobs.md)
-- [查询-TASKS](../../sql-functions/table-valued-functions/jobs.md)
+```sql
+schedule:
+ { AT <at_timestamp> | EVERY <interval> [STARTS <start_timestamp> ] [ENDS
<end_timestamp> ] }
+```
-### 语法
+其中：
```sql
-CREATE
- JOB
- job_name
- ON SCHEDULE schedule
- [COMMENT 'string']
- DO sql_body;
-
-schedule: {
- AT timestamp
- | EVERY interval
- [STARTS timestamp ]
- [ENDS timestamp ]
-}
-
interval:
quantity { WEEK | DAY | HOUR | MINUTE }
```
-一条有效的 Job 语句必须包含以下内容
-
-- 关键字 CREATE JOB 加上作业名称，它在一个 db 中标识唯一事件。JOB 名称必须是全局唯一的，如果已经存在同名的
JOB，则会报错。我们保留了 ***inner_*** 前缀在系统内部使用，因此用户不能创建以 ***inner_*** 开头的名称。
-- ON SCHEDULE 子句，它指定了 Job 作业的类型和触发时间以及频率。
-- DO 子句，它指定了 Job 作业触发时需要执行的操作，即一条 SQL 语句。
+## 必选参数
-这是一个最简单的例子：
+**1. `<job_name>`**
+> 作业名称，它在一个 db 中标识唯一事件。JOB 名称必须是全局唯一的，如果已经存在同名的 JOB，则会报错。我们保留了 **inner_**
前缀在系统内部使用，因此用户不能创建以 **inner_** 开头的名称。
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1 SELECT *
FROM db2.tbl2;
-```
+**2. `<schedule>`**
+> ON SCHEDULE 子句，指定了 Job 作业的类型和触发时间以及频率，它可以指定一次性作业或者周期性作业。
-该语句表示创建一个名为 my_job 的作业，每分钟执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1 中。
+**3. `<sql_body>`**
+> DO 子句，它指定了 Job 作业触发时需要执行的操作，即一条 SQL 语句。
-SCHEDULE 语句用于定义作业的执行时间，频率以及持续时间，它可以指定一次性作业或者周期性作业。
-- AT timestamp
+## 可选参数
-格式：'YYYY-MM-DD HH:MM:SS', 用于一次性事件，它指定事件仅在 给定的日期和时间执行一次 timestamp，当执行完成后，JOB
状态会变更为 FINISHED。
+**1. `AT <at_timestamp>`**
+> 格式：'YYYY-MM-DD HH:MM:SS', 用于**一次性事件**，它指定事件仅在 给定的日期和时间执行一次
timestamp，当执行完成后，JOB 状态会变更为 FINISHED。
-- EVERY
+**2. `EVERY <interval>`**
+> 表示定期重复操作，它指定了作业的执行频率，关键字后面要指定一个时间间隔，该时间间隔可以是天、小时、分钟、秒、周。
- 表示定期重复操作，它指定了作业的执行频率，关键字后面要指定一个时间间隔，该时间间隔可以是天、小时、分钟、秒、周。
+**3. `STARTS <start_timestamp>`**
+> 格式：'YYYY-MM-DD HH:MM:SS',用于指定作业的开始时间，如果没有指定，则从当前时间的下一个时间点开始执行。开始时间必须大于当前时间。
- - interval
+**4. `ENDS <end_timestamp>`**
+> 格式：'YYYY-MM-DD HH:MM:SS', 用于指定作业的结束时间，如果没有指定，则表示永久执行。该日期必须大于当前时间，如果指定了开始时间，即
STARTS，则结束时间必须大于开始时间。
- 用于指定作业执行频率，它可以是天、小时、分钟、周。例如：` 1 DAY` 表示每天执行一次，` 1 HOUR` 表示每小时执行一次，` 1
MINUTE` 表示每分钟执行一次，` 1 WEEK` 表示每周执行一次。
+## 权限控制
- - STARTS timestamp（可选字段）
+执行此 SQL 命令的用户必须至少具有以下权限：
- 格式：'YYYY-MM-DD
HH:MM:SS',用于指定作业的开始时间，如果没有指定，则从当前时间的下一个时间点开始执行。开始时间必须大于当前时间。
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
- - ENDS timestamp（可选字段）
+## 注意事项
- 格式：'YYYY-MM-DD HH:MM:SS',
用于指定作业的结束时间，如果没有指定，则表示永久执行。该日期必须大于当前时间，如果指定了开始时间，即 `STARTS`，则结束时间必须大于开始时间。
+- TASK 只保留最新的 100 条记录。
-- DO
+- 目前仅支持 **INSERT 内表** 操作，后续会支持更多的操作。
- 用于指定作业触发时需要执行的操作，目前仅支持 ***INSERT 内表*** 操作。后续我们会支持更多的操作。
+- 当下一个计划任务时间到期，即需要调度任务执行时，如果当前 JOB 仍有历史任务正在执行，则会跳过当前任务调度。因此控制一个合理的执行间隔非常重要。
## 示例
-创建一个一次性的 Job，它会在 2020-01-01 00:00:00 时执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1 中。
+- 创建一个名为 my_job 的作业，每分钟执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1 中。
-```sql
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1
SELECT * FROM db2.tbl2;
+ ```
-CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO db1.tbl1
SELECT * FROM db2.tbl2;
+- 创建一个一次性的 Job，它会在 2020-01-01 00:00:00 时执行一次，执行的操作是将 db2.tbl2 中的数据导入到 db1.tbl1
中。
+
+ ```sql
+ CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO
db1.tbl1 SELECT * FROM db2.tbl2;
+ ```
-```
+- 创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中。
-创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中。
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
+ ```
+
+- 创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中，该 Job 在 2020-01-01 00:10:00 时结束。
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
-```
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00'
ENDS '2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add(now(),-1);
+ ```
-创建一个周期性的 Job，它会在 2020-01-01 00:00:00 时开始执行，每天执行一次，执行的操作是将 db2.tbl2 中的数据导入到
db1.tbl1 中，该 Job 在 2020-01-01 00:10:00 时结束。
+## 最佳实践
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' ENDS
'2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add(now(),-1);
-```
+- 合理的进行 Job 的管理，避免大量的 Job 同时触发，导致任务堆积，从而影响系统的正常运行。
+- 任务的执行间隔应该设置在一个合理的范围，至少应该大于任务执行时间。
-### INSERT JOB
+## 相关文档
-- 目前仅支持 ***INSERT 内表***
-- 当下一个计划任务时间到期，即需要调度任务执行时，如果当前 JOB 仍有历史任务正在执行，则会跳过当前任务调度。因此控制一个合理的执行间隔非常重要。
+- [暂停-JOB](../job/PAUSE-JOB.md)
+- [恢复-JOB](../job/RESUME-JOB.md)
+- [删除-JOB](../job/DROP-JOB.md)
+- [查询-JOB](../../../sql-manual/sql-functions/table-valued-functions/jobs.md)
+- [查询-TASKS](../../sql-functions/table-valued-functions/jobs.md)
-### CONFIG
+## CONFIG
-fe.conf
+**fe.conf**
- job_dispatch_timer_job_thread_num, 用于分发定时任务的线程数，默认值 2，如果含有大量周期执行任务，可以调大这个参数。
@@ -162,11 +163,4 @@ fe.conf
- job_insert_task_consumer_thread_num = 10;用于执行 Insert 任务的线程数，值应该大于 0，否则默认为 5.
-### 最佳实践
-
-- 合理的进行 Job 的管理，避免大量的 Job 同时触发，导致任务堆积，从而影响系统的正常运行。
-- 任务的执行间隔应该设置在一个合理的范围，至少应该大于任务执行时间。
-
-## 关键词
- CREATE, JOB
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/DROP-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/DROP-JOB.md
index d32093f7776..dfaa71ad7c9 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/DROP-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/DROP-JOB.md
@@ -24,28 +24,33 @@ specific language governing permissions and limitations
under the License.
-->
-
-
-
## 描述
用户删除一个 JOB 作业。作业会被立即停止同时删除。
+## 语法
+
```sql
-DROP JOB where jobName='jobname';
+DROP JOB where jobName = <job_name> ;
```
-## 示例
+## 必选参数
-1. 停止名称为 example 的作业。
+**1. `<job_name>`**
+> 删除任务的作业名称。
- ```sql
- DROP JOB where jobName='example';
- ```
+## 权限控制
+
+执行此 SQL 命令的用户必须至少具有以下权限：
-## 关键词
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
- STOP, JOB
+## 示例
-### 最佳实践
+- 删除名称为 example 的作业。
+ ```sql
+ DROP JOB where jobName='example';
+ ```
\ No newline at end of file
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/PAUSE-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/PAUSE-JOB.md
index db331eb15ba..83ad9fc2f53 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/PAUSE-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/PAUSE-JOB.md
@@ -24,30 +24,34 @@ specific language governing permissions and limitations
under the License.
-->
-
-
-
## 描述
用户暂停一个正在 RUNNING 状态的 JOB，正在运行的 TASK 会被中断，JOB 状态变更为 PAUSED。被停止的 JOB 可以通过 RESUME
操作恢复运行。
-使用此命令需要 ADMIN 权限。
+## 语法
```sql
-PAUSE JOB WHERE jobname= 'jobname';
+PAUSE JOB WHERE jobname = <job_name> ;
```
-## 示例
+## 必选参数
-1. 暂停名称为 example 的 JOB。
+**1. `<job_name>`**
+> 暂停任务的作业名称。
-```sql
- PAUSE JOB where jobname='example';
-```
+## 权限控制
+
+执行此 SQL 命令的用户必须至少具有以下权限：
-## 关键词
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
+
+## 示例
- PAUSE, JOB
+- 暂停名称为 example 的 JOB。
-### 最佳实践
+ ```sql
+ PAUSE JOB where jobname='example';
+ ```
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/RESUME-JOB.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/RESUME-JOB.md
index 1b6ac6c4bc5..d18911ab1ee 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/RESUME-JOB.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/sql-manual/sql-statements/job/RESUME-JOB.md
@@ -24,29 +24,32 @@ specific language governing permissions and limitations
under the License.
-->
-
-
-
-
## 描述
将处于 PAUSED 状态的 JOB 恢复为 RUNNING 状态。RUNNING 状态的 JOB 将会根据既定的调度周期去执行。
+## 语法
+
```sql
-RESUME JOB where jobName = jobName;
+RESUME JOB where jobName = <job_name> ;
```
+## 必选参数
-## 示例
+**1. `<job_name>`**
+> 恢复任务的作业名称。
-1. 恢复运行名称为 example 的 JOB。
+## 权限控制
- ```sql
- RESUME JOB where jobName= 'example';
- ```
+执行此 SQL 命令的用户必须至少具有以下权限：
-## 关键词
+| 权限（Privilege） | 对象（Object） | 说明（Notes） |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | 数据库（DB） | 目前仅支持 **ADMIN** 权限执行此操作 |
- RESUME, JOB
+## 示例
-### 最佳实践
+- 恢复运行名称为 example 的 JOB。
+ ```sql
+ RESUME JOB where jobName= 'example';
+ ```
\ No newline at end of file
diff --git
a/versioned_docs/version-2.1/sql-manual/sql-statements/job/CREATE-JOB.md
b/versioned_docs/version-2.1/sql-manual/sql-statements/job/CREATE-JOB.md
index 1e3b20d5e82..840a9d8fa08 100644
--- a/versioned_docs/version-2.1/sql-manual/sql-statements/job/CREATE-JOB.md
+++ b/versioned_docs/version-2.1/sql-manual/sql-statements/job/CREATE-JOB.md
@@ -25,142 +25,140 @@ specific language governing permissions and limitations
under the License.
-->
-
## Description
-Doris Job is a task that runs according to a predefined schedule, triggering
predefined actions at specific times or intervals to help automate certain
tasks. In terms of functionality, it is similar to scheduled tasks on operating
systems (e.g., cron in Linux, scheduled tasks in Windows).↳
-
-There are two types of Jobs: ONE_TIME and RECURRING. The ONE_TIME type of Job
triggers at a specified time point and is mainly used for one-time tasks, while
the RECURRING type of Job triggers at specified time intervals and is used for
periodically recurring tasks. The RECURRING type of Job can specify a start
time and an end time using STARTS\ENDS. If the start time is not specified, the
first execution time is set to the current time plus one scheduling period. If
the end time is spec [...]
-
-#### Job Status
-
-A Job has four states (RUNNING, STOPPED, PAUSED, FINISHED), with the initial
state being RUNNING. A Job in the RUNNING state generates Tasks based on the
specified scheduling period. When a Job completes execution and reaches the end
time, the status changes to FINISHED.
+Doris Job is a task that runs according to a set plan. It is used to trigger
predefined operations at a specific time or a specified time interval, so as to
help us automatically perform some tasks. Functionally, it is similar to the
scheduled task on the operating system (such as cron in Linux and scheduled
tasks in Windows).
-A Job in the RUNNING state can be paused, which means it will no longer
generate Tasks.
+There are two types of jobs: `ONE_TIME` and `RECURRING`. Among them, the
`ONE_TIME` type of job will be triggered at a specified time point. It is
mainly used for one-time tasks, while the `RECURRING` type of job will be
triggered cyclically within a specified time interval. This method is mainly
used for periodic tasks.
+The `RECURRING` type of job can specify the start time and end time, that is,
`STARTS/ENDS`. If the start time is not specified, the default first execution
time is the current time + one scheduling cycle. If the end time is specified,
the task execution is completed. If the end time is reached (or exceeded, or
the next execution cycle will exceed the end time), it will be updated to the
FINISHED state, and no more tasks will be generated at this time.
-A Job in the PAUSED state can be resumed by performing the RESUME operation,
changing the state to RUNNING.
+There are 4 states for a job (`RUNNING`, `STOPPED`, `PAUSED`, `FINISHED`).
-A Job in the STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+The initial state is `RUNNING`. A job in the `RUNNING` state will generate a
TASK for execution according to the established scheduling cycle. When the job
is completed and reaches the end time, the state changes to `FINISHED`.
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+A job in the `PAUSED` state can be resumed through the RESUME operation and
changed to the RUNNING state.
-#### Task status
+A job in the `STOPPED` state is actively triggered by the user, and the
running job will be canceled and the job will be deleted.
-A Job only describes the job information, and the execution generates Tasks.
The Task status can be PENDING, RUNNING, SUCCESS, FAILED, or CANCELED.
+A job in the `FINISHED` state will be retained in the system for 24 hours and
will be deleted after 24 hours.
-PENDING indicates that the trigger time has been reached but resources are
awaited for running. Once resources are allocated, the status changes to
RUNNING. When the execution is successful or fails, the status changes to
SUCCESS or FAILED, respectively.
+JOB only describes job information. Execution will generate TASK. TASK status
is divided into `PENDING`, `RUNNING`, `SUCCEESS`, `FAILED`, `CANCELED`
+`PENDING` means that the trigger time has arrived but the resource run is
waiting. After the resource is allocated, the status changes to `RUNNING`.
Success/failure of execution changes to `SUCCESS`/`FAILED`.
+`CANCELED` means cancellation status. TASK persists the final status, i.e.
`SUCCESS`/`FAILED`. Other statuses can be checked during operation, but will
not be visible if restarted.
-CANCELED indicates the cancellation status. The final status of a Task is
persisted as SUCCESS or FAILED. Other statuses can be queried while the Task is
running, but they become invisible after a restart. Only the latest 100 Task
records are retained.
+## Syntax
-#### Permissions
-
-Currently, only users with the ADMIN role can perform this operation.
+```sql
+CREATE
+ JOB
+ <job_name>
+ ON SCHEDULE <schedule>
+ [ COMMENT <string> ]
+ DO <sql_body>
+```
-#### Related Documentation
+Where:
-- [PAUSE-JOB](../Alter/PAUSE-JOB.md)
-- [RESUME-JOB](../Alter/RESUME-JOB.md)
-- [DROP-JOB](../Drop/DROP-JOB.md)
-- [VIEW-JOB](../../../sql-functions/table-valued-functions/jobs.md),
-- [VIEW-TASKS](../../../sql-functions/table-valued-functions/tasks.md)
+```sql
+schedule:
+ { AT <at_timestamp> | EVERY <interval> [STARTS <start_timestamp> ] [ENDS
<end_timestamp> ] }
+```
-### Grammar
+Where:
```sql
-CREATE
- job
- job_name
- ON SCHEDULE schedule
- [COMMENT 'string']
- DO sql_body;
-
-schedule: {
- AT timestamp
- | EVERY interval
- [STARTS timestamp]
- [ENDS timestamp ]
-}
-
interval:
- quantity { DAY | HOUR | MINUTE |
- WEEK | SECOND }
+ quantity { WEEK | DAY | HOUR | MINUTE }
```
-A valid Job statement must contain the following
+## Required parameters
-- The keyword CREATE JOB plus the job name, which uniquely identifies the
event within a database. The job name must be globally unique, and if a JOB
with the same name already exists, an error will be reported. We reserve the
inner_ prefix for internal use, so users cannot create names starting with
***inner_***.
-- The ON SCHEDULE clause, which specifies the type of Job and when and how
often to trigger it.
-- The DO clause, which specifies the actions that need to be performed when
the Job is triggered.
+**1. `<job_name>`**
+> Job name, which identifies a unique event in a db. The job name must be
globally unique. If a job with the same name already exists, an error will be
reported. We reserve the **inner_** prefix for internal use in the system, so
users cannot create names starting with **inner_**.
-Here is a minimal example:
+**2. `<schedule>`**
+> The ON SCHEDULE clause specifies the type, triggering time and frequency of
the job. It can specify a one-time job or a periodic job.
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1 SELECT *
FROM db2.tbl2;
-```
-
-This statement means to create a job named my_job to be executed every minute,
and the operation performed is to import the data in db2.tbl2 into db1.tbl1.
+**3. `<sql_body>`**
+> The DO clause specifies the operation to be performed when the job is
triggered, that is, a SQL statement.
-The SCHEDULE statement is used to define the execution time, frequency and
duration of the job, which can specify a one-time job or a periodic job.
-- AT timestamp
+## Optional parameters
-Format: 'YYYY-MM-DD HH:MM:SS'. Used for one-time events, it specifies that the
event should only be executed once at the given date and time. Once the
execution is complete, the Job status changes to FINISHED.
+**1. `AT <at_timestamp>`**
+> Format: 'YYYY-MM-DD HH:MM:SS', used for **one-time events**, it specifies
that the event is executed only once at a given date and time timestamp, and
when the execution is completed, the job status will change to FINISHED.
-- EVERY
+**2. `EVERY <interval>`**
+> Indicates a regularly repeated operation, it specifies the execution
frequency of the job, and a time interval must be specified after the keyword,
which can be days, hours, minutes, seconds, or weeks.
- Indicates that the operation is repeated periodically, which specifies the
execution frequency of the job. After the keyword, a time interval should be
specified, which can be days, hours, minutes, seconds, and weeks.
+**3. `STARTS <start_timestamp>`**
+> Format: 'YYYY-MM-DD HH:MM:SS', used to specify the start time of the job. If
not specified, it will be executed from the next time point after the current
time. The start time must be greater than the current time.
- - interval
+**4. `ENDS <end_timestamp>`**
+> Format: 'YYYY-MM-DD HH:MM:SS', used to specify the end time of the job. If
not specified, it means permanent execution. The date must be greater than the
current time. If the start time is specified, that is, STARTS, the end time
must be greater than the start time.
- Used to specify the Job execution frequency, which can be `day`, `hour`,
`minute`, or `week`. For example, 1 `DAY` means the Job will run once every
day, 1 `HOUR` means once every hour, 1 `MINUTE` means once every minute, and `1
The CREATE JOB statement is used to create a job in a database. A job is a task
that can be scheduled to run at specific times or intervals to automate certain
actions.
+## Access Control Requirements
- - STARTS timestamp(optional)
+The user who executes this SQL command must have at least the following
permissions:
- Format: 'YYYY-MM-DD HH:MM:SS'. It is used to specify the start time of the
job. If not specified, the job starts executing from the next occurrence based
on the current time. The start time must be greater than the current time.
+| Privilege | Object | Notes
|
+|:--------------|:-----------|:------------------------------------------------------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions
to perform this operation |
- - ENDS timestamp(optional)
+## Usage Notes
- Format: 'YYYY-MM-DD HH:MM:SS'. It is used to specify the end time of the
job. If not specified, it means the job executes indefinitely. The end date
must be greater than the current time. If a start time (↳STARTS) is specified,
the end time must be greater than the start time.
+- TASK only retains the latest 100 records.
-- DO
+- Currently only supports **INSERT internal table** operations, and will
support more operations in the future.
- It is used to specify the operation that needs to be performed when the job
is triggered. Currently, all ***INSERT*** operations are supported. We will
support more operations in the future.
+- When the next scheduled task time expires, that is, when the task needs to
be scheduled for execution, if the current JOB still has historical tasks being
executed, the current task scheduling will be skipped. Therefore, it is very
important to control a reasonable execution interval.
## Examples
-Create a one-time job, which will be executed once at 2020-01-01 00:00:00, and
the operation performed is to import the data in db2.tbl2 into db1.tbl1.
+- Create a job named my_job, which is executed once every minute. The
operation performed is to import the data in db2.tbl2 into db1.tbl1.
-```sql
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1 SELECT
* FROM db2.tbl2;
+ ```
-CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO db1.tbl1
SELECT * FROM db2.tbl2;
+- Create a one-time job that will be executed once at 2020-01-01 00:00:00 to
import the data in db2.tbl2 into db1.tbl1.
-```
+ ```sql
+ CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO
db1.tbl1 SELECT * FROM db2.tbl2;
+ ```
-Create a periodic Job, which will start to execute at 2020-01-01 00:00:00,
once a day, and the operation is to import the data in db2.tbl2 into db1.tbl1.
+- Create a periodic Job that will start executing at 2020-01-01 00:00:00 and
execute once a day. The operation performed is to import the data in db2.tbl2
into db1.tbl1.
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
-```
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
+ ```
-Create a periodic Job, which will start to execute at 2020-01-01 00:00:00, and
execute once a day. The operation performed is to import the data in db2.tbl2
into db1.tbl1. This Job will be executed in 2020 Ends at -01-01 00:10:00.
+- Create a periodic job that will start at 2020-01-01 00:00:00 and execute
once a day. The operation is to import the data in db2.tbl2 into db1.tbl1. The
job ends at 2020-01-01 00:10:00.
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' ENDS
'2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add (now(),-1);
-```
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' ENDS
'2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add(now(),-1);
+ ```
+
+## Best Practices
+
+- Manage jobs reasonably to avoid a large number of jobs being triggered at
the same time, which will cause task accumulation and affect the normal
operation of the system.
+- The task execution interval should be set within a reasonable range, at
least greater than the task execution time.
+
+## Related Documents
-### CONFIG
+- [Pause-JOB](../job/PAUSE-JOB.md)
+- [Resume-JOB](../job/RESUME-JOB.md)
+- [Delete-JOB](../job/DROP-JOB.md)
+- [Query-JOB](../../../sql-manual/sql-functions/table-valued-functions/jobs.md)
+- [Query-TASKS](../../sql-functions/table-valued-functions/jobs.md)
-#### fe.conf
+## CONFIG
-- job_dispatch_timer_job_thread_num: Number of threads used for dispatching
scheduled tasks. Default value is 2. If there are a large number of
periodically executed tasks, this parameter can be increased.
-- job_dispatch_timer_job_queue_size: Size of the queue used for storing
scheduled tasks when there is task accumulation. Default value is 1024. If
there are a large number of tasks triggered at the same time, this parameter
can be increased. Otherwise, the queue may become full and submitting tasks
will be blocked, causing subsequent tasks to be unable to submit.
-- finished_job_cleanup_threshold_time_hour: Time threshold, in hours, for
cleaning up completed tasks. Default value is 24 hours.
-- job_insert_task_consumer_thread_num: Number of threads used for executing
Insert tasks. The value should be greater than 0, otherwise the default value
is 5.
+**fe.conf**
-## Best Practice
+- job_dispatch_timer_job_thread_num, the number of threads used to distribute
timed tasks, the default value is 2, if there are a large number of periodic
execution tasks, you can increase this parameter.
-- Properly manage Jobs to avoid triggering a large number of Jobs
simultaneously, which can lead to task accumulation and affect the normal
operation of the system.
-- Set the execution interval of tasks within a reasonable range, ensuring that
it is at least greater than the task execution time.
+- job_dispatch_timer_job_queue_size, the queue size for storing timed tasks
when tasks are accumulated, the default value is 1024. If a large number of
tasks are triggered at the same time, this parameter can be increased.
Otherwise, the queue will be full, and the submitted task will enter a blocked
state, which will cause subsequent tasks to fail to submit.
-## Keywords
+- finished_job_cleanup_threshold_time_hour, the time threshold for cleaning up
completed tasks, in hours, the default value is 24 hours.
- CREATE, JOB, SCHEDULE
+- job_insert_task_consumer_thread_num = 10; the number of threads used to
execute Insert tasks, the value should be greater than 0, otherwise the default
value is 5.
\ No newline at end of file
diff --git
a/versioned_docs/version-2.1/sql-manual/sql-statements/job/DROP-JOB.md
b/versioned_docs/version-2.1/sql-manual/sql-statements/job/DROP-JOB.md
index 658827896eb..530a9cb567d 100644
--- a/versioned_docs/version-2.1/sql-manual/sql-statements/job/DROP-JOB.md
+++ b/versioned_docs/version-2.1/sql-manual/sql-statements/job/DROP-JOB.md
@@ -24,27 +24,33 @@ specific language governing permissions and limitations
under the License.
-->
-
-
## Description
-User stops a JOB. A stopped job cannot be resumed.
+The user deletes a JOB job. The job will be stopped and deleted immediately.
+
+## Syntax
```sql
-DROP JOB WHERE jobName = 'job_name';
+DROP JOB where jobName = <job_name> ;
```
-## Examples
+## Required parameters
+
+**1. `<job_name>`**
+> The `<job_name>` of the task to be deleted.
-1. DROP the job named test1.
+## Access Control Requirements
- ```sql
- DROP JOB where jobName = 'test1';
- ```
+The user who executes this SQL command must have at least the following
permissions:
-## Keywords
+| Privilege | Object | Notes |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions to
perform this operation |
- DROP, JOB
+## Examples
-## Best Practice
+- Delete the job named example.
+ ```sql
+ DROP JOB where jobName='example';
+ ```
\ No newline at end of file
diff --git
a/versioned_docs/version-2.1/sql-manual/sql-statements/job/PAUSE-JOB.md
b/versioned_docs/version-2.1/sql-manual/sql-statements/job/PAUSE-JOB.md
index 2686e2e7a14..dc55b74387a 100644
--- a/versioned_docs/version-2.1/sql-manual/sql-statements/job/PAUSE-JOB.md
+++ b/versioned_docs/version-2.1/sql-manual/sql-statements/job/PAUSE-JOB.md
@@ -24,27 +24,33 @@ specific language governing permissions and limitations
under the License.
-->
-
-
-
## Description
-User suspends a JOB. A stopped job can be resumed with RESUME JOB.
+When a user pauses a job in the RUNNING state, the running task will be
interrupted and the job state will be changed to PAUSED. The stopped job can be
resumed by the RESUME operation.
+
+## Syntax
```sql
-PAUSE JOB where jobName = 'job_name';
+PAUSE JOB WHERE jobname = <job_name> ;
```
-## Examples
+## Required parameters
+
+**1. `<job_name>`**
+> The name of the job to be paused.
-1. Pause the job named test1.
+## Access Control Requirements
- ```sql
- PAUSE JOB where jobName = 'test1';
- ```
+The user who executes this SQL command must have at least the following
permissions:
-## Keywords
+| Privilege | Object | Notes |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions to
perform this operation |
+
+## Examples
- PAUSE, JOB
+- Pause the job named example.
-## Best Practice
+ ```sql
+ PAUSE JOB where jobname='example';
+ ```
\ No newline at end of file
diff --git
a/versioned_docs/version-2.1/sql-manual/sql-statements/job/RESUME-JOB.md
b/versioned_docs/version-2.1/sql-manual/sql-statements/job/RESUME-JOB.md
index 6cd8920d9b6..b106837ccb4 100644
--- a/versioned_docs/version-2.1/sql-manual/sql-statements/job/RESUME-JOB.md
+++ b/versioned_docs/version-2.1/sql-manual/sql-statements/job/RESUME-JOB.md
@@ -24,31 +24,32 @@ specific language governing permissions and limitations
under the License.
-->
-
-
-
-
## Description
-Used to restart a JOB in PAUSE state. The restarted job will continue to be
executed periodically. A JOB in STOP state cannot be resumed.
+Restore the PAUSED job to the RUNNING state. The RUNNING job will be executed
according to the scheduled period.
+
+## Syntax
```sql
-RESUME JOB WHERE jobName = 'job_name';
+RESUME JOB where jobName = <job_name> ;
```
+## Required parameters
-## Examples
+**1. `<job_name>`**
+> The `<job_name>` of the recovery task.
-1. Restart the JOB named test1.
+## Access Control Requirements
- ```sql
- RESUME JOB WHERE jobName = 'test1';
- ```
-
-## Keywords
-
- RESUME, JOB
+The user who executes this SQL command must have at least the following
permissions:
-## Best Practice
+| Privilege | Object | Notes |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions to
perform this operation |
+## Example
+- Resume the job named example.
+ ```sql
+ RESUME JOB where jobName= 'example';
+ ```
diff --git
a/versioned_docs/version-3.0/sql-manual/sql-statements/job/CREATE-JOB.md
b/versioned_docs/version-3.0/sql-manual/sql-statements/job/CREATE-JOB.md
index f8127931b2c..840a9d8fa08 100644
--- a/versioned_docs/version-3.0/sql-manual/sql-statements/job/CREATE-JOB.md
+++ b/versioned_docs/version-3.0/sql-manual/sql-statements/job/CREATE-JOB.md
@@ -25,147 +25,140 @@ specific language governing permissions and limitations
under the License.
-->
-:::tip
-
-This statement is supported since 2.1
-
-:::
-
## Description
-Doris Job is a task that runs according to a predefined schedule, triggering
predefined actions at specific times or intervals to help automate certain
tasks. In terms of functionality, it is similar to scheduled tasks on operating
systems (e.g., cron in Linux, scheduled tasks in Windows).↳
-
-There are two types of Jobs: ONE_TIME and RECURRING. The ONE_TIME type of Job
triggers at a specified time point and is mainly used for one-time tasks, while
the RECURRING type of Job triggers at specified time intervals and is used for
periodically recurring tasks. The RECURRING type of Job can specify a start
time and an end time using STARTS\ENDS. If the start time is not specified, the
first execution time is set to the current time plus one scheduling period. If
the end time is spec [...]
-
-#### Job Status
-
-A Job has four states (RUNNING, STOPPED, PAUSED, FINISHED), with the initial
state being RUNNING. A Job in the RUNNING state generates Tasks based on the
specified scheduling period. When a Job completes execution and reaches the end
time, the status changes to FINISHED.
-
-A Job in the RUNNING state can be paused, which means it will no longer
generate Tasks.
+Doris Job is a task that runs according to a set plan. It is used to trigger
predefined operations at a specific time or a specified time interval, so as to
help us automatically perform some tasks. Functionally, it is similar to the
scheduled task on the operating system (such as cron in Linux and scheduled
tasks in Windows).
-A Job in the PAUSED state can be resumed by performing the RESUME operation,
changing the state to RUNNING.
+There are two types of jobs: `ONE_TIME` and `RECURRING`. Among them, the
`ONE_TIME` type of job will be triggered at a specified time point. It is
mainly used for one-time tasks, while the `RECURRING` type of job will be
triggered cyclically within a specified time interval. This method is mainly
used for periodic tasks.
+The `RECURRING` type of job can specify the start time and end time, that is,
`STARTS/ENDS`. If the start time is not specified, the default first execution
time is the current time + one scheduling cycle. If the end time is specified,
the task execution is completed. If the end time is reached (or exceeded, or
the next execution cycle will exceed the end time), it will be updated to the
FINISHED state, and no more tasks will be generated at this time.
-A Job in the STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+There are 4 states for a job (`RUNNING`, `STOPPED`, `PAUSED`, `FINISHED`).
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+The initial state is `RUNNING`. A job in the `RUNNING` state will generate a
TASK for execution according to the established scheduling cycle. When the job
is completed and reaches the end time, the state changes to `FINISHED`.
-#### Task status
+A job in the `PAUSED` state can be resumed through the RESUME operation and
changed to the RUNNING state.
-A Job only describes the job information, and the execution generates Tasks.
The Task status can be PENDING, RUNNING, SUCCESS, FAILED, or CANCELED.
+A job in the `STOPPED` state is actively triggered by the user, and the
running job will be canceled and the job will be deleted.
-PENDING indicates that the trigger time has been reached but resources are
awaited for running. Once resources are allocated, the status changes to
RUNNING. When the execution is successful or fails, the status changes to
SUCCESS or FAILED, respectively.
+A job in the `FINISHED` state will be retained in the system for 24 hours and
will be deleted after 24 hours.
-CANCELED indicates the cancellation status. The final status of a Task is
persisted as SUCCESS or FAILED. Other statuses can be queried while the Task is
running, but they become invisible after a restart. Only the latest 100 Task
records are retained.
+JOB only describes job information. Execution will generate TASK. TASK status
is divided into `PENDING`, `RUNNING`, `SUCCEESS`, `FAILED`, `CANCELED`
+`PENDING` means that the trigger time has arrived but the resource run is
waiting. After the resource is allocated, the status changes to `RUNNING`.
Success/failure of execution changes to `SUCCESS`/`FAILED`.
+`CANCELED` means cancellation status. TASK persists the final status, i.e.
`SUCCESS`/`FAILED`. Other statuses can be checked during operation, but will
not be visible if restarted.
-#### Permissions
+## Syntax
-Currently, only users with the ADMIN role can perform this operation.
+```sql
+CREATE
+ JOB
+ <job_name>
+ ON SCHEDULE <schedule>
+ [ COMMENT <string> ]
+ DO <sql_body>
+```
-#### Related Documentation
+Where:
-- [PAUSE-JOB](../Alter/PAUSE-JOB.md)
-- [RESUME-JOB](../Alter/RESUME-JOB.md)
-- [DROP-JOB](../Drop/DROP-JOB.md)
-- [VIEW-JOB](../../../sql-functions/table-valued-functions/jobs.md),
-- [VIEW-TASKS](../../../sql-functions/table-valued-functions/tasks.md)
+```sql
+schedule:
+ { AT <at_timestamp> | EVERY <interval> [STARTS <start_timestamp> ] [ENDS
<end_timestamp> ] }
+```
-### Grammar
+Where:
```sql
-CREATE
- job
- job_name
- ON SCHEDULE schedule
- [COMMENT 'string']
- DO sql_body;
-
-schedule: {
- AT timestamp
- | EVERY interval
- [STARTS timestamp]
- [ENDS timestamp ]
-}
-
interval:
- quantity { DAY | HOUR | MINUTE |
- WEEK | SECOND }
+ quantity { WEEK | DAY | HOUR | MINUTE }
```
-A valid Job statement must contain the following
+## Required parameters
-- The keyword CREATE JOB plus the job name, which uniquely identifies the
event within a database. The job name must be globally unique, and if a JOB
with the same name already exists, an error will be reported. We reserve the
inner_ prefix for internal use, so users cannot create names starting with
***inner_***.
-- The ON SCHEDULE clause, which specifies the type of Job and when and how
often to trigger it.
-- The DO clause, which specifies the actions that need to be performed when
the Job is triggered.
+**1. `<job_name>`**
+> Job name, which identifies a unique event in a db. The job name must be
globally unique. If a job with the same name already exists, an error will be
reported. We reserve the **inner_** prefix for internal use in the system, so
users cannot create names starting with **inner_**.
-Here is a minimal example:
+**2. `<schedule>`**
+> The ON SCHEDULE clause specifies the type, triggering time and frequency of
the job. It can specify a one-time job or a periodic job.
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1 SELECT *
FROM db2.tbl2;
-```
+**3. `<sql_body>`**
+> The DO clause specifies the operation to be performed when the job is
triggered, that is, a SQL statement.
-This statement means to create a job named my_job to be executed every minute,
and the operation performed is to import the data in db2.tbl2 into db1.tbl1.
+## Optional parameters
-The SCHEDULE statement is used to define the execution time, frequency and
duration of the job, which can specify a one-time job or a periodic job.
-- AT timestamp
+**1. `AT <at_timestamp>`**
+> Format: 'YYYY-MM-DD HH:MM:SS', used for **one-time events**, it specifies
that the event is executed only once at a given date and time timestamp, and
when the execution is completed, the job status will change to FINISHED.
-Format: 'YYYY-MM-DD HH:MM:SS'. Used for one-time events, it specifies that the
event should only be executed once at the given date and time. Once the
execution is complete, the Job status changes to FINISHED.
+**2. `EVERY <interval>`**
+> Indicates a regularly repeated operation, it specifies the execution
frequency of the job, and a time interval must be specified after the keyword,
which can be days, hours, minutes, seconds, or weeks.
-- EVERY
+**3. `STARTS <start_timestamp>`**
+> Format: 'YYYY-MM-DD HH:MM:SS', used to specify the start time of the job. If
not specified, it will be executed from the next time point after the current
time. The start time must be greater than the current time.
- Indicates that the operation is repeated periodically, which specifies the
execution frequency of the job. After the keyword, a time interval should be
specified, which can be days, hours, minutes, seconds, and weeks.
+**4. `ENDS <end_timestamp>`**
+> Format: 'YYYY-MM-DD HH:MM:SS', used to specify the end time of the job. If
not specified, it means permanent execution. The date must be greater than the
current time. If the start time is specified, that is, STARTS, the end time
must be greater than the start time.
- - interval
+## Access Control Requirements
- Used to specify the Job execution frequency, which can be `day`, `hour`,
`minute`, or `week`. For example, 1 `DAY` means the Job will run once every
day, 1 `HOUR` means once every hour, 1 `MINUTE` means once every minute, and `1
The CREATE JOB statement is used to create a job in a database. A job is a task
that can be scheduled to run at specific times or intervals to automate certain
actions.
+The user who executes this SQL command must have at least the following
permissions:
- - STARTS timestamp(optional)
+| Privilege | Object | Notes
|
+|:--------------|:-----------|:------------------------------------------------------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions
to perform this operation |
- Format: 'YYYY-MM-DD HH:MM:SS'. It is used to specify the start time of the
job. If not specified, the job starts executing from the next occurrence based
on the current time. The start time must be greater than the current time.
+## Usage Notes
- - ENDS timestamp(optional)
+- TASK only retains the latest 100 records.
- Format: 'YYYY-MM-DD HH:MM:SS'. It is used to specify the end time of the
job. If not specified, it means the job executes indefinitely. The end date
must be greater than the current time. If a start time (↳STARTS) is specified,
the end time must be greater than the start time.
+- Currently only supports **INSERT internal table** operations, and will
support more operations in the future.
-- DO
+- When the next scheduled task time expires, that is, when the task needs to
be scheduled for execution, if the current JOB still has historical tasks being
executed, the current task scheduling will be skipped. Therefore, it is very
important to control a reasonable execution interval.
- It is used to specify the operation that needs to be performed when the job
is triggered. Currently, all ***INSERT*** operations are supported. We will
support more operations in the future.
+## Examples
-## Example
+- Create a job named my_job, which is executed once every minute. The
operation performed is to import the data in db2.tbl2 into db1.tbl1.
-Create a one-time job, which will be executed once at 2020-01-01 00:00:00, and
the operation performed is to import the data in db2.tbl2 into db1.tbl1.
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1 SELECT
* FROM db2.tbl2;
+ ```
-```sql
+- Create a one-time job that will be executed once at 2020-01-01 00:00:00 to
import the data in db2.tbl2 into db1.tbl1.
-CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO db1.tbl1
SELECT * FROM db2.tbl2;
+ ```sql
+ CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO
db1.tbl1 SELECT * FROM db2.tbl2;
+ ```
-```
+- Create a periodic Job that will start executing at 2020-01-01 00:00:00 and
execute once a day. The operation performed is to import the data in db2.tbl2
into db1.tbl1.
-Create a periodic Job, which will start to execute at 2020-01-01 00:00:00,
once a day, and the operation is to import the data in db2.tbl2 into db1.tbl1.
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
+ ```
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO
INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >=
days_add(now(),-1);
-```
+- Create a periodic job that will start at 2020-01-01 00:00:00 and execute
once a day. The operation is to import the data in db2.tbl2 into db1.tbl1. The
job ends at 2020-01-01 00:10:00.
-Create a periodic Job, which will start to execute at 2020-01-01 00:00:00, and
execute once a day. The operation performed is to import the data in db2.tbl2
into db1.tbl1. This Job will be executed in 2020 Ends at -01-01 00:10:00.
+ ```sql
+ CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' ENDS
'2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add(now(),-1);
+ ```
-```sql
-CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' ENDS
'2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2
create_time >= days_add (now(),-1);
-```
+## Best Practices
+
+- Manage jobs reasonably to avoid a large number of jobs being triggered at
the same time, which will cause task accumulation and affect the normal
operation of the system.
+- The task execution interval should be set within a reasonable range, at
least greater than the task execution time.
+
+## Related Documents
-### CONFIG
+- [Pause-JOB](../job/PAUSE-JOB.md)
+- [Resume-JOB](../job/RESUME-JOB.md)
+- [Delete-JOB](../job/DROP-JOB.md)
+- [Query-JOB](../../../sql-manual/sql-functions/table-valued-functions/jobs.md)
+- [Query-TASKS](../../sql-functions/table-valued-functions/jobs.md)
-#### fe.conf
+## CONFIG
-- job_dispatch_timer_job_thread_num: Number of threads used for dispatching
scheduled tasks. Default value is 2. If there are a large number of
periodically executed tasks, this parameter can be increased.
-- job_dispatch_timer_job_queue_size: Size of the queue used for storing
scheduled tasks when there is task accumulation. Default value is 1024. If
there are a large number of tasks triggered at the same time, this parameter
can be increased. Otherwise, the queue may become full and submitting tasks
will be blocked, causing subsequent tasks to be unable to submit.
-- finished_job_cleanup_threshold_time_hour: Time threshold, in hours, for
cleaning up completed tasks. Default value is 24 hours.
-- job_insert_task_consumer_thread_num: Number of threads used for executing
Insert tasks. The value should be greater than 0, otherwise the default value
is 5.
+**fe.conf**
-## Best Practice
+- job_dispatch_timer_job_thread_num, the number of threads used to distribute
timed tasks, the default value is 2, if there are a large number of periodic
execution tasks, you can increase this parameter.
-- Properly manage Jobs to avoid triggering a large number of Jobs
simultaneously, which can lead to task accumulation and affect the normal
operation of the system.
-- Set the execution interval of tasks within a reasonable range, ensuring that
it is at least greater than the task execution time.
+- job_dispatch_timer_job_queue_size, the queue size for storing timed tasks
when tasks are accumulated, the default value is 1024. If a large number of
tasks are triggered at the same time, this parameter can be increased.
Otherwise, the queue will be full, and the submitted task will enter a blocked
state, which will cause subsequent tasks to fail to submit.
-## Keywords
+- finished_job_cleanup_threshold_time_hour, the time threshold for cleaning up
completed tasks, in hours, the default value is 24 hours.
- CREATE, JOB, SCHEDULE
+- job_insert_task_consumer_thread_num = 10; the number of threads used to
execute Insert tasks, the value should be greater than 0, otherwise the default
value is 5.
\ No newline at end of file
diff --git
a/versioned_docs/version-3.0/sql-manual/sql-statements/job/DROP-JOB.md
b/versioned_docs/version-3.0/sql-manual/sql-statements/job/DROP-JOB.md
index 48d228b7749..530a9cb567d 100644
--- a/versioned_docs/version-3.0/sql-manual/sql-statements/job/DROP-JOB.md
+++ b/versioned_docs/version-3.0/sql-manual/sql-statements/job/DROP-JOB.md
@@ -26,23 +26,31 @@ under the License.
## Description
-User stops a JOB. A stopped job cannot be resumed.
+The user deletes a JOB job. The job will be stopped and deleted immediately.
+
+## Syntax
```sql
-DROP JOB WHERE jobName = 'job_name';
+DROP JOB where jobName = <job_name> ;
```
-## Example
+## Required parameters
+
+**1. `<job_name>`**
+> The `<job_name>` of the task to be deleted.
-1. DROP the job named test1.
+## Access Control Requirements
- ```sql
- DROP JOB where jobName = 'test1';
- ```
+The user who executes this SQL command must have at least the following
permissions:
-## Keywords
+| Privilege | Object | Notes |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions to
perform this operation |
- DROP, JOB
+## Examples
-## Best Practice
+- Delete the job named example.
+ ```sql
+ DROP JOB where jobName='example';
+ ```
\ No newline at end of file
diff --git
a/versioned_docs/version-3.0/sql-manual/sql-statements/job/PAUSE-JOB.md
b/versioned_docs/version-3.0/sql-manual/sql-statements/job/PAUSE-JOB.md
index 08a4f309f62..dc55b74387a 100644
--- a/versioned_docs/version-3.0/sql-manual/sql-statements/job/PAUSE-JOB.md
+++ b/versioned_docs/version-3.0/sql-manual/sql-statements/job/PAUSE-JOB.md
@@ -24,25 +24,33 @@ specific language governing permissions and limitations
under the License.
-->
-
## Description
-User suspends a JOB. A stopped job can be resumed with RESUME JOB.
+When a user pauses a job in the RUNNING state, the running task will be
interrupted and the job state will be changed to PAUSED. The stopped job can be
resumed by the RESUME operation.
+
+## Syntax
```sql
-PAUSE JOB where jobName = 'job_name';
+PAUSE JOB WHERE jobname = <job_name> ;
```
-## Example
+## Required parameters
+
+**1. `<job_name>`**
+> The name of the job to be paused.
+
+## Access Control Requirements
-1. Pause the job named test1.
+The user who executes this SQL command must have at least the following
permissions:
- ```sql
- PAUSE JOB where jobName = 'test1';
- ```
+| Privilege | Object | Notes |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions to
perform this operation |
-## Keywords
+## Examples
- PAUSE, JOB
+- Pause the job named example.
-## Best Practice
+ ```sql
+ PAUSE JOB where jobname='example';
+ ```
\ No newline at end of file
diff --git
a/versioned_docs/version-3.0/sql-manual/sql-statements/job/RESUME-JOB.md
b/versioned_docs/version-3.0/sql-manual/sql-statements/job/RESUME-JOB.md
index 56836cd86fe..b106837ccb4 100644
--- a/versioned_docs/version-3.0/sql-manual/sql-statements/job/RESUME-JOB.md
+++ b/versioned_docs/version-3.0/sql-manual/sql-statements/job/RESUME-JOB.md
@@ -24,28 +24,32 @@ specific language governing permissions and limitations
under the License.
-->
-
## Description
-Used to restart a JOB in PAUSE state. The restarted job will continue to be
executed periodically. A JOB in STOP state cannot be resumed.
+Restore the PAUSED job to the RUNNING state. The RUNNING job will be executed
according to the scheduled period.
+
+## Syntax
```sql
-RESUME JOB WHERE jobName = 'job_name';
+RESUME JOB where jobName = <job_name> ;
```
+## Required parameters
-## Example
-
-1. Restart the JOB named test1.
-
- ```sql
- RESUME JOB WHERE jobName = 'test1';
- ```
+**1. `<job_name>`**
+> The `<job_name>` of the recovery task.
-## Keywords
+## Access Control Requirements
- RESUME, JOB
+The user who executes this SQL command must have at least the following
permissions:
-## Best Practice
+| Privilege | Object | Notes |
+|:--------------|:-----------|:------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions to
perform this operation |
+## Example
+- Resume the job named example.
+ ```sql
+ RESUME JOB where jobName= 'example';
+ ```
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
