This is an automated email from the ASF dual-hosted git repository.

chengpan pushed a commit to branch branch-1.8
in repository https://gitbox.apache.org/repos/asf/kyuubi.git


The following commit(s) were added to refs/heads/branch-1.8 by this push:
     new ff9738309 [KYUUBI #5294] [DOC] Update supported dialects for JDBC 
engine
ff9738309 is described below

commit ff973830986012614caf6a44e67e983948627530
Author: yangming <261635...@qq.com>
AuthorDate: Tue Oct 24 16:16:29 2023 +0800

    [KYUUBI #5294] [DOC] Update supported dialects for JDBC engine
    
    ### _Why are the changes needed?_
    
    As https://github.com/apache/kyuubi/pull/4000 adds the Apache Phoenix 
support for the JDBC engine without upgrading the configuration's description.
    
    This PR aims to update the outdated configuration description to reflect 
the capabilities of the Kyuubi JDBC engine.
    
    ### _How was this patch tested?_
    - [ ] Add some test cases that check the changes thoroughly including 
negative and positive cases if possible
    
    - [ ] Add screenshots for manual tests if appropriate
    
    - [ ] [Run 
test](https://kyuubi.readthedocs.io/en/master/contributing/code/testing.html#running-tests)
 locally before make a pull request
    
    ### _Was this patch authored or co-authored using generative AI tooling?_
    
    No.
    
    Closes #5294 from ymZhao1001/doc0915.
    
    Closes #5294
    
    8d61c36f9 [yangming] update jdbc doc
    d082b4d34 [yangming] run dev/reformat and dev/gen/gen_all_config_docs.sh
    5b814d86b [zhaoyangming] add jdbc Phoenix dialect
    
    Lead-authored-by: yangming <261635...@qq.com>
    Co-authored-by: zhaoyangming <zhaoyangm...@deepexi.com>
    Signed-off-by: Cheng Pan <cheng...@apache.org>
    (cherry picked from commit 289549f7f3b531cc84bb6887c1b984544604e4fa)
    Signed-off-by: Cheng Pan <cheng...@apache.org>
---
 docs/configuration/settings.md                     | 152 ++++++++++-----------
 .../org/apache/kyuubi/config/KyuubiConf.scala      |   5 +-
 2 files changed, 79 insertions(+), 78 deletions(-)

diff --git a/docs/configuration/settings.md b/docs/configuration/settings.md
index 2bfee4d47..bf96c5996 100644
--- a/docs/configuration/settings.md
+++ b/docs/configuration/settings.md
@@ -120,82 +120,82 @@ You can configure the Kyuubi properties in 
`$KYUUBI_HOME/conf/kyuubi-defaults.co
 
 ### Engine
 
-|                           Key                            |          Default  
        |                                                                       
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-|----------------------------------------------------------|---------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 [...]
-| kyuubi.engine.chat.extra.classpath                       | &lt;undefined&gt; 
        | The extra classpath for the Chat engine, for configuring the location 
of the SDK and etc.                                                             
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.chat.gpt.apiKey                            | &lt;undefined&gt; 
        | The key to access OpenAI open API, which could be got at 
https://platform.openai.com/account/api-keys                                    
                                                                                
                                                                                
                                                                                
                           [...]
-| kyuubi.engine.chat.gpt.http.connect.timeout              | PT2M              
        | The timeout[ms] for establishing the connection with the Chat GPT 
server. A timeout value of zero is interpreted as an infinite timeout.          
                                                                                
                                                                                
                                                                                
                  [...]
-| kyuubi.engine.chat.gpt.http.proxy                        | &lt;undefined&gt; 
        | HTTP proxy url for API calling in Chat GPT engine. e.g. 
http://127.0.0.1:1087                                                           
                                                                                
                                                                                
                                                                                
                            [...]
-| kyuubi.engine.chat.gpt.http.socket.timeout               | PT2M              
        | The timeout[ms] for waiting for data packets after Chat GPT server 
connection is established. A timeout value of zero is interpreted as an 
infinite timeout.                                                               
                                                                                
                                                                                
                         [...]
-| kyuubi.engine.chat.gpt.model                             | gpt-3.5-turbo     
        | ID of the model used in ChatGPT. Available models refer to OpenAI's 
[Model overview](https://platform.openai.com/docs/models/overview).             
                                                                                
                                                                                
                                                                                
                [...]
-| kyuubi.engine.chat.java.options                          | &lt;undefined&gt; 
        | The extra Java options for the Chat engine                            
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.chat.memory                                | 1g                
        | The heap memory for the Chat engine                                   
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.chat.provider                              | ECHO              
        | The provider for the Chat engine. Candidates: <ul> <li>ECHO: simply 
replies a welcome message.</li> <li>GPT: a.k.a ChatGPT, powered by 
OpenAI.</li></ul>                                                               
                                                                                
                                                                                
                             [...]
-| kyuubi.engine.connection.url.use.hostname                | true              
        | (deprecated) When true, the engine registers with hostname to 
zookeeper. When Spark runs on K8s with cluster mode, set to false to ensure 
that server can connect to engine                                               
                                                                                
                                                                                
                          [...]
-| kyuubi.engine.deregister.exception.classes                                   
       || A comma-separated list of exception classes. If there is any 
exception thrown, whose class matches the specified classes, the engine would 
deregister itself.                                                              
                                                                                
                                                                                
                         [...]
-| kyuubi.engine.deregister.exception.messages                                  
       || A comma-separated list of exception messages. If there is any 
exception thrown, whose message or stacktrace matches the specified message 
list, the engine would deregister itself.                                       
                                                                                
                                                                                
                          [...]
-| kyuubi.engine.deregister.exception.ttl                   | PT30M             
        | Time to live(TTL) for exceptions pattern specified in 
kyuubi.engine.deregister.exception.classes and 
kyuubi.engine.deregister.exception.messages to deregister engines. Once the 
total error count hits the kyuubi.engine.deregister.job.max.failures within the 
TTL, an engine will deregister itself and wait for self-terminated. Otherwise, 
we suppose that the engine has recovered from temporary failures.   [...]
-| kyuubi.engine.deregister.job.max.failures                | 4                 
        | Number of failures of job before deregistering the engine.            
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.event.json.log.path                        | 
file:///tmp/kyuubi/events | The location where all the engine events go for the 
built-in JSON logger.<ul><li>Local Path: start with 'file://'</li><li>HDFS 
Path: start with 'hdfs://'</li></ul>                                            
                                                                                
                                                                                
                                     [...]
-| kyuubi.engine.event.loggers                              | SPARK             
        | A comma-separated list of engine history loggers, where 
engine/session/operation etc events go.<ul> <li>SPARK: the events will be 
written to the Spark listener bus.</li> <li>JSON: the events will be written to 
the location of kyuubi.engine.event.json.log.path</li> <li>JDBC: to be 
done</li> <li>CUSTOM: User-defined event handlers.</li></ul> Note that: Kyuubi 
supports custom event handlers with the Jav [...]
-| kyuubi.engine.flink.application.jars                     | &lt;undefined&gt; 
        | A comma-separated list of the local jars to be shipped with the job 
to the cluster. For example, SQL UDF jars. Only effective in yarn application 
mode.                                                                           
                                                                                
                                                                                
                  [...]
-| kyuubi.engine.flink.extra.classpath                      | &lt;undefined&gt; 
        | The extra classpath for the Flink SQL engine, for configuring the 
location of hadoop client jars, etc. Only effective in yarn session mode.       
                                                                                
                                                                                
                                                                                
                  [...]
-| kyuubi.engine.flink.java.options                         | &lt;undefined&gt; 
        | The extra Java options for the Flink SQL engine. Only effective in 
yarn session mode.                                                              
                                                                                
                                                                                
                                                                                
                 [...]
-| kyuubi.engine.flink.memory                               | 1g                
        | The heap memory for the Flink SQL engine. Only effective in yarn 
session mode.                                                                   
                                                                                
                                                                                
                                                                                
                   [...]
-| kyuubi.engine.hive.event.loggers                         | JSON              
        | A comma-separated list of engine history loggers, where 
engine/session/operation etc events go.<ul> <li>JSON: the events will be 
written to the location of kyuubi.engine.event.json.log.path</li> <li>JDBC: to 
be done</li> <li>CUSTOM: to be done.</li></ul>                                  
                                                                                
                                    [...]
-| kyuubi.engine.hive.extra.classpath                       | &lt;undefined&gt; 
        | The extra classpath for the Hive query engine, for configuring 
location of the hadoop client jars and etc.                                     
                                                                                
                                                                                
                                                                                
                     [...]
-| kyuubi.engine.hive.java.options                          | &lt;undefined&gt; 
        | The extra Java options for the Hive query engine                      
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.hive.memory                                | 1g                
        | The heap memory for the Hive query engine                             
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.initialize.sql                             | SHOW DATABASES    
        | SemiColon-separated list of SQL statements to be initialized in the 
newly created engine before queries. i.e. use `SHOW DATABASES` to eagerly 
active HiveClient. This configuration can not be used in JDBC url due to the 
limitation of Beeline/JDBC driver.                                              
                                                                                
                         [...]
-| kyuubi.engine.jdbc.connection.password                   | &lt;undefined&gt; 
        | The password is used for connecting to server                         
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.jdbc.connection.propagateCredential        | false             
        | Whether to use the session's user and password to connect to database 
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.jdbc.connection.properties                                     
       || The additional properties are used for connecting to server           
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.jdbc.connection.provider                   | &lt;undefined&gt; 
        | The connection provider is used for getting a connection from the 
server                                                                          
                                                                                
                                                                                
                                                                                
                  [...]
-| kyuubi.engine.jdbc.connection.url                        | &lt;undefined&gt; 
        | The server url that engine will connect to                            
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.jdbc.connection.user                       | &lt;undefined&gt; 
        | The user is used for connecting to server                             
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.jdbc.driver.class                          | &lt;undefined&gt; 
        | The driver class for JDBC engine connection                           
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.jdbc.extra.classpath                       | &lt;undefined&gt; 
        | The extra classpath for the JDBC query engine, for configuring the 
location of the JDBC driver and etc.                                            
                                                                                
                                                                                
                                                                                
                 [...]
-| kyuubi.engine.jdbc.initialize.sql                        | SELECT 1          
        | SemiColon-separated list of SQL statements to be initialized in the 
newly created engine before queries. i.e. use `SELECT 1` to eagerly active 
JDBCClient.                                                                     
                                                                                
                                                                                
                     [...]
-| kyuubi.engine.jdbc.java.options                          | &lt;undefined&gt; 
        | The extra Java options for the JDBC query engine                      
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.jdbc.memory                                | 1g                
        | The heap memory for the JDBC query engine                             
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.jdbc.session.initialize.sql                                    
       || SemiColon-separated list of SQL statements to be initialized in the 
newly created engine session before queries.                                    
                                                                                
                                                                                
                                                                                
                [...]
-| kyuubi.engine.jdbc.type                                  | &lt;undefined&gt; 
        | The short name of JDBC type                                           
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.kubernetes.submit.timeout                  | PT30S             
        | The engine submit timeout for Kubernetes application.                 
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.operation.convert.catalog.database.enabled | true              
        | When set to true, The engine converts the JDBC methods of set/get 
Catalog and set/get Schema to the implementation of different engines           
                                                                                
                                                                                
                                                                                
                  [...]
-| kyuubi.engine.operation.log.dir.root                     | 
engine_operation_logs     | Root directory for query operation log at 
engine-side.                                                                    
                                                                                
                                                                                
                                                                                
                                          [...]
-| kyuubi.engine.pool.name                                  | engine-pool       
        | The name of the engine pool.                                          
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.pool.selectPolicy                          | RANDOM            
        | The select policy of an engine from the corresponding engine pool 
engine for a session. <ul><li>RANDOM - Randomly use the engine in the 
pool</li><li>POLLING - Polling use the engine in the pool</li></ul>             
                                                                                
                                                                                
                            [...]
-| kyuubi.engine.pool.size                                  | -1                
        | The size of the engine pool. Note that, if the size is less than 1, 
the engine pool will not be enabled; otherwise, the size of the engine pool 
will be min(this, kyuubi.engine.pool.size.threshold).                           
                                                                                
                                                                                
                    [...]
-| kyuubi.engine.pool.size.threshold                        | 9                 
        | This parameter is introduced as a server-side parameter controlling 
the upper limit of the engine pool.                                             
                                                                                
                                                                                
                                                                                
                [...]
-| kyuubi.engine.session.initialize.sql                                         
       || SemiColon-separated list of SQL statements to be initialized in the 
newly created engine session before queries. This configuration can not be used 
in JDBC url due to the limitation of Beeline/JDBC driver.                       
                                                                                
                                                                                
                [...]
-| kyuubi.engine.share.level                                | USER              
        | Engines will be shared in different levels, available configs are: 
<ul> <li>CONNECTION: engine will not be shared but only used by the current 
client connection</li> <li>USER: engine will be shared by all sessions created 
by a unique username, see also kyuubi.engine.share.level.subdomain</li> 
<li>GROUP: the engine will be shared by all sessions created by all users 
belong to the same primary group na [...]
-| kyuubi.engine.share.level.sub.domain                     | &lt;undefined&gt; 
        | (deprecated) - Using kyuubi.engine.share.level.subdomain instead      
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.share.level.subdomain                      | &lt;undefined&gt; 
        | Allow end-users to create a subdomain for the share level of an 
engine. A subdomain is a case-insensitive string values that must be a valid 
zookeeper subpath. For example, for the `USER` share level, an end-user can 
share a certain engine within a subdomain, not for all of its clients. 
End-users are free to create multiple engines in the `USER` share level. When 
disable engine pool, use 'default' if [...]
-| kyuubi.engine.single.spark.session                       | false             
        | When set to true, this engine is running in a single session mode. 
All the JDBC/ODBC connections share the temporary views, function registries, 
SQL configuration and the current database.                                     
                                                                                
                                                                                
                   [...]
-| kyuubi.engine.spark.event.loggers                        | SPARK             
        | A comma-separated list of engine loggers, where 
engine/session/operation etc events go.<ul> <li>SPARK: the events will be 
written to the Spark listener bus.</li> <li>JSON: the events will be written to 
the location of kyuubi.engine.event.json.log.path</li> <li>JDBC: to be 
done</li> <li>CUSTOM: to be done.</li></ul>                                     
                                                   [...]
-| kyuubi.engine.spark.python.env.archive                   | &lt;undefined&gt; 
        | Portable Python env archive used for Spark engine Python language 
mode.                                                                           
                                                                                
                                                                                
                                                                                
                  [...]
-| kyuubi.engine.spark.python.env.archive.exec.path         | bin/python        
        | The Python exec path under the Python env archive.                    
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.spark.python.home.archive                  | &lt;undefined&gt; 
        | Spark archive containing $SPARK_HOME/python directory, which is used 
to init session Python worker for Python language mode.                         
                                                                                
                                                                                
                                                                                
               [...]
-| kyuubi.engine.submit.timeout                             | PT30S             
        | Period to tolerant Driver Pod ephemerally invisible after submitting. 
In some Resource Managers, e.g. K8s, the Driver Pod is not visible immediately 
after `spark-submit` is returned.                                               
                                                                                
                                                                                
               [...]
-| kyuubi.engine.trino.connection.keystore.password         | &lt;undefined&gt; 
        | The keystore password used for connecting to trino cluster            
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.trino.connection.keystore.path             | &lt;undefined&gt; 
        | The keystore path used for connecting to trino cluster                
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.trino.connection.keystore.type             | &lt;undefined&gt; 
        | The keystore type used for connecting to trino cluster                
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.trino.connection.password                  | &lt;undefined&gt; 
        | The password used for connecting to trino cluster                     
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.trino.connection.truststore.password       | &lt;undefined&gt; 
        | The truststore password used for connecting to trino cluster          
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.trino.connection.truststore.path           | &lt;undefined&gt; 
        | The truststore path used for connecting to trino cluster              
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.trino.connection.truststore.type           | &lt;undefined&gt; 
        | The truststore type used for connecting to trino cluster              
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.trino.event.loggers                        | JSON              
        | A comma-separated list of engine history loggers, where 
engine/session/operation etc events go.<ul> <li>JSON: the events will be 
written to the location of kyuubi.engine.event.json.log.path</li> <li>JDBC: to 
be done</li> <li>CUSTOM: to be done.</li></ul>                                  
                                                                                
                                    [...]
-| kyuubi.engine.trino.extra.classpath                      | &lt;undefined&gt; 
        | The extra classpath for the Trino query engine, for configuring other 
libs which may need by the Trino engine                                         
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.trino.java.options                         | &lt;undefined&gt; 
        | The extra Java options for the Trino query engine                     
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.trino.memory                               | 1g                
        | The heap memory for the Trino query engine                            
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.type                                       | SPARK_SQL         
        | Specify the detailed engine supported by Kyuubi. The engine type 
bindings to SESSION scope. This configuration is experimental. Currently, 
available configs are: <ul> <li>SPARK_SQL: specify this engine type will launch 
a Spark engine which can provide all the capacity of the Apache Spark. Note, 
it's a default engine type.</li> <li>FLINK_SQL: specify this engine type will 
launch a Flink engine which c [...]
-| kyuubi.engine.ui.retainedSessions                        | 200               
        | The number of SQL client sessions kept in the Kyuubi Query Engine web 
UI.                                                                             
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.ui.retainedStatements                      | 200               
        | The number of statements kept in the Kyuubi Query Engine web UI.      
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.ui.stop.enabled                            | true              
        | When true, allows Kyuubi engine to be killed from the Spark Web UI.   
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.user.isolated.spark.session                | true              
        | When set to false, if the engine is running in a group or server 
share level, all the JDBC/ODBC connections will be isolated against the user. 
Including the temporary views, function registries, SQL configuration, and the 
current database. Note that, it does not affect if the share level is 
connection or user.                                                             
                                [...]
-| kyuubi.engine.user.isolated.spark.session.idle.interval  | PT1M              
        | The interval to check if the user-isolated Spark session is timeout.  
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
-| kyuubi.engine.user.isolated.spark.session.idle.timeout   | PT6H              
        | If kyuubi.engine.user.isolated.spark.session is false, we will 
release the Spark session if its corresponding user is inactive after this 
configured timeout.                                                             
                                                                                
                                                                                
                          [...]
-| kyuubi.engine.yarn.submit.timeout                        | PT30S             
        | The engine submit timeout for YARN application.                       
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+|                           Key                            |          Default  
        |                                                                       
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+|----------------------------------------------------------|---------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 [...]
+| kyuubi.engine.chat.extra.classpath                       | &lt;undefined&gt; 
        | The extra classpath for the Chat engine, for configuring the location 
of the SDK and etc.                                                             
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.chat.gpt.apiKey                            | &lt;undefined&gt; 
        | The key to access OpenAI open API, which could be got at 
https://platform.openai.com/account/api-keys                                    
                                                                                
                                                                                
                                                                                
                           [...]
+| kyuubi.engine.chat.gpt.http.connect.timeout              | PT2M              
        | The timeout[ms] for establishing the connection with the Chat GPT 
server. A timeout value of zero is interpreted as an infinite timeout.          
                                                                                
                                                                                
                                                                                
                  [...]
+| kyuubi.engine.chat.gpt.http.proxy                        | &lt;undefined&gt; 
        | HTTP proxy url for API calling in Chat GPT engine. e.g. 
http://127.0.0.1:1087                                                           
                                                                                
                                                                                
                                                                                
                            [...]
+| kyuubi.engine.chat.gpt.http.socket.timeout               | PT2M              
        | The timeout[ms] for waiting for data packets after Chat GPT server 
connection is established. A timeout value of zero is interpreted as an 
infinite timeout.                                                               
                                                                                
                                                                                
                         [...]
+| kyuubi.engine.chat.gpt.model                             | gpt-3.5-turbo     
        | ID of the model used in ChatGPT. Available models refer to OpenAI's 
[Model overview](https://platform.openai.com/docs/models/overview).             
                                                                                
                                                                                
                                                                                
                [...]
+| kyuubi.engine.chat.java.options                          | &lt;undefined&gt; 
        | The extra Java options for the Chat engine                            
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.chat.memory                                | 1g                
        | The heap memory for the Chat engine                                   
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.chat.provider                              | ECHO              
        | The provider for the Chat engine. Candidates: <ul> <li>ECHO: simply 
replies a welcome message.</li> <li>GPT: a.k.a ChatGPT, powered by 
OpenAI.</li></ul>                                                               
                                                                                
                                                                                
                             [...]
+| kyuubi.engine.connection.url.use.hostname                | true              
        | (deprecated) When true, the engine registers with hostname to 
zookeeper. When Spark runs on K8s with cluster mode, set to false to ensure 
that server can connect to engine                                               
                                                                                
                                                                                
                          [...]
+| kyuubi.engine.deregister.exception.classes                                   
       || A comma-separated list of exception classes. If there is any 
exception thrown, whose class matches the specified classes, the engine would 
deregister itself.                                                              
                                                                                
                                                                                
                         [...]
+| kyuubi.engine.deregister.exception.messages                                  
       || A comma-separated list of exception messages. If there is any 
exception thrown, whose message or stacktrace matches the specified message 
list, the engine would deregister itself.                                       
                                                                                
                                                                                
                          [...]
+| kyuubi.engine.deregister.exception.ttl                   | PT30M             
        | Time to live(TTL) for exceptions pattern specified in 
kyuubi.engine.deregister.exception.classes and 
kyuubi.engine.deregister.exception.messages to deregister engines. Once the 
total error count hits the kyuubi.engine.deregister.job.max.failures within the 
TTL, an engine will deregister itself and wait for self-terminated. Otherwise, 
we suppose that the engine has recovered from temporary failures.   [...]
+| kyuubi.engine.deregister.job.max.failures                | 4                 
        | Number of failures of job before deregistering the engine.            
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.event.json.log.path                        | 
file:///tmp/kyuubi/events | The location where all the engine events go for the 
built-in JSON logger.<ul><li>Local Path: start with 'file://'</li><li>HDFS 
Path: start with 'hdfs://'</li></ul>                                            
                                                                                
                                                                                
                                     [...]
+| kyuubi.engine.event.loggers                              | SPARK             
        | A comma-separated list of engine history loggers, where 
engine/session/operation etc events go.<ul> <li>SPARK: the events will be 
written to the Spark listener bus.</li> <li>JSON: the events will be written to 
the location of kyuubi.engine.event.json.log.path</li> <li>JDBC: to be 
done</li> <li>CUSTOM: User-defined event handlers.</li></ul> Note that: Kyuubi 
supports custom event handlers with the Jav [...]
+| kyuubi.engine.flink.application.jars                     | &lt;undefined&gt; 
        | A comma-separated list of the local jars to be shipped with the job 
to the cluster. For example, SQL UDF jars. Only effective in yarn application 
mode.                                                                           
                                                                                
                                                                                
                  [...]
+| kyuubi.engine.flink.extra.classpath                      | &lt;undefined&gt; 
        | The extra classpath for the Flink SQL engine, for configuring the 
location of hadoop client jars, etc. Only effective in yarn session mode.       
                                                                                
                                                                                
                                                                                
                  [...]
+| kyuubi.engine.flink.java.options                         | &lt;undefined&gt; 
        | The extra Java options for the Flink SQL engine. Only effective in 
yarn session mode.                                                              
                                                                                
                                                                                
                                                                                
                 [...]
+| kyuubi.engine.flink.memory                               | 1g                
        | The heap memory for the Flink SQL engine. Only effective in yarn 
session mode.                                                                   
                                                                                
                                                                                
                                                                                
                   [...]
+| kyuubi.engine.hive.event.loggers                         | JSON              
        | A comma-separated list of engine history loggers, where 
engine/session/operation etc events go.<ul> <li>JSON: the events will be 
written to the location of kyuubi.engine.event.json.log.path</li> <li>JDBC: to 
be done</li> <li>CUSTOM: to be done.</li></ul>                                  
                                                                                
                                    [...]
+| kyuubi.engine.hive.extra.classpath                       | &lt;undefined&gt; 
        | The extra classpath for the Hive query engine, for configuring 
location of the hadoop client jars and etc.                                     
                                                                                
                                                                                
                                                                                
                     [...]
+| kyuubi.engine.hive.java.options                          | &lt;undefined&gt; 
        | The extra Java options for the Hive query engine                      
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.hive.memory                                | 1g                
        | The heap memory for the Hive query engine                             
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.initialize.sql                             | SHOW DATABASES    
        | SemiColon-separated list of SQL statements to be initialized in the 
newly created engine before queries. i.e. use `SHOW DATABASES` to eagerly 
active HiveClient. This configuration can not be used in JDBC url due to the 
limitation of Beeline/JDBC driver.                                              
                                                                                
                         [...]
+| kyuubi.engine.jdbc.connection.password                   | &lt;undefined&gt; 
        | The password is used for connecting to server                         
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.jdbc.connection.propagateCredential        | false             
        | Whether to use the session's user and password to connect to database 
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.jdbc.connection.properties                                     
       || The additional properties are used for connecting to server           
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.jdbc.connection.provider                   | &lt;undefined&gt; 
        | The connection provider is used for getting a connection from the 
server                                                                          
                                                                                
                                                                                
                                                                                
                  [...]
+| kyuubi.engine.jdbc.connection.url                        | &lt;undefined&gt; 
        | The server url that engine will connect to                            
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.jdbc.connection.user                       | &lt;undefined&gt; 
        | The user is used for connecting to server                             
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.jdbc.driver.class                          | &lt;undefined&gt; 
        | The driver class for JDBC engine connection                           
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.jdbc.extra.classpath                       | &lt;undefined&gt; 
        | The extra classpath for the JDBC query engine, for configuring the 
location of the JDBC driver and etc.                                            
                                                                                
                                                                                
                                                                                
                 [...]
+| kyuubi.engine.jdbc.initialize.sql                        | SELECT 1          
        | SemiColon-separated list of SQL statements to be initialized in the 
newly created engine before queries. i.e. use `SELECT 1` to eagerly active 
JDBCClient.                                                                     
                                                                                
                                                                                
                     [...]
+| kyuubi.engine.jdbc.java.options                          | &lt;undefined&gt; 
        | The extra Java options for the JDBC query engine                      
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.jdbc.memory                                | 1g                
        | The heap memory for the JDBC query engine                             
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.jdbc.session.initialize.sql                                    
       || SemiColon-separated list of SQL statements to be initialized in the 
newly created engine session before queries.                                    
                                                                                
                                                                                
                                                                                
                [...]
+| kyuubi.engine.jdbc.type                                  | &lt;undefined&gt; 
        | The short name of JDBC type                                           
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.kubernetes.submit.timeout                  | PT30S             
        | The engine submit timeout for Kubernetes application.                 
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.operation.convert.catalog.database.enabled | true              
        | When set to true, The engine converts the JDBC methods of set/get 
Catalog and set/get Schema to the implementation of different engines           
                                                                                
                                                                                
                                                                                
                  [...]
+| kyuubi.engine.operation.log.dir.root                     | 
engine_operation_logs     | Root directory for query operation log at 
engine-side.                                                                    
                                                                                
                                                                                
                                                                                
                                          [...]
+| kyuubi.engine.pool.name                                  | engine-pool       
        | The name of the engine pool.                                          
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.pool.selectPolicy                          | RANDOM            
        | The select policy of an engine from the corresponding engine pool 
engine for a session. <ul><li>RANDOM - Randomly use the engine in the 
pool</li><li>POLLING - Polling use the engine in the pool</li></ul>             
                                                                                
                                                                                
                            [...]
+| kyuubi.engine.pool.size                                  | -1                
        | The size of the engine pool. Note that, if the size is less than 1, 
the engine pool will not be enabled; otherwise, the size of the engine pool 
will be min(this, kyuubi.engine.pool.size.threshold).                           
                                                                                
                                                                                
                    [...]
+| kyuubi.engine.pool.size.threshold                        | 9                 
        | This parameter is introduced as a server-side parameter controlling 
the upper limit of the engine pool.                                             
                                                                                
                                                                                
                                                                                
                [...]
+| kyuubi.engine.session.initialize.sql                                         
       || SemiColon-separated list of SQL statements to be initialized in the 
newly created engine session before queries. This configuration can not be used 
in JDBC url due to the limitation of Beeline/JDBC driver.                       
                                                                                
                                                                                
                [...]
+| kyuubi.engine.share.level                                | USER              
        | Engines will be shared in different levels, available configs are: 
<ul> <li>CONNECTION: engine will not be shared but only used by the current 
client connection</li> <li>USER: engine will be shared by all sessions created 
by a unique username, see also kyuubi.engine.share.level.subdomain</li> 
<li>GROUP: the engine will be shared by all sessions created by all users 
belong to the same primary group na [...]
+| kyuubi.engine.share.level.sub.domain                     | &lt;undefined&gt; 
        | (deprecated) - Using kyuubi.engine.share.level.subdomain instead      
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.share.level.subdomain                      | &lt;undefined&gt; 
        | Allow end-users to create a subdomain for the share level of an 
engine. A subdomain is a case-insensitive string values that must be a valid 
zookeeper subpath. For example, for the `USER` share level, an end-user can 
share a certain engine within a subdomain, not for all of its clients. 
End-users are free to create multiple engines in the `USER` share level. When 
disable engine pool, use 'default' if [...]
+| kyuubi.engine.single.spark.session                       | false             
        | When set to true, this engine is running in a single session mode. 
All the JDBC/ODBC connections share the temporary views, function registries, 
SQL configuration and the current database.                                     
                                                                                
                                                                                
                   [...]
+| kyuubi.engine.spark.event.loggers                        | SPARK             
        | A comma-separated list of engine loggers, where 
engine/session/operation etc events go.<ul> <li>SPARK: the events will be 
written to the Spark listener bus.</li> <li>JSON: the events will be written to 
the location of kyuubi.engine.event.json.log.path</li> <li>JDBC: to be 
done</li> <li>CUSTOM: to be done.</li></ul>                                     
                                                   [...]
+| kyuubi.engine.spark.python.env.archive                   | &lt;undefined&gt; 
        | Portable Python env archive used for Spark engine Python language 
mode.                                                                           
                                                                                
                                                                                
                                                                                
                  [...]
+| kyuubi.engine.spark.python.env.archive.exec.path         | bin/python        
        | The Python exec path under the Python env archive.                    
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.spark.python.home.archive                  | &lt;undefined&gt; 
        | Spark archive containing $SPARK_HOME/python directory, which is used 
to init session Python worker for Python language mode.                         
                                                                                
                                                                                
                                                                                
               [...]
+| kyuubi.engine.submit.timeout                             | PT30S             
        | Period to tolerant Driver Pod ephemerally invisible after submitting. 
In some Resource Managers, e.g. K8s, the Driver Pod is not visible immediately 
after `spark-submit` is returned.                                               
                                                                                
                                                                                
               [...]
+| kyuubi.engine.trino.connection.keystore.password         | &lt;undefined&gt; 
        | The keystore password used for connecting to trino cluster            
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.trino.connection.keystore.path             | &lt;undefined&gt; 
        | The keystore path used for connecting to trino cluster                
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.trino.connection.keystore.type             | &lt;undefined&gt; 
        | The keystore type used for connecting to trino cluster                
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.trino.connection.password                  | &lt;undefined&gt; 
        | The password used for connecting to trino cluster                     
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.trino.connection.truststore.password       | &lt;undefined&gt; 
        | The truststore password used for connecting to trino cluster          
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.trino.connection.truststore.path           | &lt;undefined&gt; 
        | The truststore path used for connecting to trino cluster              
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.trino.connection.truststore.type           | &lt;undefined&gt; 
        | The truststore type used for connecting to trino cluster              
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.trino.event.loggers                        | JSON              
        | A comma-separated list of engine history loggers, where 
engine/session/operation etc events go.<ul> <li>JSON: the events will be 
written to the location of kyuubi.engine.event.json.log.path</li> <li>JDBC: to 
be done</li> <li>CUSTOM: to be done.</li></ul>                                  
                                                                                
                                    [...]
+| kyuubi.engine.trino.extra.classpath                      | &lt;undefined&gt; 
        | The extra classpath for the Trino query engine, for configuring other 
libs which may need by the Trino engine                                         
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.trino.java.options                         | &lt;undefined&gt; 
        | The extra Java options for the Trino query engine                     
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.trino.memory                               | 1g                
        | The heap memory for the Trino query engine                            
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.type                                       | SPARK_SQL         
        | Specify the detailed engine supported by Kyuubi. The engine type 
bindings to SESSION scope. This configuration is experimental. Currently, 
available configs are: <ul> <li>SPARK_SQL: specify this engine type will launch 
a Spark engine which can provide all the capacity of the Apache Spark. Note, 
it's a default engine type.</li> <li>FLINK_SQL: specify this engine type will 
launch a Flink engine which c [...]
+| kyuubi.engine.ui.retainedSessions                        | 200               
        | The number of SQL client sessions kept in the Kyuubi Query Engine web 
UI.                                                                             
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.ui.retainedStatements                      | 200               
        | The number of statements kept in the Kyuubi Query Engine web UI.      
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.ui.stop.enabled                            | true              
        | When true, allows Kyuubi engine to be killed from the Spark Web UI.   
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.user.isolated.spark.session                | true              
        | When set to false, if the engine is running in a group or server 
share level, all the JDBC/ODBC connections will be isolated against the user. 
Including the temporary views, function registries, SQL configuration, and the 
current database. Note that, it does not affect if the share level is 
connection or user.                                                             
                                [...]
+| kyuubi.engine.user.isolated.spark.session.idle.interval  | PT1M              
        | The interval to check if the user-isolated Spark session is timeout.  
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
+| kyuubi.engine.user.isolated.spark.session.idle.timeout   | PT6H              
        | If kyuubi.engine.user.isolated.spark.session is false, we will 
release the Spark session if its corresponding user is inactive after this 
configured timeout.                                                             
                                                                                
                                                                                
                          [...]
+| kyuubi.engine.yarn.submit.timeout                        | PT30S             
        | The engine submit timeout for YARN application.                       
                                                                                
                                                                                
                                                                                
                                                                                
              [...]
 
 ### Event
 
diff --git 
a/kyuubi-common/src/main/scala/org/apache/kyuubi/config/KyuubiConf.scala 
b/kyuubi-common/src/main/scala/org/apache/kyuubi/config/KyuubiConf.scala
index 87f8fcad1..8f7e4bb4e 100644
--- a/kyuubi-common/src/main/scala/org/apache/kyuubi/config/KyuubiConf.scala
+++ b/kyuubi-common/src/main/scala/org/apache/kyuubi/config/KyuubiConf.scala
@@ -2005,8 +2005,9 @@ object KyuubiConf {
       " all the capacity of the Trino.</li>" +
       " <li>HIVE_SQL: specify this engine type will launch a Hive engine which 
can provide" +
       " all the capacity of the Hive Server2.</li>" +
-      " <li>JDBC: specify this engine type will launch a JDBC engine which can 
provide" +
-      " a MySQL protocol connector, for now we only support Doris 
dialect.</li>" +
+      " <li>JDBC: specify this engine type will launch a JDBC engine which can 
forward " +
+      " queries to the database system through the certain JDBC driver, " +
+      " for now, it supports Doris and Phoenix.</li>" +
       " <li>CHAT: specify this engine type will launch a Chat engine.</li>" +
       "</ul>")
     .version("1.4.0")

Reply via email to