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

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

@@ -0,0 +1,247 @@
+# Data Sharing
+
+## 1. Overview
+
+### What is Data Share
+
+Data Share is a **zero-copy** data sharing feature provided by Singdata Lakehouse, enabling **cross-account or cross-service-instance** data authorization and usage within the same service region. Unlike traditional data replication or import solutions, Data Share does not require manually setting up data sync links between enterprises. Instead, it directly provides read-only access to source data through "authorization", with real-time updates.
+
+### Application Scenarios
+
+* **Real-time Sharing Scenario**: Enterprise A shares its own data (e.g., transaction logs, user behavior data) with Enterprise B in real time. Enterprise B can query updated data in real time without performing data sync.
+* **Multi-party Collaborative Analysis**: Multiple partners analyze and mine data based on the same real-time dataset, reducing duplicate storage and transmission costs.
+* **Data Provider and Data Consumer Model**: The data provider wants to open part of their data to partners. Partners can obtain read-only data without bearing storage costs for their own BI analysis or product integration.
+
+### Use Case in This Document
+
+This document takes **Enterprise A** (data provider) and **Enterprise B** (data consumer) as examples to introduce the following operations:
+
+1. **Enterprise A creates a Data Share and shares data**: Enterprise A has e-commerce data for Brazil_Commercial in its own data warehouse and wants to include desensitized data in the Data Share, specifying Enterprise B as the recipient.
+2. **Enterprise B receives and extracts data from the Data Share**: Enterprise B, in its own Singdata Lakehouse instance, receives the share from Enterprise A and creates the corresponding schema to extract the shared data.
+3. **Enterprise B uses the extracted data with BI applications to create reports**: Enterprise B analyzes the read-only data extracted from the Data Share and creates reports in BI tools.
+4. **Enterprise A writes data, and Enterprise B's reports reflect data changes in real time**: Since Data Share is zero-copy and real-time, updates made by Enterprise A to the data are immediately visible to Enterprise B.
+
+***
+
+## 2. Enterprise A Creates a Data Share and Specifies Enterprise B as the Recipient
+
+In the following example, Enterprise A has a logistics table `rpt_brazil_ec`, which contains the logistics status of all products from all sellers. Enterprise B is one of the sellers under Enterprise A. Enterprise A needs to provide Enterprise B with the logistics status of its sold products so that Enterprise B can use this data for BI dashboards to analyze and track logistics status. To do this, Enterprise A will filter `rpt_brazil_ec`, create a view `sub_rpt_brazil_ec_05e107217c7266362fd44b75b2cd4cc4` containing only Enterprise B's data, and share this view with Enterprise B.
+
+### 2.1 Creating a View
+
+Since the logistics table `rpt_brazil_ec` contains data for all sellers, for data security reasons, not all data can be provided to Enterprise B. Therefore, a view needs to be created first that only contains Enterprise B's data, and only this view will be shared.
+
+The table `rpt_brazil_ec` contains a seller ID field: `seller_id`. Use this field as a filter condition to create the following view:
+
+```
+-- Create an independent schema for the share, facilitating subsequent management and maintenance
+CREATE SCHEMA seller_data_share;
+
+-- Create a view. Assume Enterprise B's seller_id is 05e107217c7266362fd44b75b2cd4cc4
+CREATE    VIEW seller_data_share.sub_rpt_brazil_ec_05e107217c7266362fd44b75b2cd4cc4 AS
+SELECT    *
+FROM      rpt_brazil_ec
+WHERE     seller_id = '05e107217c7266362fd44b75b2cd4cc4';
+```
+
+### 2.2 Creating a Data Share and Sharing with Specified Enterprise B
+
+#### Web Interface Operations
+
+**1) Create a Data Share**
+
+* Log into the Singdata Lakehouse console using an account with the "Instance Administrator" (`instance_admin`) role.
+* In the left navigation, select "Data" → "Data Sharing", and click "+ New Share".
+
+:-: ![](.topwrite/assets/image_1740388043727.png =742)
+
+* In the dialog, fill in the share name (e.g., shipping_detail), and select the workspace where the data to be shared is located.
+* Note: The data to be shared must be in the same workspace. If the data itself is distributed across multiple workspaces, you can create views of the data to be shared from other workspaces within one workspace to centralize all data to be shared into the same workspace.
+
+:-: ![](.topwrite/assets/image_1740388342928.png =438)
+
+**2) Add Data Objects to Share**
+
+Continuing in the Create Share dialog, click "Add" and select the objects to share. As shown below, in the ql_ws workspace, find the schema created above: seller_data_share, and select the view within it: seller_data_share.sub_rpt_brazil_ec_05e107217c7266362fd44b75b2cd4cc4
+
+After clicking "Done", the view will be included in the share list.
+
+:-: ![](.topwrite/assets/image_1740388392799.png =537)
+
+^
+
+**3) Configure Recipient Instances**
+
+In the same dialog, click the "Add" button below "Recipient Instances", enter Enterprise B's Singdata Lakehouse "Service Instance Name" (which Enterprise B needs to provide; it can be found in the upper right area of the homepage after logging into their service instance), and click Done.
+
+:-: ![](.topwrite/assets/image_1740388438814.png =531)
+
+^
+
+**4) Complete Data Share Creation**
+
+After completing all the above fields, click the "OK" button to finish creating the Data Share object and specify sharing it with Enterprise B's Lakehouse service instance.
+
+Subsequently, you can edit this Data Share to add or remove data objects to share, or add or remove Lakehouse service instances receiving this data (e.g., if you need to share with other service instances of Enterprise B).
+
+**5) View or Manage Share Objects**
+
+After creation, you can see the newly created Data Share object in the "Data Sharing" → "Shared by Me" list.
+
+:-: ![](.topwrite/assets/image_1740390203623.png =718)
+
+^
+
+#### SQL Operations
+
+If you prefer SQL operations, use an account with the "Instance Administrator" (`instance_admin`) role to execute the following operations in Enterprise A's workspace (e.g., `ql_ws`):
+
+**1) Create Share**
+
+```
+CREATE SHARE shipping_detail;
+```
+
+**2) Add View to Share**
+
+```
+-- Note: SELECT grants the recipient the ability to query data, READ METADATA grants the recipient the ability to see this view object. Both permissions need to be granted.
+GRANT SELECT, READ METADATA ON VIEW seller_data_share.sub_rpt_brazil_ec_05e107217c7266362fd44b75b2cd4cc4 TO SHARE shipping_detail;
+```
+
+**3) Configure Target Instance for Share**
+
+```
+ALTER SHARE shipping_detail ADD INSTANCE '<Replace with Enterprise B instance_name>';
+```
+
+Enterprise B needs to provide the name of their Lakehouse service instance. After this operation, Enterprise B will immediately obtain the right to use share shipping_detail and can extract read-only access to the view: seller_data_share.sub_rpt_brazil_ec_05e107217c7266362fd44b75b2cd4cc4 from it.
+
+> After completing the above steps, Enterprise A has successfully shared filtered data with Enterprise B via the Data Share feature.
+
+##
+
+### 2.3 Enterprise B Receives and Extracts Data from the Data Share
+
+After Enterprise A completes the sharing, Enterprise B needs to "receive and extract" the shared data in their own Singdata Lakehouse instance to use the view object in queries.
+
+#### Web Interface Operations
+
+**View Objects Shared with Me**
+
+Log into Enterprise B's Singdata Lakehouse console using an account with the "Instance Administrator" or "Workspace Administrator" role.
+
+In the left navigation, select "Data Management" → "Data Sharing", switch to the "Shared with Me" tab, and you will see the shipping_detail shared by Enterprise A.
+
+^
+
+**Extract Data**
+
+Click the "Extract" button below the shipping_detail card.
+
+In the dialog, select the "Source Schema" (a Data Share may contain multiple schemas; you need to specify the schema for data extraction), as well as the workspace and corresponding schema in Enterprise B's service instance where you want the shared data to land.
+
+Note: A new schema will be created based on the filled-in schema name. This schema is read-only, and you cannot create other data objects such as tables or views within this schema.
+
+After completing the fields, click the "OK" button. The system will create a read-only schema in Enterprise B's specified workspace and map it to the objects shared by Enterprise A.
+
+^
+
+**After Extraction is Complete**
+
+Enterprise B can see the corresponding new schema and the view: sub_rpt_brazil_ec_05e107217c7266362fd44b75b2cd4cc4 in "Data Catalog" or on the "Data" tab of the "Development" feature.
+
+You can query the data in the view just like using local data objects.
+
+^
+
+### 2.4 SQL Operations
+
+If using SQL to extract data from a share, execute the following commands in Enterprise B's workspace:
+
+**View Share Objects**
+
+```SQL
+SHOW SHARES;
+```
+
+You can see the `INBOUND` type Data Share named shipping_detail from Enterprise A's service instance.
+
+**View Data in shipping_detail**
+
+```
+DESC SHARE shipping_detail;
+```
+
+^
+
+**Create Local Schema**
+
+```
+CREATE SCHEMA b_workspace_share_schema FROM SHARE A_instance_name.shipping_detail.share_demo;
+```
+
+Where `A_instance_name`, `share_demo`, and the source schema name can be found through `SHOW SHARES;` and `DESC SHARE share_demo;`.
+
+`b_workspace_share_schema` is the name of the read-only schema created in Enterprise B's workspace, which can be customized.
+
+^
+
+***
+
+## 4. Enterprise B Uses the Extracted Data with BI Applications to Create Reports
+
+After Enterprise B extracts and successfully creates a read-only schema, they can query or perform join analysis on `orders_view` in any BI tool or SQL workbench compatible with Singdata Lakehouse. For example:
+
+```
+SELECT 
+    order_id,
+    customer_id,
+    order_amount,
+    order_status
+FROM b_workspace_share_schema.orders_view
+WHERE order_status = 'COMPLETED';
+```
+
+* **Joining External Data**: You can join `orders_view` with Enterprise B's internal data tables (`JOIN`) for analysis.
+* **Data Modeling**: You can use `orders_view` as a data source in BI tools for data visualization and report creation.
+
+At this point, Enterprise B no longer needs to worry about whether the data is synced in real time — Data Share ensures that when Enterprise A's source data is updated, Enterprise B queries the latest data.
+
+***
+
+## 5. Enterprise A Writes Data to the Data Share, and Enterprise B's Reports Reflect Changes in Real Time
+
+When Enterprise A inserts new data into the underlying table `orders` corresponding to `orders_view`, or updates existing order data, the Data Share automatically exposes the changed data to Enterprise B in real time. Enterprise B does not need any additional operations and can see the latest results in SQL queries or BI reports.
+
+Example: Enterprise A executes the following statement to update the order status, and Enterprise B can immediately see the updated status records in their existing reports.
+
+```
+-- Enterprise A executes in workspace_a
+UPDATE orders
+SET order_status = 'SHIPPED'
+WHERE order_id = 10001;
+```
+
+Enterprise B obtains the latest status in real time through the previous BI report or the following SQL query:
+
+```
+-- Enterprise B executes
+SELECT 
+    order_id,
+    order_status
+FROM b_workspace_share_schema.orders_view
+WHERE order_id = 10001;
+```
+
+***
+
+## Summary
+
+Through the above 5 steps, you can achieve real-time data sharing similar to Snowflake Data Sharing on the Singdata Lakehouse platform. The biggest features of Data Share are:
+
+* **Zero-copy, Low Latency**: No need for duplicate storage or periodic sync between enterprises. Data changes can be propagated to consumers in real time.
+* **Secure and Controllable Data**: Data is only shared in a "read-only" form, and share objects can be removed at any time through permission control.
+* **Easy to Scale**: Data columns or rows can be flexibly filtered through Views to achieve fine-grained sharing control.
+
+^

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

@@ -0,0 +1,269 @@
+# Quickly Set Up a Lakehouse Data Development Environment for Your Team
+
+## Overview
+
+This document aims to help you quickly set up a Lakehouse data development environment for team use. The environment includes multiple user identities that can log in and perform data development, with different data permissions and roles assigned to each user to ensure necessary permission control, resource allocation, and collaboration convenience.
+
+## 1. Preparations
+
+1. **Create a Singdata Account**
+
+   If you do not have a Singdata account, you can register at the [Singdata official website](https://www.singdata.com/). For registration instructions, refer to [logging in](logging-in.md).
+
+2. **Create a Lakehouse Service Instance**
+
+   You need to have at least one Lakehouse service instance created. If you have not yet created a service instance, refer to the "Create a Lakehouse Service Instance" section in [logging in](logging-in.md) for instructions.
+
+3. **Have the instance\_admin (Instance Administrator) Role for the Lakehouse Service Instance**
+
+   Lakehouse's permission management is role-based. The user who creates the Lakehouse service instance will automatically have the instance\_admin (Instance Administrator) role for that service instance.
+
+## 2. After Setup
+
+After completing the setup as described in the following sections, you will have the following environment:
+
+1. An independent workspace under a Lakehouse service instance;
+2. Multiple user identities with permissions to perform data development in the workspace;
+3. A SQL task that is submitted for periodic execution.
+
+***
+
+## 3. Steps
+
+### 3.1 Create Users
+
+When you register a Singdata account, the first user under that account is created by default and has all operational permissions under the account. When multiple people in a team use Lakehouse for development, using multiple user identities and distinguishing permissions can effectively manage data and resources, enhance security, reduce the risk of operational conflicts, and enable effective auditing and tracing of individual operations.
+
+To achieve the above management goals, you need to create independent users for each developer or each integrated service to prepare for subsequent role assignments.
+
+Log in to the Singdata product using the default user created during account registration, go to the management center page, and switch to the "User Management" function:
+
+:-: ![](.topwrite/assets/quickstart_team_p1.png =801)
+
+^
+
+Click the "New" button in the upper right corner and select "New User." Here, create two users: developer and analyst, as shown below:
+
+:-: ![](.topwrite/assets/quickstart_team_p2.png =361)
+
+^
+
+:-: ![](.topwrite/assets/quickstart_team_p3.png =360)
+
+After successful creation, you can see these two users in the user list under user management.
+
+### 3.2 Create a Workspace
+
+In Lakehouse, a workspace is used to isolate computing resources and data, forming a relatively independent data development environment to avoid resource conflicts or data misoperations. After opening a Lakehouse service instance, the system will create a workspace named quickstart by default. Here, to fully introduce the team usage method, we will create another workspace: dev\_envirment:
+
+Log in using the user created during tenant registration, and click the name of the opened service instance in the management center to enter the service instance homepage.
+
+:-: ![](.topwrite/assets/quickstart_team_p4.png =797)
+
+^
+
+On the service instance homepage, click "Management" - "Workspace" in the left menu to enter the workspace management page. Click the "+ New Space" button in the upper right corner:
+
+:-: ![](.topwrite/assets/quickstart_team_p5.png =774)
+
+^
+
+Enter the workspace name in the pop-up window and click "OK" to complete the workspace creation:
+
+:-: ![](.topwrite/assets/quickstart_team_p6.png =382)
+
+^
+
+:-: ![](.topwrite/assets/quickstart_team_p7.png =733)
+
+^
+
+### 3.4 Create Schema and Table
+
+In the Lakehouse workspace, schema is used to further categorize data tables and views. You can plan the schema hierarchy based on team size and business needs. First, create three schemas: STG, CORE, and ADS.
+
+First, click "Develop" on the right side of the newly created dev\_envirment workspace to enter the development page, and execute the following SQL to create the schema:
+
+:-: ![](.topwrite/assets/quickstart_team_p8.png =730)
+
+^
+
+:-: ![](.topwrite/assets/quickstart_team_p9.png =736)
+
+Create two tables in Schema STG and insert some sample data:
+
+```SQL
+CREATE SCHEMA STG;   -- Store original or temporary tables from data sources
+CREATE SCHEMA CORE;  -- Store core fact tables/dimension tables
+CREATE SCHEMA ADS;   -- Store summary or analysis result tables
+
+
+----------------------------------------------------------
+-- 1. Create sample table in STG layer: EMPLOYEES
+----------------------------------------------------------
+CREATE TABLE STG.EMPLOYEES (
+    EMP_ID          INT,
+    EMP_NAME        VARCHAR(50),
+    DEPARTMENT      VARCHAR(50),
+    JOIN_DATE       STRING
+);
+
+-- Insert some sample data into the table
+INSERT INTO STG.EMPLOYEES (EMP_ID, EMP_NAME, DEPARTMENT, JOIN_DATE) VALUES
+    (101, 'Alice',    'Engineering', '2023-07-10'),
+    (102, 'Bob',      'Sales',       '2024-08-05'),
+    (103, 'Charlie',  'Finance',     '2024-09-01');
+
+----------------------------------------------------------
+-- 2. Create sample view: EMPLOYEES_OVERVIEW
+----------------------------------------------------------
+CREATE VIEW ADS.EMPLOYEES_OVERVIEW AS
+SELECT 
+    EMP_ID,
+    EMP_NAME,
+    DEPARTMENT,
+    JOIN_DATE
+FROM EMPLOYEES;
+```
+
+### 3.5 Adding Team Members to the Workspace and Granting Permissions
+
+The two users created above: developer and analyst, by default, do not have any permissions for data operations and resource usage. They need to be authorized by a user with the workspace\_admin role before they can perform any operations.
+
+Assuming we want the permissions for these two users to be:
+
+**developer user**, can use the "development" feature; can read and write all data under the dev\_environment workspace, and can create and delete objects such as tables and views; can use all computing cluster resources under the dev\_environment workspace; can submit and maintain periodic tasks under the dev\_environment workspace.
+
+**analyst user**, can use the "development" feature; has read-only permissions for all tables and views under the schema ADS, and has read-only permissions for the table stg.employees; can use all computing cluster resources under the dev\_environment workspace.
+
+To achieve the above, continue using the user who created the dev\_environment workspace, open the "development" feature, create a new SQL script, and execute the following authorization statements:
+
+```SQL
+----------------------------------------------------------
+-- 1. Authorize the developer user
+----------------------------------------------------------
+-- Add the user developer to the workspace. Only after joining the workspace can permissions for metadata objects under the workspace be granted.
+CREATE USER developer;
+
+-- Grant the workspace_dev role to the user developer, to have the following permissions: "Can use the 'development' function; can read and write all data under the dev_environment workspace, and can create and delete objects such as tables and views; can use all computing cluster resources under the dev_environment workspace;"
+GRANT ROLE workspace_dev TO USER developer;
+
+-- Grant the workspace_sre role to the user developer, to have the permission "Can submit and maintain periodic tasks under the dev_environment workspace"
+GRANT ROLE workspace_sre TO USER developer;
+
+
+----------------------------------------------------------
+-- 2. Authorize the analyst user
+----------------------------------------------------------
+-- Add the user analyst to the workspace. Only after joining the workspace can permissions for metadata objects under the workspace be granted.
+CREATE USER analyst;
+
+-- Grant the workspace_analyst role to the user analyst, to have the following permissions: "Can use the 'development' function; can use all computing cluster resources under the dev_environment workspace;"
+GRANT ROLE workspace_analyst TO USER analyst;
+
+-- Grant the user analyst separate data permissions to achieve "read-only permissions on all tables and views under the schema ADS"
+GRANT SELECT, READ METADATA ON ALL TABLES IN SCHEMA ads TO USER analyst;
+GRANT SELECT, READ METADATA ON ALL VIEWS IN SCHEMA ads TO USER analyst;
+
+-- Grant the user analyst separate data permissions to achieve "read-only permissions on the table stg.employees"
+GRANT SELECT, READ METADATA ON TABLE stg.employees TO USER analyst;
+
+```
+
+The above authorization operations, including adding users to the workspace and granting roles, can also be completed through the WEB page.
+
+**Web-based workspace addition operation**
+
+Continue using the user who created the dev\_environment workspace, click on "Management" - "Workspace" in the left menu to enter the workspace list, find the dev\_environment workspace, and click to enter. On the "Users" tab of the workspace details page, click the "+ Add User" button on the right:
+
+:-: ![](.topwrite/assets/quickstart_team_p10.png =774)
+
+^
+
+In the pop-up window, find the user developer and check the box (you can also find the analyst user and check the box together. However, since the permissions to be granted to the two users are different, operate separately here, only add the developer user first).
+
+:-: ![](.topwrite/assets/quickstart_team_p11.png =763)
+
+^
+
+At this point, there are two buttons below, click the right "Add User" button to only perform the operation of adding the user to the workspace without any authorization. Click the left "Add User and Grant Role" button to further select the role to be granted. Suppose we click the left "Add User and Grant Role" button:
+
+:-: ![](.topwrite/assets/quickstart_team_p12.png =772)
+
+^
+
+Among the roles that can be granted, we select the "workspace\_dev" role, check the box, and click "Grant Role".
+
+After completing the above operations, we have completed the operations of adding the developer user to the workspace and granting authorization. The effect is equivalent to the authorization executed by the above SQL.
+
+For the authorization operation of the analyst user, since it includes the operation of "separately granting partial data permissions", it is recommended to use the SQL GRANT statement to perform the authorization, which is more convenient.
+
+### 3.6 Check Authorization Results
+
+Lakehouse supports using the SHOW GRANTS statement to query the permissions granted to users.
+
+Execute the following statement in the development function:
+
+```SQL
+SHOW GRANTS TO USER developer;
+```
+
+The results are as follows:
+
+:-: ![](.topwrite/assets/quickstart_team_p13.png =738)
+
+^
+
+### 3.7 Team Member Login to the System
+
+After completing the above operations, both the developer and analyst users can log in to Lakehouse and have the corresponding permissions to perform data development or queries. Below, we will use the developer user to log in to the system.
+
+Return to the Singdata login page <https://accounts.singdata.com/login>, and sequentially enter the account name, username, and password. The account name is provided after the account registration is successful and can be obtained from the URL after any user of the account logs in.
+
+:-: ![](.topwrite/assets/quickstart_team_p15.png =746)
+
+Now, use the developer user to log in at the .accounts.singdata.com/login URL, and click the "Enter" service instance button under the "Lakehouse" product to enter the Lakehouse service instance.
+
+:-: ![](.topwrite/assets/quickstart_team_p16.png =740)
+
+### 3.8 Team Member Writing Development Tasks
+
+After the developer user logs in, go to the "Development" page in the left menu. Since the current developer user has only joined the dev\_environment workspace, there is no need to switch workspaces. If multiple workspaces are joined, you can switch to the required workspace for development in the upper right corner.
+
+:-: ![](.topwrite/assets/quickstart_team_p17.png =739)
+
+^
+
+Click the "+" to create a new SQL script in the "Development" function, and write a query statement to query the data in the stg.employees table.
+
+:-: ![](.topwrite/assets/quickstart_team_p18.png =717)
+
+^
+
+```SQL
+select * from stg.employees limit 10;
+```
+
+:-: ![](.topwrite/assets/quickstart_team_p19.png =740)
+
+^
+
+Click the "Save" button to save the task code, and the "Schedule" button to open the schedule configuration popup.
+
+:-: ![](.topwrite/assets/quickstart_team_p20.png =572)
+
+^
+
+In the popup, configure the scheduling task's cycle, rerun method, and other information, then click the "OK" button to complete the scheduling configuration operation for the task.
+
+:-: ![](.topwrite/assets/quickstart_team_p21.png =730)
+
+^
+
+After successfully configuring the schedule, the "Submit" button becomes clickable. After clicking "Submit," the task is submitted for periodic scheduling.
+
+:-: ![](.topwrite/assets/quickstart_team_p22.png =695)
+
+^
+
+The above completes the process from creating a user, authorizing, to using the new user to develop SQL tasks and submitting them for periodic scheduling.

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

@@ -0,0 +1,90 @@
+# Quick Analysis of Local CSV Files
+
+### **Objective**:
+
+Through this document, you will be able to quickly analyze local CSV files using Lakehouse
+
+### **Analyze CSV Format Files**:
+
+#### **Data Preparation**:
+
+This article uses the Brazilian e-commerce public dataset as an example. In the local path /User/Downloads/brazil-ecommerce on the client, there are the following CSV files:
+```
+-------------/User/Downloads/brazil-ecommerce ------------------ 
+olist_customers_dataset.csv.gz 
+olist_geolocation_dataset.csv.gz
+olist_order_items_dataset.csv.gz 
+olist_order_payments_dataset.csv.gz 
+olist_order_reviews_dataset.csv.gz 
+olist_orders_dataset.csv.gz
+olist_products_dataset.csv.gz 
+olist_sellers_dataset.csv.gz 
+product_category_name_translation.csv.gz
+```
+Using the Lakehouse JDBC client SQLLine (or DBeaver / Datagrip, etc.) to upload data to the Lakehouse User volume space (restriction: single file must be smaller than 5G):
+
+(USER VOLUME is the file storage space that is automatically enabled for the current user in the current workspace, no need to create it in advance)
+```
+--Execute in SQLline or any Lakehouse JDBC client to upload a single file: olist_customers_dataset.csv.gz
+
+PUT '/User/Downloads/brazil-ecommerce/olist_customers_dataset.csv.gz' TO USER VOLUME SUBDIRECTORY 'bz_olist_data';
+```
+In the client tool, or in the Studio SQL task node, execute the following command to display the files that have been uploaded to the USER VOLUME:
+```
+show user volume directory like '%olist%';
+```
+#### **Quickly Analyze Data with Lakehouse SQL**
+
+For example: Count the number of users in each state and sort in descending order by the number of users
+```
+SELECT count(1) as customer_number_by_state,
+       customer_state,
+FROM USER VOLUME (
+    customer_id STRING,
+    customer_unique_id STRING,
+    customer_zip_code_prefix INT,
+    customer_city STRING,
+    customer_state STRING
+ ) using csv Options
+ (
+     'sep' = ',',
+     'compression'='gzip',  -- Currently supports zstd/gzip/zlib compression formats. Remove this parameter for no compression
+     'header'='true'
+ )
+ FILES ('bz_olist_data/olist_customers_dataset.csv.gz')
+group by customer_state
+order by customer_number_by_state desc;
+```
+Options parameters:
+
+* sep: Column separator, default is ",". Supports a maximum length of 1 character, for example: `'sep'=','`
+* compression: Configures the file compression format. Supported compression formats are: gzip/zstd/zlib. For example: `'compression'='gzip'`
+* header: Whether to parse the header, default is false. Boolean type, for example: `'header'='true'`
+
+In addition, the following parameters are also supported:
+
+* timeZone: Configures the time zone, no default value. Used to specify the time zone for the time format in the file. For example: `'timeZone' = 'Asia/Shanghai'`
+* escape: Used to escape quotes within quoted values, default value is "\", for example: `'escape'='\'`
+* lineSep: Line separator, default value is "\n". Supports a maximum length of 2 characters, for example: `'lineSep'='$'`
+* quote: Sets a single character used to escape quote values. The default value is double quotes '"', for example: `'quote'='"'`
+
+#### **Generate an internal table in the lakehouse**
+```
+CREATE TABLE OLIST_CUSTOMER_TBL
+AS
+SELECT * FROM USER VOLUME (
+    customer_id STRING,
+    customer_unique_id STRING,
+    customer_zip_code_prefix INT,
+    customer_city STRING,
+    customer_state STRING
+ ) using csv Options
+ (
+     'sep' = ',',
+     'compression'='gzip',
+     'header'='true'
+ )
+ FILES ('bz_olist_data/olist_customers_dataset.csv.gz');
+```
+
+^