@clickzetta/cz-cli-darwin-arm64 0.3.94 → 0.3.96

package/bin/skills/lakehouse-doc-en/references/Ingestion.md

@@ -0,0 +1,87 @@
+# Data Ingestion
+
+Singdata Lakehouse supports three categories of data ingestion: real-time database sync, file import, and message queue ingestion. Choose based on your data source.
+
+***
+
+## I have a relational database (MySQL / PostgreSQL / SQL Server, etc.)
+
+**Recommended: Studio Data Sync Tasks** — visual configuration, supports full load + real-time incremental sync, no coding required.
+
+| Scenario                                                 | Approach                          | Reference                                                           |
+| -------------------------------------------------------- | --------------------------------- | ------------------------------------------------------------------- |
+| Single table or a few tables, real-time sync             | Studio real-time sync task (CDC)  | [Real-time Sync Task](realtime_sync.md)                             |
+| Full database sync, mirroring a source DB into Lakehouse | Studio multi-table real-time sync | [Multi-table Real-time Sync Guide](multitable_realtime_sync_sop.md) |
+| Offline periodic sync (T+1 or H+1)                       | Studio offline sync task          | [Offline Sync Task](batch_sync.md) · [FAQ](batch_sync_sop.md)       |
+| Oracle database real-time sync                           | Bluepipe integration              | [Oracle Real-time Sync](bluepipe-oracle-lakehouse-datasync.md)      |
+| Sync over private network (VPC / Private Link)           | Studio + Private Link             | [RDS Sync over VPC](studio-di-privatelink-vpc-from-rds.md)          |
+
+> **End-to-end example**: [Complete workflow from MySQL to BI reports](quick_start_bi_analysis.md)
+
+***
+
+## I have files (CSV / Parquet / JSON, etc.)
+
+| Scenario                                                 | Approach                         | Reference                                                                                         |
+| -------------------------------------------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------- |
+| Files are local, quick import                            | Studio upload or PUT + COPY INTO | [Import Local Data](load-data-local.md) · [Quick Upload](quick_start_upload_data.md)              |
+| Files are on OSS / S3 / COS, one-time import             | COPY INTO + Volume               | [Bulk Import from Object Storage](load-data-oss.md)                                               |
+| Files are continuously uploaded to OSS / S3, auto-ingest | Pipe (object storage mode)       | [Pipe Continuous Ingestion](pipe-introduction.md) · [Object Storage Pipe](pipe-storage-object.md) |
+| Feishu spreadsheet / online spreadsheet import           | Feishu data import               | [How to Import Feishu Spreadsheets](import-feishu-data.md)                                        |
+
+> **Choosing between the two continuous ingestion modes**: Use `LIST_PURGE` if you don't need to keep the source files after upload. Use `EVENT_NOTIFICATION` if you need to retain the source files or require near-real-time triggering. See [Pipe Continuous Ingestion](pipe-introduction.md) for details.
+
+***
+
+## I have a Kafka message stream
+
+| Scenario                                                | Approach                            | Reference                                                         |
+| ------------------------------------------------------- | ----------------------------------- | ----------------------------------------------------------------- |
+| Continuously consume a Kafka topic and write to a table | Pipe (Kafka mode)                   | [Kafka Pipe](pipe-kafka.md)                                       |
+| Configure Kafka sync visually via Studio                | Studio real-time sync task          | [Kafka Real-time Sync](realtime_sync.md)                          |
+| Complex message processing before ingestion             | Kafka external table + Table Stream | [Kafka External Table + Table Stream](pipe-kafka-table-stream.md) |
+
+***
+
+## I have a custom data source or need programmatic ingestion
+
+| Scenario                                               | Approach                | Reference                                                        |
+| ------------------------------------------------------ | ----------------------- | ---------------------------------------------------------------- |
+| Java application bulk write                            | Java SDK BulkLoad       | [Java SDK Bulk Upload](use-java-sdk-upload-data-local.md)        |
+| Java application real-time write (millisecond latency) | Java SDK RealtimeStream | [Java SDK Real-time Upload](use-java-sdk-realtime-uploaddata.md) |
+| Python application bulk write                          | Python SDK              | [Python SDK Upload](use-python-sdk-upload-data.md)               |
+| Python data processing tasks                           | Studio Python task      | [Python Task Development](python-task-dev.md)                    |
+| Write from Flink                                       | Flink Connector         | [Flink Write to Lakehouse](flink-write-connector.md)             |
+| Use open-source ETL tools                              | Airbyte / DataX         | [Ecosystem Integrations](ecosystem-all.md)                       |
+
+***
+
+## I'm migrating from another data warehouse
+
+| Source                                 | Reference                                                                                |
+| -------------------------------------- | ---------------------------------------------------------------------------------------- |
+| Migrating from Snowflake               | [Snowflake ETL Pipeline Migration Guide](migrate-snowflake-realtime-etl-to-lakehouse.md) |
+| Migrating from Spark data engineering  | [Spark Best Practices Migration Guide](spark-lakehouse-iceberg-rest.md)                  |
+| Migrating from Alibaba Cloud Data Lake | [Alibaba Cloud Data Lake Migration Guide](ingesting-data-from-alibaba-cloud-datalake.md) |
+
+***
+
+## Not sure which approach to use?
+
+Use this decision tree:
+
+```
+What is your data source?
+├── Relational database (MySQL / PG / SQL Server)
+│   ├── Need real-time sync → Studio multi-table real-time sync
+│   └── Offline periodic sync → Studio offline sync task
+├── Files (CSV / Parquet / JSON)
+│   ├── One-time import → COPY INTO
+│   └── Continuous auto-ingest → Pipe (object storage mode)
+├── Kafka message stream
+│   ├── Simple consume and ingest → Pipe (Kafka mode)
+│   └── Complex processing → Kafka external table + Table Stream
+└── Custom / programmatic ingestion → SDK or Python task
+```
+
+For a full comparison of all approaches, see: [A Comprehensive Guide to Ingesting Data into Singdata Lakehouse](a_comprehensive_guide_to_ingesting_data_into_clickzetta_lakehouse.md)

package/bin/skills/lakehouse-doc-en/references/Introduction.md

@@ -0,0 +1,148 @@
+# AI Gateway User Guide
+
+## Preface
+
+This guide is designed to provide enterprise users with comprehensive instructions for the Singdata AI Gateway product, covering core features, detailed operational workflows, best practices, and frequently asked questions. Singdata AI Gateway is an enterprise-grade AI gateway service launched by the Singdata platform, delivering core capabilities such as unified multi-model API management, intelligent routing and scheduling, BYOK (Bring Your Own Key) model integration, usage statistics and analysis, and permission management. It helps enterprises simplify the process of integrating large models from multiple vendors, reduce operational complexity, and ensure the stability, security, and observability of AI services.
+
+## 1. Product Introduction
+
+### 1.0 What Is AI Gateway
+
+**AI Gateway (AI Gateway / LLM Gateway)** is a traffic governance middleware purpose-built for large model services. It acts as the unified access layer and control plane between AI applications and multiple AI model services.
+
+Think of it as the "intelligent front desk" for enterprise AI capabilities: all AI invocation requests pass through the gateway first, which uniformly decides who can use it, how much they can use, which model to use, how much it costs, and whether it is secure — then returns the processed result to the application.
+
+**The difference between AI Gateway and a traditional API gateway**: AI Gateway is not a simple upgrade of a traditional API gateway. It is a brand-new component designed for the characteristics of large model services (long connections, high bandwidth, high latency, streaming transmission, token-based billing):
+
+| Comparison dimension | AI Gateway | Traditional API Gateway |
+|---|---|---|
+| Core objective | Large model traffic governance and AI capability control | General API traffic forwarding and management |
+| Billing unit | Token-level precise metering | Request count / bandwidth |
+| Traffic characteristics | Long connections, streaming transmission, large payloads | Short connections, request-response pattern |
+| Core capabilities | Semantic caching, model routing, content safety | Load balancing, rate limiting, authentication |
+| Protocol support | AI-specific protocols such as OpenAI API, Anthropic API | General protocols such as HTTP, gRPC, WebSocket |
+
+**How it works**:
+
+1. **Access layer processing**: Receives HTTP/gRPC requests from applications, performs identity authentication and basic parameter validation
+2. **Request pre-processing**: Desensitizes sensitive information, checks prompt safety, validates quotas
+3. **Intelligent routing decision**: Selects the optimal model service based on routing rules and real-time status
+4. **Upstream forwarding**: Forwards the standardized request to the selected model service; the gateway manages API keys uniformly
+5. **Response processing**: Receives the model's streaming response, performs content safety review, and counts token usage
+6. **Result return**: Returns the processed response to the client while recording logs and monitoring data
+
+### 1.1 Product Positioning
+
+AI Gateway is a **unified access and management gateway** purpose-built by the Singdata platform for enterprise-grade AI applications, serving as the core hub of enterprise AI infrastructure. It connects upward to various internal enterprise AI applications (intelligent customer service, content generation, code assistance, data analysis, etc.) and connects downward to major domestic and international LLM vendors, industry-specific vertical models, and enterprise-owned models.
+
+In light of the common pain points in enterprise AI adoption, Singdata AI Gateway addresses the following core challenges:
+
+* **API Fragmentation**: Different vendors provide inconsistent API specifications, requiring enterprises to develop separate adapter code for each vendor, resulting in high maintenance costs
+* **High Operational Complexity**: When using multiple models in parallel, there is a lack of unified monitoring, alerting, and troubleshooting mechanisms
+* **Uncontrollable Costs**: Unable to granularly manage AI usage by team, project, or application dimension, leading to easy overspending
+* **Data Security Risks**: Increased risk of data leakage when invoking models across multiple channels, with a lack of unified security control and auditing capabilities
+* **Insufficient Flexibility**: Switching model vendors or adding new models requires changes to business code, impacting business continuity
+
+With Singdata AI Gateway, enterprises can achieve "integrate once, use everywhere," significantly reducing the development and operational costs of AI applications while enhancing the stability, security, and observability of AI services.
+
+### 1.2 Core Product Value
+
+Singdata AI Gateway delivers four core values for enterprises:
+
+1. **Cost Reduction and Efficiency**: Unified API interface reduces the workload of multi-model adapter development; intelligent routing strategies automatically select the optimal cost-performance model, lowering AI invocation costs
+2. **Unified Management**: Centrally manage all model resources and invocation permissions, achieving "one platform to manage all AI"
+3. **Flexible Expansion**: Support rapid integration of new model vendors and custom models without modifying business code, enabling flexible expansion on demand
+
+### 1.3 Core Advantages
+
+#### 1.3.1 Multi-Model Unified Access
+
+* **Full Vendor Coverage**: Supports major domestic and international LLM vendors such as Alibaba Cloud Bailian, ByteDance Doubao, and AWS Bedrock
+* **Standard Interface Compatibility**: Provides a REST API interface 100% compatible with OpenAI, allowing existing OpenAI-based business code to work without modification -- simply replace the API endpoint and key for a seamless switch
+* **Multi-Modal Support**: Comprehensive support for multi-modal capabilities including text generation, image understanding, speech recognition and synthesis, and code generation
+* **Model Version Management**: Unified management of different model versions, supporting smooth upgrades and rollbacks
+
+#### 1.3.2 Intelligent Routing and Load Balancing
+
+* **Multi-Dimensional Routing Strategies**: Supports intelligent routing based on multiple dimensions such as price, throughput, latency, and region
+
+  * **Price Priority**: Automatically selects the lowest-price available provider to maximize cost efficiency
+  * **Throughput Priority**: Automatically selects the highest-throughput provider to handle high-concurrency scenarios
+  * **Latency Priority**: Automatically selects the lowest-latency provider to ensure user experience
+
+#### 1.3.3 BYOK Seamless Integration
+
+* **Multi-Provider Support**: Currently supports BYOK access for major providers such as Alibaba Cloud Bailian - Beijing, AWS Bedrock US-EAST-1, and BytePlus AP-SOUTHEAST
+* **Zero-Code Integration**: Simply enter your third-party API key on the platform to integrate your own models without any development work
+* **Independent Billing System**: When using BYOK models, billing goes directly through your own third-party provider account, with no additional fees charged by the platform
+* **Unified Management Experience**: BYOK models enjoy the same management experience as platform built-in models, supporting unified routing, monitoring, and usage statistics
+
+#### 1.3.4 Granular Usage Management
+
+* **Multi-Dimensional Usage Statistics**: Supports Token consumption statistics by model, account, API Key, user, time, and other dimensions
+* **Fine-Grained Quota Control**: Supports setting independent Token quotas and validity periods for each API Key to prevent unexpected overspending
+* **Real-Time Usage Monitoring**: Real-time display of Token consumption trends with usage threshold alerts
+* **Cost Allocation and Analysis**: Automatically generates multi-dimensional cost analysis reports, supporting cost allocation by team and project
+* **Data Export**: Supports exporting all usage data in Excel format for internal financial accounting
+
+#### 1.3.5 Enterprise-Grade Security Management
+
+* **Fine-Grained Permission Management**: Supports Role-Based Access Control (RBAC), with different users having different operational permissions
+
+### 1.4 Core Functional Modules
+
+Singdata AI Gateway includes the following five core functional modules, corresponding to the left navigation menu:
+
+| Functional Module | Core Capabilities | Business Value |
+| --- | --- | --- |
+| **API Key Management** | Key creation / editing / deletion / disabling, validity period configuration, Token quota settings, routing policy binding, batch operations, usage viewing | Achieve permission isolation and usage control across different businesses and teams |
+| **Model Marketplace** | Model display and search, model detail viewing, one-click copy of invocation examples, model runtime status monitoring | Quickly understand platform-supported model capabilities, obtain integration code, and monitor model runtime status |
+| **BYOK** | Third-party provider management, own key configuration, model selection, connectivity testing, BYOK model management | Seamlessly integrate enterprise-owned third-party model services while retaining original accounts and billing systems |
+| **Usage Statistics** | Multi-dimensional usage query, trend analysis, detail viewing, data export, cost analysis | Gain comprehensive insight into AI cost composition and achieve granular cost management and allocation |
+| **Permission Management** | User authorization, role management, permission revocation | Ensure platform security and achieve permission isolation for different users |
+
+### 1.5 Architecture
+
+Singdata AI Gateway adopts a cloud-native distributed architecture consisting of four layers: access layer, routing layer, model layer, and management layer:
+
+1. **Access Layer**: Provides a unified API access endpoint, responsible for request authentication, rate limiting, and protocol conversion
+2. **Routing Layer**: The core intelligent routing engine, responsible for forwarding requests to the optimal model access point based on routing strategies
+3. **Model Layer**: Interfaces with various model vendor APIs, responsible for request forwarding and response processing
+4. **Management Layer**: Provides management capabilities including API Key management, model management, BYOK management, usage statistics, and permission management
+
+### 1.6 Applicable Scenarios
+
+#### 1.6.1 Enterprise Multi-Model Unified Management Scenario
+
+**Business Pain Point**: Enterprises simultaneously use large models from multiple vendors, each with its own API interface, key management, and billing system, resulting in high development and operational complexity and difficult cost control.
+
+**Solution**: Unify access to all models through Singdata AI Gateway, provide a standardized API interface, and achieve centralized key management, routing and scheduling, usage statistics, and monitoring and alerting.
+
+#### 1.6.2 Rapid AI Application Development Scenario
+
+**Business Pain Point**: Developers need to spend significant time learning API documentation from different vendors and writing adapter code, resulting in long development cycles and low efficiency.
+
+**Solution**: Singdata AI Gateway provides a standard API interface 100% compatible with OpenAI, allowing developers to invoke all models by learning a single API specification. The platform also provides rich invocation examples and SDKs to further lower the development barrier.
+
+#### 1.6.3 Granular AI Cost Management Scenario
+
+**Business Pain Point**: Enterprise AI costs grow rapidly, but it is impossible to accurately track AI usage by team or project, making cost allocation difficult and overspending likely.
+
+**Solution**: Singdata AI Gateway supports creating independent API Keys for each team and project, with independent Token quotas. The platform provides multi-dimensional usage statistics and cost analysis reports, helping enterprises achieve accurate cost allocation and control.
+
+#### 1.6.4 Self-Owned Model Integration Scenario
+
+**Business Pain Point**: Enterprises have already activated model services with third-party providers and wish to retain their original accounts and billing systems while managing them through a unified gateway.
+
+**Solution**: Through Singdata AI Gateway's BYOK feature, simply enter your enterprise's own API key to integrate third-party models into the unified gateway, enjoying a management experience fully consistent with platform built-in models.
+
+### 1.7 Comparison with Traditional Integration Approaches
+
+| Comparison Dimension | Traditional Multi-Model Integration Approach | Singdata AI Gateway Integration Approach |
+| --- | --- | --- |
+| Development Effort | Develop separate adapter code for each vendor, high workload | Develop once, invoke all models; 80% workload reduction |
+| Operational Complexity | Parallel operation of multiple systems, high complexity | Unified platform management, simple operations |
+| Cost Control | Unable to achieve granular control, costs uncontrollable | Multi-dimensional usage statistics and quotas, precise cost control |
+| Model Switching | Requires modifying business code, impacts business continuity | No code changes required, one-click switching |
+| Security Control | Decentralized management, high security risk | Unified security control, comprehensive data protection |
+| Observability | Lack of unified monitoring, difficult troubleshooting | Full-link observability, rapid issue localization |

package/bin/skills/lakehouse-doc-en/references/JDBC-Driver.md

@@ -0,0 +1,62 @@
+# JDBC Driver
+
+## Java Environment Requirements
+
+The Singdata Lakehouse JDBC driver requires Java version 1.8 or higher. Please ensure that your development environment has the appropriate version of Java installed and configured.
+
+## JDBC Driver Download
+
+You can download and use the Singdata Lakehouse JDBC driver in the following two ways:
+
+1. Through Maven Dependency
+   Add the following dependency code to your project's `pom.xml` file:
+   ```xml
+   <dependency>
+     <groupId>com.clickzetta</groupId>
+     <artifactId>clickzetta-java</artifactId>
+     <version>${version}</version>
+   </dependency>
+   ```
+2. Directly download the SDK Jar package, you can find and download the corresponding version of the Jar package on the Maven repository page.
+
+* [Download Link 1](https://central.sonatype.com/artifact/com.clickzetta/clickzetta-java/versions)
+* [Download Link 2](https://mvnrepository.com/artifact/com.clickzetta/clickzetta-java)
+
+## Configure JDBC Driver
+
+To use the Singdata Lakehouse JDBC driver to connect to Singdata Lakehouse, you need to configure it according to the following steps:
+
+### JDBC Driver Class
+
+In your JDBC application, use the `com.clickzetta.client.jdbc.ClickZettaDriver` class to load the driver.
+
+### JDBC Connection String
+
+When using the JDBC driver to connect to Singdata Lakehouse, the syntax format of the JDBC connection string is as follows:
+```
+jdbc:clickzetta://<service_instance_name>.api.singdata.com/<workspace_name>?<connection_params>
+```
+* Connection Parameters Description:
+
+  * `<service_instance_name>`: Lakehouse service instance name. When a Lakehouse service instance is activated in a specified Region, the system will automatically assign an instance name. You can find the Lakehouse instance name on the Singdata product console page.
+
+    ![](.topwrite/assets/image_1739867152425.png)
+
+  * `<workspace_name>`: Workspace name.
+
+  * `<connection_params>`: Supports defining parameters using the `=` format, with multiple parameters separated by the `&` symbol. Common parameters are listed in the table below:
+
+| Parameter       | Value                                                                 |
+| -------------- | ---------------------------------------------------------------------- |
+| username       | Singdata login username                                                |
+| password       | Login user password                                                    |
+| schema         | Specifies the default schema to connect to, optional                                                       |
+| virtualCluster | Configures the virtual cluster used by default for JDBC connections, optional. If not specified, you need to use the SQL command `use vcluster <vc_name>` after connecting to specify it for use |
+| use\_http=true | Whether to use the HTTP protocol, default is HTTPS. This parameter needs to be specified when using a private link connection                          |
+
+#### Connection String Example
+```
+jdbc:clickzetta://lakehouse_instance_name.api.singdata.com/default?username=Alice&password=xxxxx&schema=public&virtualCluster=default
+```
+
+

package/bin/skills/lakehouse-doc-en/references/JDBC_MindsDB_ML_LLM.md

@@ -0,0 +1,255 @@
+# Connect to MindsDB for Data Analysis Based on ML and LLM
+
+## Step Overview:
+
+1. Add a MySQL type data source in the "Data Source" section of Singdata Lakehouse, and connect to [MindsDB](mindsdb.md) via the MySQL protocol.
+2. Create a new "JDBC Script" task type in Singdata Lakehouse, and select the MindsDB data source created in the first step.
+3. This allows you to operate and manage MindsDB using MySQL syntax in Singdata Lakehouse, and perform various predictive analyses on the data in Singdata Lakehouse through models managed by MindsDB (including traditional machine learning models and LLM).
+4. Similar to SQL tasks, you can directly schedule and maintain JDBC tasks periodically and achieve workflow orchestration with other tasks by setting task dependencies.
+
+## Create a New MindsDB Connection
+
+Before creating a new connection, please ensure that your MindsDB has opened the MySQL service port 47335.
+
+![](.topwrite/assets/image_1718691461767.png)
+
+## Create a New JDBC Script Task and View MindsDB Metadata
+
+![](.topwrite/assets/image_1718691763216.png)
+
+Execute the following command to view the ML ENGINES deployed in MindsDB:
+
+```sql
+-- List ML ENGINES deployed in MindsDB
+SHOW ENGINES;
+```
+
+## List models deployed in MindsDB
+
+```sql
+-- List models deployed in MindsDB
+SHOW MODELS;
+```
+
+## Make predictions using MindsDB model
+
+Execute the following command to make predictions using a deployed model in MindsDB:
+
+```sql
+SELECT * FROM mindsdb.<model_name> WHERE <conditions>;
+```
+
+## Task Scheduling and Maintenance
+
+Similar to SQL tasks, JDBC tasks can be scheduled and maintained on a periodic basis. You can orchestrate workflows with other tasks by configuring task dependencies.
+
+## Create a new JDBC script task to connect MindsDB to Singdata Lakehouse
+
+```
+CREATE DATABASE if not exists clickzetta_gharchive --- display name for database.
+
+WITH ENGINE = 'clickzetta', --- name of the mindsdb handler
+
+PARAMETERS = {
+
+"service": "api.singdata.com", --- Singdata Lakehouse service address.
+
+"workspace": "", --- Singdata workspace.
+
+"instance": "", --- account instance id.
+
+"vcluster": "default", --- vcluster
+
+"username": "", --- your usename.
+
+"password": "", --- Your password.
+
+"schema": "public" --- common schema PUBLIC.
+
+};
+
+-- query data from Singdata lakehouse
+
+SELECT * FROM clickzetta_gharchive.collections;
+
+```
+
+![](.topwrite/assets/image_1718692091502.png)
+
+## Create a new JDBC script task to perform sentiment classification on text data in the Lakehouse table using the Huggingface sentiment classifier model
+
+### Create a new model
+
+```
+CREATE MODEL if not exists proj_gharchive.hf_sentiment_classifier
+
+PREDICT sentiment
+
+USING
+
+engine='huggingface',
+
+model_name= 'cardiffnlp/twitter-roberta-base-sentiment',
+
+task='text-classification',
+
+input_column = 'description',
+
+labels=['negative','neutral','positive'];
+
+DESCRIBE proj_gharchive.hf_sentiment_classifier;
+
+```
+
+By executing the DESCRIBE proj\_gharchive.hf\_sentiment\_classifier command, you can see that the hf\_sentiment\_classifier model has been deployed and activated.
+
+![](.topwrite/assets/image_1718692548739.png)
+
+### Batch Prediction (Sentiment Classification) on Data in Singdata Lakehouse
+
+```
+-- Text sentiment classification of the description of Huggingface's 7-day popular Repos
+
+SELECT model.sentiment AS description_sentiment,
+
+        model.sentiment_explain,
+        
+        input.*
+
+FROM clickzetta_gharchive.github_timeline_past_7_days_hot_repos AS input
+
+JOIN proj_gharchive.hf_sentiment_classifier AS model
+
+WHERE input.description IS NOT NULL
+
+ORDER BY input.star_increase DESC;
+
+```
+
+Running the above SQL, check the query result's description\_sentiment field, and you can see the different classification results for the input\_column = 'description' column, including neutral, positive, or negative (the labels value in the model).
+
+![](.topwrite/assets/image_1718692823877.png)
+
+## Create a new JDBC script task to classify the sentiment of text data in the Lakehouse table using the OpenAI large model
+
+In this section, we will classify the sentiment of text with the help of the OpenAI GPT-3.5 model.
+
+### Create a new model
+
+```
+CREATE ML\_ENGINE if not exists openai_engine
+
+FROM openai
+
+USING
+
+openai_api_key = 'sk-';
+
+-- DROP MODEL if exists proj_gharchive.gpt35t_sentiment_classifier_openai;
+
+CREATE MODEL if not exists proj_gharchive.gpt35t_sentiment_classifier_openai
+
+PREDICT sentiment
+
+USING
+
+engine = 'openai_engine',
+
+prompt_template = 'describe the sentiment of the description
+
+strictly as "positive", "neutral", or "negative".
+
+"I love the product":positive
+
+"It is a scam":negative
+
+"{{description}}.":';
+
+```
+
+### Batch Prediction on Data in Singdata Lakehouse (Sentiment Classification)
+
+```
+--gpt35t_7-day popular Repo description text sentiment classification
+
+SELECT output.*,
+
+input.*
+
+FROM clickzetta_gharchive.github_timeline_past_7_days_hot_repos AS input
+
+JOIN proj_gharchive.gpt35t_sentiment_classifier AS output
+
+LIMIT 10;
+
+```
+
+## Create a New JDBC Script Task to Forecast Lakehouse Time Series Data Using the StatsForecast Model
+
+### Create a New Model
+
+**StatsForecast** provides a set of widely used univariate time series forecasting models, including `ARIMA` using exponential smoothing and automated modeling optimized for high performance with `numba`.
+
+```
+CREATE MODEL if not exists proj_gharchive.quarterly_repo_star_incre_forecaster
+
+FROM clickzetta_gharchive
+
+(SELECT *
+
+FROM github_timeline_from_20220101_repos_star_incre_monthly
+
+WHERE repo_id = 214011414
+
+)
+
+PREDICT star_increase
+
+ORDER BY month_of_date
+
+GROUP BY repo_id
+
+WINDOW 12
+
+HORIZON 3
+
+USING ENGINE = 'statsforecast';
+
+```
+
+### Batch Prediction on Data in Singdata Lakehouse
+
+```
+-- statsforecast_monthly star growth forecast
+
+SELECT t.*
+
+FROM clickzetta_gharchive.github_timeline_from_20220101_repos_star_incre_monthly AS t
+
+WHERE t.repo_id = 214011414
+
+UNION ALL
+
+SELECT m.repo_id,
+
+'kingToolboxWindTerm' AS repo_name,
+
+m.month_of_date,
+
+m.star_increase
+
+FROM proj_gharchive.quarterly_repo_star_incre_forecaster AS m
+
+JOIN clickzetta_gharchive.github_timeline_from_20220101_repos_star_incre_monthly AS t
+
+WHERE t.month_of_date > LATEST AND
+
+t.repo_id = 214011414;
+
+```
+
+![](.topwrite/assets/image_1718696051211.png)
+
+## Task Scheduling and Workflow Orchestration
+
+Similar to SQL tasks, JDBC tasks can be directly scheduled and maintained periodically. Workflow orchestration with other tasks can be achieved by setting task dependencies.