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

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

@@ -0,0 +1 @@
+

package/bin/skills/lakehouse-doc-en/references/web-job-history.md

@@ -0,0 +1,178 @@
+# Lakehouse Job History
+
+Through the job history page, you can view detailed information about queries executed in the Lakehouse account over the past 7 days. This page displays a list of historical jobs, including tasks submitted using your own jdbc jar, studio temporary queries, and studio periodic scheduling tasks.
+
+## Job History
+
+### View History
+
+Click on Compute in the left navigation bar, then click on Job History to enter the job history page:
+
+![](.topwrite/assets/image_1740557896004.png)
+
+## Job History Search
+- Supports searching by job ID generated by SQL jobs
+- Supports searching by status
+     - setup: SQL initialization phase, including operations such as compilation and optimization
+     - resuming_cluster: Waiting for vc to start, if it takes a long time, please contact technical support
+     - queued: Job is queued waiting for resources, if it takes a long time, check if vc resources are fully occupied, consider expanding vc
+     - running: SQL data processing time, you can click on diagnostics to view the time taken by each operator
+     - finish: Job has ended, some jobs may have a cleanup process in this stage, which can take time
+- Supports filtering by duration
+- Supports filtering by time, currently up to 10,000 jobs from the past seven days can be queried
+- Supports filtering by the name of the cluster where the job ran
+- Supports filtering by the job submitter
+- Supports filtering by queryTag
+    Users can use the command set query_tag="" to indicate the source of the job and tag the job when submitting SQL. This makes it easy to filter in this interface
+    - Set query_tag in the studio interface, select two days of SQL to execute simultaneously
+    ```SQL
+        set query_tag="test";
+        select 1;
+    ```
+- Add `query_tag` in the JDBC URL, so each submitted SQL will carry the `query_tag` to indicate the source, which can be filtered on the page.
+    ```text
+    jdbc:clickzetta://xxxx.api.singdata.com/default?schema=public&query_tag=test
+
+    ```
+- Set query_tag in python code
+```python
+# Establish connection
+conn = connect(username='',
+ password='', 
+service='api.singdata.com', 
+instance='jnsxwfyr',
+ workspace='', schema='public', vcluster='default') 
+# Execute SQL
+cursor = conn.cursor() 
+my_param["hints"]["query_tag"] ="test"
+cursor.execute('select 1;', parameters=my_param)
+
+```
+- The default Schema for the job, the context in which the submitted SQL runs, can be obtained through select current_schema().
+
+## Job Details
+
+Enter the job details to view detailed information about the job.
+
+![](.topwrite/assets/image_1740557994319.png)
+
+**Field Information Explained as Follows**
+
+|        |                                                                                                                      |
+| ------ | -------------------------------------------------------------------------------------------------------------------- |
+| Field  | Description                                                                                                          |
+| Status | Indicates the status of the job, currently includes
Ready to execute: The job is being compiled and other operations
Waiting to execute: Waiting for resources
Executing: Running, the job is processing data
Execution successful: The job ran successfully
Execution terminated: The job was terminated
Execution failed: The job failed to run |
+| Submit Time | The time the server received the request to start                                                                 |
+| End Time    | The time the job ended                                                                                           |
+| Duration    | Includes compilation optimization, starting computing resources, queuing, and job running time                                                        |
+| Owner       | The user who submitted the job                                                                                   |
+| Spill to Disk | The size of the data spilled to disk, this parameter can help understand if the performance is slow due to insufficient cluster memory resources                                      |
+| Read from Cache | In the analytical cluster, the already read data will be cached first to speed up computation                                                      |
+| Output Records   | The number of output records of the job                                                                                                            |
+| Consumption     | Refers to the computing resources used by the job, excluding the computing resources while the job is waiting for IO.                                                                                        |
+| Cluster     | The cluster used to run the job                                                                                                            |
+
+### Stage Interface
+
+SQL execution is divided into each stage, and stages are executed from bottom to top. Clicking on a specific stage will show the specific time consumption of each stage.
+
+![](.topwrite/assets/image_1740558003358.png)
+
+**Field information is explained as follows**
+
+|            |                                                                                   |
+| ---------- | --------------------------------------------------------------------------------- |
+| Field         | Description                                                                                |
+| Status         | Indicates the status of the job, currently includes: 
Waiting for execution: waiting for resources
Executing: running, the job is processing data
Execution successful: job ran successfully
Execution failed: job ran unsuccessfully |
+| Start Time       | The start time of the stage, stages in the analytical cluster will run simultaneously                                                       |
+| End Time       | The end time of the job                                                                          |
+| Duration         | The duration of the stage running                                                                       |
+| Spilled to Disk      | The size of the data spilled to disk, this parameter can help understand if the slow performance is due to insufficient memory resources in the cluster                                             |
+| Read from Cache     | In the analytical cluster, the already read data will be cached first. This speeds up computation                                                     |
+| Contains Operator | Stage                                                                             |
+
+### Operator Interface
+
+In the operator interface, you can view the type of each operator and the upstream and downstream dependencies. An operator is a concept in the query plan that represents the specific steps and strategies for executing a query, including data access, transformation, and update.
+
+![](.topwrite/assets/image_1740558011631.png)
+
+**Field information is explained as follows**
+
+|         |                                       |
+| ------- | ------------------------------------- |
+| Belongs to Stage | The stage corresponding to the operator                       |
+| Spilled to Disk   | The size of the data spilled to disk, this parameter can help understand if the slow performance is due to insufficient memory resources in the cluster |
+| Read from Cache  | In the analytical cluster, the already read data will be cached first. This speeds up computation         |
+| Total Rows     | The data currently processed by the operator                        |
+| Time Consumed | operate will run concurrently, currently showing the average time of operate |
+| Field         | Corresponds to the SQL script, corresponding field                          |
+
+### Table Mode
+
+Supports stage switching table mode
+
+![](.topwrite/assets/image_1740558022227.png)
+
+Supports operator switching table mode
+![](.topwrite/assets/image_1740558027758.png)
+
+## Analyzing Failed Jobs
+
+When a job fails to run, you can view the reason for the failure through the details in the job profile. Here are some common failure reasons and solutions:
+
+### SQL Syntax Error
+
+**Error Example**:
+```SQL
+Execute select * from ttt;
+Error: CZLH-42000:[1,15] Semantic analysis exception - table or view not found - uat_demo_project.`public`.ttt
+```
+**Error Code CZLH-42000** indicates an error related to SQL language parsing. [1,15] indicates that the error occurred on line 1, column 15 of the SQL. In this example, the reason is that the `ttt` table does not exist. Please note that if you submit tasks through Studio development, the job editor in development will include descriptive information, which is not submitted to the SQL engine. Therefore, the correct line number should subtract the preceding descriptive information. You can view the correct positional relationship through the job content in the job details or find the error location in the SQL editor.
+
+
+## Analyzing Slow Running Jobs
+
+Slow running jobs may encounter issues during the compilation phase, the virtual cluster startup phase, or the execution phase. Below are the analyses and solutions for these phases:
+
+### Compilation Phase
+
+**Issue**: Job status shows "Preparing to execute".
+
+**Possible Causes and Solutions**:
+
+1. **Complex execution plan**: The job may require a long time to optimize. Please be patient; it should not take more than 10 minutes under normal circumstances.
+2. **Compilation resources are fully occupied**: If you submit a large number of SQLs at once, it may lead to insufficient compilation resources. Please reduce the frequency of SQL submissions. If you have a large number of high-concurrency query requirements, please submit a ticket for assistance.
+
+### Virtual Cluster Startup Phase
+
+**Issue**: Job status shows "Cluster starting". The current status is that the computing cluster is being started.
+
+### Waiting Execution Phase
+
+**Issue**: Job status shows "Waiting to execute".
+
+**Possible Causes and Solutions**:
+
+**Insufficient computing resources in the current cluster**: You can filter and view the currently running jobs through the interface. A large number of running jobs may be causing resource waiting. You can expand resources or terminate large running jobs to free up resources.
+
+### Execution Phase
+
+**Issue**: Job status shows "Running". At this stage, you can click to view the execution status of each operator.
+
+**Possible Causes and Solutions**:
+
+1. **Waiting for resources**: The job may be waiting for resource allocation. Please check the resource usage. If necessary, please submit a ticket for assistance.
+2. **Slow data reading speed**: The job may be executing slowly due to slow data reading speed. Please check the data storage and reading strategy. If necessary, optimize the data storage structure or adjust the reading strategy.
+
+## Viewing Execution Plan and Operator Details
+
+During the execution phase, you can click on the executing operator to query specific steps and strategies. For example, moving the mouse over a specific operator can correspond to the specific operator executed in the SQL. This helps you identify which specific operator is causing the job to run slowly.
+
+![](.topwrite/assets/image_1740558276614.png)
+## Share for Diagnosis  
+
+After entering the assignment details page, click the “Share” button to share the assignment with others. Recipients can view the content without logging in.  
+![](.topwrite/assets/image_1740558353576.png)
+If you need to stop sharing, you can revoke access to the link at any time.  
+If you have any questions or need further assistance, please copy the link above and contact the Lakehouse team. We will diagnose and resolve the issue for you.

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

@@ -0,0 +1,30 @@
+# Web Search
+
+## Feature Overview
+
+Web Search adds internet search capability to Analytics Agent, enabling the agent to automatically invoke external search engines during data analysis to obtain real-time information, achieving combined analysis of "internal data + external knowledge." This is suitable for scenarios requiring correlation analysis between internal data and external events (such as weather, sports events, news, etc.).
+
+## How to Use
+
+Simply ask questions directly in the conversation window; there is no need to manually select a tool. The Agent will automatically determine whether an internet search is needed based on the question content.
+
+### Example
+
+\> *Question: What caused the change in order volume between March 28-30, 2025?*
+
+The Agent will automatically perform the following steps:
+
+1\. Query the internal database to retrieve the number of comments and rating data for the corresponding time period
+
+2\. Invoke web search to obtain external information such as weather, sports events, and news during the same period
+
+3\. Conduct multi-dimensional attribution analysis and output conclusions along with visualization charts
+
+\:-:
+![](/.topwrite/assets/image_1776137592328.png =427)
+
+**Notes**
+
+1\. Web search results are influenced by the content returned by the search engine; it is recommended to manually verify key conclusions
+
+2\. **The Web Search feature is currently in beta. To enable internet search capability, please contact the Singdata team**

package/bin/skills/lakehouse-doc-en/references/what-is-clickzetta-lakehouse.md

@@ -0,0 +1,55 @@
+# Singdata Lakehouse Introduction
+
+Singdata Lakehouse is a fully managed data management and analysis service based on the open lakehouse architecture. Singdata Lakehouse meets the needs of data warehouse construction, data lake exploration and analysis, batch/real-time data processing and analysis, business reports, etc., all these workloads with a single engine. It meets the needs of scalability, cost, and performance at different stages of the enterprise through compute-storage separation architecture, Serverless elastic computing power, and intelligent optimization features. Built-in data integration, development and operation, data asset management and other services are available upon activation, greatly simplifying data development and management work, and accelerating enterprise data insight and value realization.
+![](.topwrite/assets/image_1710684652463.png)
+
+## Core  Features
+
+We are committed to meeting the management requirements of enterprise-level users, while continuously improving the platform's ease of use, flexibility, and openness to achieve the best user experience.
+
+![](.topwrite/assets/image_1710684668475.png)
+
+## Key  Features
+
+### Next-Generation SQL Data Processing Engine
+
+A single engine meets the needs of batch, stream, and analysis scenarios, without the need for multiple component combinations. With a single engine, it simultaneously meets the needs of batch processing, real-time computing, and online analysis scenarios, effectively reducing the threshold for data application development and accelerating value delivery. High performance across all scenarios, cloud-native, compute-storage separation architecture, vectorized execution engine. Under the same resource scale, it leads the mainstream products in the industry on the TPCDS10TB/TPCH100GB/SSB 100GB test set.
+
+![](.topwrite/assets/image_1710684703287.png)
+
+### Serverless Elastic Architecture
+
+The compute-storage separation virtual computing cluster design optimizes calculations for ETL and analysis scenarios using different execution engines. It supports the creation of virtual clusters needed for different business needs on demand, isolating the impact between businesses while meeting different needs for high throughput and high performance. It senses business load, automatically manages the start and stop of the cluster and second-level elastic concurrency, while meeting the needs of low cost and high SLA.
+
+![](.topwrite/assets/image_1710684714663.png)
+
+### Open, No Lock-in
+
+The storage layer is compatible with mainstream open storage formats, and the metadata service provides open metadata services in the form of Catalog. After external engines authenticate and authorize the user's identity, they can access the data files of Singdata Lakehouse. On the basis of a unified security policy, it provides the best openness, releases greater data value with the help of a rich open-source ecosystem.
+
+![](.topwrite/assets/image_1710684730323.png)
+
+### Unified Data Assets
+
+Supports structured data in the form of Tables, and unstructured data in the form of files and directories for unified storage, and provides fine-grained access control based on ACL. It realizes the assetization and secure access control of various structured data. Different sources and types of data are unified into a centralized storage repository to achieve excellent performance, simplicity, and consistency. Supports unstructured data exploration and analysis.
+![](.topwrite/assets/image_1691805420547.png)
+
+### Integrated Solution for Data Development and Management
+
+The engine capabilities and platform tools are seamlessly integrated to meet the needs of data integration, development and operation, data catalog, security governance, data analysis and system management under a unified Web user experience. With the help of storage-computing separation, on-demand elastic virtual clusters, and automated operation and maintenance and optimization features, it shields the need for infrastructure operation and maintenance management, providing an integrated data platform solution with a SaaS-like development management experience.
+
+![](.topwrite/assets/image_1710684752427.png)
+
+## Typical Use Cases
+
+### Upgrading Traditional Solutions with an Integrated Data Platform
+
+![](.topwrite/assets/image_1710684770709.png)
+
+### IoT Data Analysis Scenarios
+
+![](.topwrite/assets/image_1710684779746.png)
+
+### Customer-Oriented Data Applications
+
+![](.topwrite/assets/image_1710684790045.png)

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

@@ -0,0 +1,90 @@
+# What is Singdata Lakehouse?
+
+Singdata Lakehouse is a state-of-the-art service that revolutionizes enterprise data management with a comprehensive, managed lakehouse architecture. Our platform is not merely an extension of traditional database technologies or "big data" software platforms; it is built from the ground up with an innovative, cloud-native design that incorporates a brand new SQL query engine. This architecture endows Singdata Lakehouse with all the capabilities of an enterprise datalake/warehouse   and a multitude of special features and unique functionalities.
+
+By seamlessly integrating key components such as data warehousing, data lake exploration, real-time and batch data processing, as well as business intelligence reporting, Singdata Lakehouse is tailored to meet the dynamic scalability, cost, and performance needs of businesses at every stage of their growth. Our focus on storage-compute decoupling and Serverless elastic computing, paired with intelligent optimization tools, streamlines data development and management. This empowers our cutomers to achieve faster, more efficient insights and to unlock the full potential of their data with unparalleled flexibility and ease of use.
+
+:-: ![](.topwrite/assets/p1.png =714)
+
+## Core Product Features
+
+We are dedicated to delivering a superior management experience for our enterprise users. We are constantly refining the platform to enhance its usability, flexibility, and openness, guaranteeing that our users receive the finest service possible.
+
+:-: ![](.topwrite/assets/p2.png =725)
+
+## Main Product Features
+
+### A True Self-managed Data Platform Service
+
+Singdata Lakehouse stands out as a genuine self-managed service, which means:
+
+* There’s no need to select, install, configure, or manage any hardware, whether virtual or physical.
+* Practically, there’s no software installation, configuration, or management required on your part.
+* All ongoing maintenance, management, upgrades, and tuning are expertly handled by the Singdata Lakehouse team.
+* Singdata Lakehouse operates entirely within cloud infrastructure. Every component of our service (with the exception of optional command line clients, drivers, and connectors) is hosted in public cloud environments.
+* For compute needs, Singdata Lakehouse leverages virtual compute instances, and for persistent data storage, it utilizes a dedicated storage service.
+* Unlike packaged software offerings, Singdata Lakehouse is not something you install. We take care of all aspects of software installation and updates, ensuring a seamless and hassle-free experience for our users.
+
+### Next-Generation SQL Data Processing Engine
+
+Singdata Lakehouse is equipped with a robust SQL data processing engine designed to handle batch processing, real-time computing, and online analysis all at once. Users can streamline their data processing and analysis tasks with a single, powerful engine, eliminating the need for complex component integration. This approach dramatically simplifies the development of data applications and speeds up the realization of value.
+
+Built on a cloud-native architecture, this engine leverages a storage-compute separation model and a vectorized execution engine to deliver top-tier performance. It outperforms leading competitors in benchmark tests, including the TPCDS 10TB, TPCH 100GB, and SSB 100GB test suites, even when using the same scale of resources.
+
+:-: ![](.topwrite/assets/p3.png =508)
+
+### Serverless Elastic Architecture
+
+Singdata Lakehouse utilizes a virtual computing cluster architecture with a decoupled storage and compute layer, offering a specialized execution engine tailored for ETL and analytical tasks to optimize computing performance. Users can dynamically provision virtual clusters based on specific business needs, ensuring business-specific isolation and accommodating varying demands for high throughput and performance.
+
+The platform proactively monitors business workloads, automating the management of cluster lifecycles and elastic concurrency. This intelligent approach not only maintains a high service level agreement (SLA) but also achieves cost efficiency.
+
+:-: ![](.topwrite/assets/ps.png =681)
+
+### Open and No Data Lock-In
+
+Singdata Lakehouse's storage layer is designed to be compatible with popular open storage formats. It offers a metadata service through a Catalog, enabling external engines to access data files following a secure authentication and authorization process. Within a cohesive security policy framework, the platform ensures optimal openness. Leveraging a robust open-source ecosystem, it empowers enterprises to unlock greater value from their data.
+
+:-: ![](.topwrite/assets/p2_1740475216000.png =664)
+
+### Unified Data Assets
+
+Singdata Lakehouse accommodates both structured data, stored as tables, and unstructured data, including files and directories. The platform offers nuanced permission management through access control lists (ACLs), guaranteeing centralized governance and secure data asset access. Moreover, it facilitates the exploration and analysis of unstructured data, thereby enhancing the overall efficiency of data utilization.
+
+:-: ![](.topwrite/assets/image_1691805420547.png =640)
+
+### Integrated Solution for Data Development and Management
+
+Singdata Lakehouse harmoniously blends the power of its data processing engine with its platform tools, delivering a cohesive web-based user experience. The platform encompasses a wide range of functionalities, including data integration, development and operations, data cataloging, security governance, data analytics, and system management. By employing storage-compute separation, demand-driven elastic virtual clusters, and automated operations and optimizations, it streamlines infrastructure management and maintenance. Singdata Lakehouse offers users a comprehensive, SaaS-based data platform solution.
+
+:-: ![](.topwrite/assets/p7.png =610)
+
+## Typical Use Cases
+
+### Upgrading Traditional Solutions with an Integrated Data Platform
+
+By transitioning to Singdata Lakehouse, enterprises can elevate their traditional data management and analytics solutions, thereby achieving streamlined data management and sophisticated analysis capabilities.
+
+:-: ![](.topwrite/assets/p8.png =801)
+
+### IoT Data Analysis Scenarios
+
+Singdata Lakehouse is suitable for IoT data analysis scenarios, helping enterprises extract valuable information from large amounts of device and sensor data to optimize business decisions.
+
+:-: ![](.topwrite/assets/p9.png)
+
+### Customer-Oriented Data Applications
+
+Singdata Lakehouse enables businesses to develop customer-centric data analytics applications, offering personalized services and tailored product recommendations by delving into comprehensive analyses of customer behavior and preferences.
+
+:-: ![](.topwrite/assets/p10.png)
+
+We are firmly convinced that the robust capabilities and adaptable features of Singdata Lakehouse represent a significant leap forward in the world of data management and analysis. This innovative platform is designed to empower enterprises with the tools they need to not only handle their data with greater efficiency but also to unlock the full potential of their information assets. With Singdata Lakehouse, businesses can expect to streamline their data processes, which in turn paves the way for scalable business growth and continuous innovation.
+
+The powerful functions of Singdata Lakehouse, such as its Incremental computation and one-stop data development and management capabilities, are tailored to meet the complex demands of modern data workflows. Its flexible features allow for seamless integration with existing systems, ensuring that enterprises can leverage their data without disrupting current operations. This level of adaptability is crucial in today's fast-paced business environment, where the ability to pivot and respond to market changes quickly can make all the difference.
+
+By utilizing Singdata Lakehouse, enterprises will be able to better manage their data, ensuring that it is not just stored, but also organized and accessible in a way that supports informed decision-making. The platform's intuitive interface and robust data governance framework make it an invaluable asset for data scientists, analysts, and business leaders alike. They can now delve deeper into their data, uncovering patterns and insights that would otherwise remain hidden, and use these findings to drive strategic initiatives.
+
+Moreover, the ability to analyze large volumes of data, including IoT data, in real-time is a game-changer for enterprises looking to optimize their operations and customer experiences. Singdata Lakehouse enables companies to extract valuable information from vast amounts of device and sensor data, which is essential for industries such as manufacturing, healthcare, and transportation. This capability supports data-driven decision-making at a granular level, allowing businesses to fine-tune processes, reduce costs, and identify new opportunities for growth.
+
+In summary, Singdata Lakehouse is not just a tool for data management and analysis; it is a catalyst for business transformation. Its robust capabilities and adaptable features are designed to help enterprises navigate the complexities of big data, ensuring that they can manage, analyze, and act on their data with unparalleled precision and speed. This empowers businesses to achieve sustainable growth, drive innovation, and maintain a competitive edge in an ever-evolving marketplace.

package/bin/skills/lakehouse-doc-en/references/window-frame.md

@@ -0,0 +1,135 @@
+# Window Frame
+
+Window Frame is a subset defined when using window functions to limit the computation scope of the window function, performing calculations only on the data within the window frame. Through window frames, you can precisely control how window functions compute and their results. Below is a detailed description and usage examples of window frames.
+
+## Window Frame Syntax
+
+When using window functions, define the window frame through the `OVER` clause with the following syntax:
+
+```SQL
+<window_function> OVER (
+    [PARTITION BY <partition_expression>]
+    [ORDER BY <order_expression>]
+    [frame_clause>]
+)
+```
+
+Where `<window_function>` represents the window function to use, such as `ROW_NUMBER()`, `RANK()`, `SUM()`, etc. The `PARTITION BY` clause is used to group data, with each group called a partition. The `ORDER BY` clause is used to sort data within each partition, which will affect the results of certain window functions such as `ROW_NUMBER()`, `RANK()`, etc. `frame_clause` is used to define the scope of the window frame and comes in two forms: `ROWS frame` and `RANGE frame`.
+
+### ROWS frame
+
+`ROWS frame` is a row-based window frame used to specify the number or position of rows included in the window frame. Its syntax is as follows:
+
+```SQL
+ROWS BETWEEN <start_boundary> AND <end_boundary>
+```
+
+`<start_boundary>` and `<end_boundary>` define the start and end boundaries of the window frame and can be one of the following values:
+
+- `UNBOUNDED PRECEDING`: Starts from the first row of the partition.
+- `UNBOUNDED FOLLOWING`: Ends at the last row of the partition.
+- `CURRENT ROW`: The current row.
+- `<offset> PRECEDING`: The row `<offset>` rows before the current row, where `<offset>` is a non-negative integer.
+- `<offset> FOLLOWING`: The row `<offset>` rows after the current row, where `<offset>` is a non-negative integer.
+
+### RANGE frame
+
+`RANGE frame` is a value-based window frame used to specify the range of values of rows included in the window frame. Its syntax is as follows:
+
+```SQL
+RANGE BETWEEN <start_boundary> AND <end_boundary>
+```
+
+`<start_boundary>` and `<end_boundary>` define the start and end boundaries of the window frame and can be one of the following values:
+
+- `UNBOUNDED PRECEDING`: Starts from the minimum value in the partition.
+- `UNBOUNDED FOLLOWING`: Ends at the maximum value in the partition.
+- `CURRENT ROW`: The value of the current row.
+- `<value> PRECEDING`: The value of the current row minus `<value>`, where `<value>` is a non-negative number.
+- `<value> FOLLOWING`: The value of the current row plus `<value>`, where `<value>` is a non-negative number.
+
+## Window Frame Usage Examples
+
+Below are some SQL query examples using Window Frames, along with their output results. Assume we have a table called sales containing monthly sales and profit margin data as follows:
+
+| month | sales | profit |
+| ----- | ----- | ------ |
+| 1     | 100   | 0.1    |
+| 2     | 120   | 0.15   |
+| 3     | 80    | 0.05   |
+| 4     | 150   | 0.2    |
+| 5     | 90    | 0.1    |
+| 6     | 110   | 0.12   |
+
+### ROWS frame
+
+* Query: Use the `SUM()` function and `ROWS frame` to calculate the sum of sales for the current month and the two months before and after.
+
+```SQL
+SELECT month, sales, SUM(sales) OVER (ORDER BY month ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS sum_sales
+FROM sales;
+
++-------+-------+-----------+
+| month | sales | sum_sales |
++-------+-------+-----------+
+| 1     | 100   | 300       |
+| 2     | 120   | 450       |
+| 3     | 80    | 540       |
+| 4     | 150   | 550       |
+| 5     | 90    | 430       |
+| 6     | 110   | 350       |
++-------+-------+-----------+
+```
+
+* Query: Use the `AVG()` function and `ROWS frame` to calculate the average profit margin for the current month and the months before and after.
+
+```SQL
+SELECT month, profit, AVG(profit) OVER (ORDER BY month ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS avg_profit
+FROM sales;
++-------+--------+---------------------+
+| month | profit |     avg_profit      |
++-------+--------+---------------------+
+| 1     | 0.1    | 0.125               |
+| 2     | 0.15   | 0.09999999999999999 |
+| 3     | 0.05   | 0.13333333333333333 |
+| 4     | 0.2    | 0.11666666666666665 |
+| 5     | 0.1    | 0.14                |
+| 6     | 0.12   | 0.11                |
++-------+--------+---------------------+
+```
+
+### RANGE frame
+
+* Query: Use the `COUNT()` function and `RANGE frame` to calculate the distribution of each month's sales across the year, i.e., how many months have sales within 10 of the current month's sales.
+
+```SQL
+SELECT month, sales, COUNT(*) OVER (ORDER BY sales RANGE BETWEEN 10 PRECEDING AND 10 FOLLOWING) AS count_sales
+FROM sales;
++-------+-------+-------------+
+| month | sales | count_sales |
++-------+-------+-------------+
+| 3     | 80    | 2           |
+| 5     | 90    | 3           |
+| 1     | 100   | 3           |
+| 6     | 110   | 3           |
+| 2     | 120   | 2           |
+| 4     | 150   | 1           |
++-------+-------+-------------+
+```
+
+* Query: Use the `MAX()` function and `RANGE frame` to calculate the maximum profit margin among the current month and the adjacent months.
+
+```SQL
+SELECT month, profit, MAX(profit) OVER (ORDER BY month RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS max_profit
+FROM sales;
++-------+--------+------------+
+| month | profit | max_profit |
++-------+--------+------------+
+| 1     | 0.1    | 0.15       |
+| 2     | 0.15   | 0.15       |
+| 3     | 0.05   | 0.2        |
+| 4     | 0.2    | 0.2        |
+| 5     | 0.1    | 0.2        |
+| 6     | 0.12   | 0.12       |
++-------+--------+------------+
+```

package/bin/skills/lakehouse-doc-en/references/window-function-summary.md

@@ -0,0 +1,134 @@
+## Window Functions
+
+Window Functions are powerful SQL functions that allow users to perform grouped calculations on a dataset within a query. Unlike traditional aggregate functions, window functions can calculate each row of data while retaining the detailed information of the original data. Window functions have a wide range of applications in data analysis, report generation, and other scenarios, such as calculating rankings, cumulative sums, moving averages, etc.
+
+## Basic Syntax of Window Functions
+
+The basic syntax of window functions is as follows:
+
+```SQL
+<window_function> OVER (
+    [PARTITION BY <partition_expression>]
+    [ORDER BY <order_expression>]
+)
+```
+
+* `<window_function>`: Specify the window function to use, such as `ROW_NUMBER()`, `RANK()`, `SUM()`, etc.
+* `PARTITION BY`: Divide the dataset into different partitions, each partition being an independent calculation scope.
+* `ORDER BY`: Sort the data within each partition, affecting the calculation results of some window functions.
+
+## Classification of Window Functions
+
+Based on functionality and return value type, window functions can be divided into the following categories:
+
+1. **Ranking Functions**: Rank the data and return an integer value representing the relative position. Common ranking functions include `ROW_NUMBER()`, `RANK()`, `DENSE_RANK()`, `PERCENT_RANK()`, `CUME_DIST()`, `NTILE()`, etc.
+2. **Aggregate Functions**: Perform aggregate calculations on the data and return a value representing the overall characteristics. Lakehouse supports all standard aggregate functions.
+3. **Analytic Functions**: Perform analytical calculations on the data and return a value representing the data characteristics. Common analytic functions include `FIRST_VALUE()`, `LAST_VALUE()`, `LAG()`, `LEAD()`, `NTH_VALUE()`, `CUME_DIST()`, etc.
+
+## Examples of Using Window Functions
+
+Below are some examples of SQL queries using window functions and their output results. Suppose we have a table named sales that contains data on monthly sales and profit margins, as shown below:
+
+```SQL
+CREATE    TABLE sales (MONTH int, sales int, profit double);
+INSERT    INTO sales (MONTH, sales, profit)
+VALUES    (1, 100, 0.1),
+          (2, 120, 0.15),
+          (3, 80, 0.05),
+          (4, 150, 0.2),
+          (5, 90, 0.1),
+          (6, 110, 0.12);
+```
+
+### Ranking Functions
+
+* Query: Use the `ROW_NUMBER()` function to rank sales in descending order.
+
+```SQL
+SELECT month, sales, ROW_NUMBER() OVER (ORDER BY sales DESC) AS rank
+FROM sales;
++-------+-------+------+
+| month | sales | rank |
++-------+-------+------+
+| 4     | 150   | 1    |
+| 2     | 120   | 2    |
+| 6     | 110   | 3    |
+| 1     | 100   | 4    |
+| 5     | 90    | 5    |
+| 3     | 80    | 6    |
++-------+-------+------+
+```
+
+* Query: Use the `RANK()` function to rank the profit margin in ascending order and group by quarter.
+
+```SQL
+SELECT month, profit, RANK() OVER (PARTITION BY CEIL(month / 3) ORDER BY profit ASC) AS rank
+FROM sales;
++-------+--------+------+
+| month | profit | rank |
++-------+--------+------+
+| 3     | 0.05   | 1    |
+| 1     | 0.1    | 2    |
+| 2     | 0.15   | 3    |
+| 5     | 0.1    | 1    |
+| 6     | 0.12   | 2    |
+| 4     | 0.2    | 3    |
++-------+--------+------+
+```
+
+### Aggregate Functions
+
+* Query: Use the `AVG()` function to calculate the difference between the monthly sales and the annual average sales.
+
+```SQL
+SELECT month, sales, sales - AVG(sales) OVER () AS diff
+FROM sales;
++-------+-------+--------------------+
+| month | sales |        diff        |
++-------+-------+--------------------+
+| 1     | 100   | -8.333333333333329 |
+| 2     | 120   | 11.666666666666671 |
+| 3     | 80    | -28.33333333333333 |
+| 4     | 150   | 41.66666666666667  |
+| 5     | 90    | -18.33333333333333 |
+| 6     | 110   | 1.6666666666666714 |
++-------+-------+--------------------+
+```
+
+### Analytic Functions
+
+* Query: Use the `LAG()` function and `LEAD()` function to calculate the difference in sales between each month and the previous month and the next month.
+
+```SQL
+SELECT month, sales, sales - LAG(sales) OVER (ORDER BY month) AS prev_diff, sales - LEAD(sales) OVER (ORDER BY month) AS next_diff
+FROM sales;
++-------+-------+-----------+-----------+
+| month | sales | prev_diff | next_diff |
++-------+-------+-----------+-----------+
+| 1     | 100   | null      | -20       |
+| 2     | 120   | 20        | 40        |
+| 3     | 80    | -40       | -70       |
+| 4     | 150   | 70        | 60        |
+| 5     | 90    | -60       | -20       |
+| 6     | 110   | 20        | null      |
++-------+-------+-----------+-----------+
+```
+
+* Query: Use the `CUME_DIST()` function to calculate the cumulative distribution of monthly sales in the annual sales.
+
+```SQL
+SELECT month, sales, CUME_DIST() OVER (ORDER BY sales) AS cume_dist
+FROM sales;
++-------+-------+---------------------+
+| month | sales |      cume_dist      |
++-------+-------+---------------------+
+| 3     | 80    | 0.16666666666666666 |
+| 5     | 90    | 0.3333333333333333  |
+| 1     | 100   | 0.5                 |
+| 6     | 110   | 0.6666666666666666  |
+| 2     | 120   | 0.8333333333333334  |
+| 4     | 150   | 1.0                 |
++-------+-------+---------------------+
+```
+
+^