morrySnow commented on code in PR #1879:
URL: https://github.com/apache/doris-website/pull/1879#discussion_r1925172536
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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.
Review Comment:
`STARTS\ENDS` 这里为什么会用一个反斜杠？表示什么意思？
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
Review Comment:
这句英文，感觉有点儿重复
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+A job in the PAUSE state can be resumed through the RESUME operation and
changed to the RUNNING state.
Review Comment:
```suggestion
A job in the `PAUSED` state can be resumed through the RESUME operation and
changed to the RUNNING state.
```
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
Review Comment:
这一段话里面的 state 都加上反引号，更好一点？
```suggestion
A job in the `RUNNING` state can be paused, that is, it will be paused, and
no more tasks will be generated.
```
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+A job in the PAUSE state can be resumed through the RESUME operation and
changed to the RUNNING state.
-#### Task status
+A job in the STOP 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
+```sql
-Currently, only users with the ADMIN role can perform this operation.
+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 timestamp | EVERY interval [STARTS timestamp ] [ENDS timestamp ] }
Review Comment:
```suggestion
{ AT <at_timestamp> | EVERY <interval> [STARTS <start_timestamp> ] [ENDS
<end_timestamp> ] }
```
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+A job in the PAUSE state can be resumed through the RESUME operation and
changed to the RUNNING state.
-#### Task status
+A job in the STOP state is actively triggered by the user, and the running job
will be canceled and the job will be deleted.
Review Comment:
```suggestion
A job in the `STOPED` state is actively triggered by the user, and the
running job will be canceled and the job will be deleted.
```
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+A job in the PAUSE state can be resumed through the RESUME operation and
changed to the RUNNING state.
-#### Task status
+A job in the STOP 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
+```sql
-Currently, only users with the ADMIN role can perform this operation.
+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 timestamp | EVERY interval [STARTS timestamp ] [ENDS 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 timestamp>`**
Review Comment:
```suggestion
**1. `AT <at_timestamp>`**
```
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+A job in the PAUSE state can be resumed through the RESUME operation and
changed to the RUNNING state.
-#### Task status
+A job in the STOP 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
Review Comment:
`JOB only describes job information.` 这个表述有点儿奇怪
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+A job in the PAUSE state can be resumed through the RESUME operation and
changed to the RUNNING state.
-#### Task status
+A job in the STOP 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
+```sql
-Currently, only users with the ADMIN role can perform this operation.
+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 timestamp | EVERY interval [STARTS timestamp ] [ENDS 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 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>`**
+> 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.
+> * STARTS 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.
+> * ENDS 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.
Review Comment:
这里应该分成三个参数介绍
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+A job in the PAUSE state can be resumed through the RESUME operation and
changed to the RUNNING state.
-#### Task status
+A job in the STOP 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.
Review Comment:
```suggestion
A job in the `FINISHED` state will be retained in the system for 24 hours
and will be deleted after 24 hours.
```
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+A job in the PAUSE state can be resumed through the RESUME operation and
changed to the RUNNING state.
-#### Task status
+A job in the STOP 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
+```sql
-Currently, only users with the ADMIN role can perform this operation.
+CREATE
+JOB
+<job_name>
+ON SCHEDULE <schedule>
+[ COMMENT <string> ]
+DO <sql_body> ;
Review Comment:
去掉分号
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+A job in the PAUSE state can be resumed through the RESUME operation and
changed to the RUNNING state.
-#### Task status
+A job in the STOP 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
+```sql
-Currently, only users with the ADMIN role can perform this operation.
+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 timestamp | EVERY interval [STARTS timestamp ] [ENDS 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 }
Review Comment:
```suggestion
quantity { WEEK | DAY | HOUR | MINUTE }
```
##########
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 = <jobname> ;
Review Comment:
```suggestion
DROP JOB where jobName = <job_name> ;
```
##########
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 = <jobname> ;
Review Comment:
```suggestion
PAUSE JOB WHERE jobname = <job_name> ;
```
##########
docs/sql-manual/sql-statements/job/CREATE-JOB.md:
##########
@@ -25,147 +25,137 @@ 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 specified and the task completes execution by reaching the end
time (or exceeds it, or the next execution period exceeds the end time), the
Job status is updated to FINISHED, and no more Tasks are generated.
-
-#### 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`). 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 STOPPED state is triggered by the user, which cancels the running
Job and then deletes it.
+A job in the RUNNING state can be paused, that is, it will be paused, and no
more tasks will be generated.
-A Job in the FINISHED state remains in the system for 24 hours and is deleted
after that.
+A job in the PAUSE state can be resumed through the RESUME operation and
changed to the RUNNING state.
-#### Task status
+A job in the STOP 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
+```sql
-Currently, only users with the ADMIN role can perform this operation.
+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 timestamp | EVERY interval [STARTS timestamp ] [ENDS 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 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>`**
+> 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.
+> * STARTS 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.
+> * ENDS 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.
-- EVERY
+## Access Control Requirements
- 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.
+The user who executes this SQL command must have at least the following
permissions:
- - interval
+| Privilege | Object | Notes
|
+|:--------------|:-----------|:------------------------------------------------------------------------|
+| ADMIN_PRIV | Database | Currently only supports **ADMIN** permissions
to perform this operation |
- 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.
+## Usage Notes
- - STARTS timestamp(optional)
+- TASK only retains the latest 100 records.
- 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.
+- Currently only supports **INSERT internal table** operations, and we will
support more operations in the future.
Review Comment:
```suggestion
- Currently only supports **INSERT internal table** operations, and will
support more operations in the future.
```
##########
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 = <jobname> ;
Review Comment:
```suggestion
RESUME JOB where jobName = <job_name> ;
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
