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

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

@@ -0,0 +1 @@
+# LangChain Integration Guide

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

@@ -0,0 +1,43 @@
+## LEFT 
+
+In Lakehouse, the LEFT function is used to extract a specified number of characters from the left side of a given string. It is important to note that the unit of character length is utf8 characters, which means that a Chinese character will be considered as one length unit.
+
+###  Syntax
+
+The syntax format of the LEFT function is as follows:
+```Plaintext
+LEFT(str, len)
+```
+- `str`: The string from which characters are to be extracted. This parameter accepts data of type VARCHAR.
+- `len`: The number of characters to be extracted from the left side of the string. This parameter should be a positive integer.
+
+### Return Value
+
+The LEFT function returns a string containing the specified number of characters extracted from the left side of the input string. The return value's data type is VARCHAR.
+
+###  Example
+
+Below are several usage examples of the LEFT function:
+
+Example 1:
+```SQL
+SELECT LEFT('Hello, welcome to Lakehouse', 5);
+```
+This query will return the first 5 characters on the left side of the string 'Hello, welcome to Lakehouse', which is 'Hello'.
+
+ Example 2:
+```SQL
+SELECT LEFT('Lakehouse, a powerful real-time data warehouse.', 9);
+```
+This query will return the first 9 characters from the left side of the string 'Lakehouse, a powerful real-time data warehouse.', which is 'Lakehouse'.
+
+Example 3:
+```SQL
+SELECT LEFT('The quick brown fox jumps over the lazy dog', 9);
+```
+This query will return the first 9 characters from the left side of the string 'The quick brown fox jumps over the lazy dog', which is 'The quick'.
+
+### Notes
+
+- Ensure that the `len` parameter is a positive integer, otherwise the function will return an error.
+- If the `len` parameter is greater than the length of the input string, the LEFT function will return the entire input string.

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

@@ -0,0 +1,71 @@
+# ilike Operator Usage Guide
+
+The ilike operator is a tool used in SQL query statements for string matching. It can help you determine whether a string matches a specific pattern without considering case sensitivity. The usage of the ilike operator is similar to the like operator, but it is more flexible and convenient, allowing you to handle string matching issues more easily.
+
+## Syntax
+
+The basic syntax of the ilike operator is as follows:
+```SQL
+str [ NOT ] ilike pattern
+```
+In which, `str` is the string expression to be matched, and `pattern` is the pattern expression to be matched. You can also use the `NOT` keyword to reverse the matching condition.
+In addition, the ilike operator also supports the use of `ANY`, `SOME`, or `ALL` keywords to match multiple patterns. When using `ALL`, `str` must match all given patterns; when using `ANY` or `SOME`, `str` only needs to match at least one pattern.
+
+### Wildcards in Patterns
+The ilike operator's pattern contains the following two special characters to represent wildcard matching:
+* `_`: Matches any single character (similar to `.` in POSIX regular expressions).
+* `%`: Matches any number of characters (similar to `.*` in POSIX regular expressions).
+
+
+##  Example
+Suppose we have a table named `students` that contains the names and class information of students, as shown below:
+```SQL
+CREATE TABLE students (
+  name STRING,
+  class STRING
+);
+
+INSERT INTO students (name, class) VALUES
+  ('Alice', 'A'),
+  ('Bob', 'B'),
+  ('Carol', 'A'),
+  ('David', 'C');
+```
+Here are some query examples using the ilike operator and their output results:
+
+1. Query students whose names contain the letter "a" (case-sensitive):
+```SQL
+SELECT name, class
+FROM students
+WHERE class like '%a%';
+
++------+-------+
+| name | class |
++------+-------+
+```
+2. Query students whose names start with "a" or "b" (case-sensitive):
+```SQL
+SELECT name, class
+FROM students
+WHERE name like ANY ('a%', 'b%');
+
++------+-------+
+| name | class |
++------+-------+
+```
+```markdown
+3. Query students whose names contain both the letters "a" and "l":
+```
+```SQL
+SELECT name, class
+FROM students
+WHERE name like ALL ('%a%', '%l%');
+
++-------+-------+
+| name  | class |
++-------+-------+
+| Carol | A     |
++-------+-------+
+```
+
+^

package/bin/skills/lakehouse-doc-en/references/list-partition.md

@@ -0,0 +1,88 @@
+# Description
+
+`SHOW PARTITIONS` is a command in SQL used to display partition information of a specified table. Partitioned tables are a common data organization method in data warehouses, optimizing query performance and management efficiency by distributing data across different partitions. Using `SHOW PARTITIONS` allows you to quickly view the partition structure of a table and detailed information about each partition.
+
+# Usage Restrictions
+
+* Currently, partitions written using the [real-time SDK](java_reference/realtime-upload.md) cannot be viewed immediately. You need to wait for the real-time written data to be committed to view the partition size.
+
+# Syntax
+```SQL
+SHOW PARTITIONS [EXTENDED] table_name [ PARTITION ( partition_col_name = partition_col_val [ , ... ] ) ]
+[WHERE <expr>]
+```
+## Parameter Description
+
+* **EXTENDED**: Adding this keyword allows you to view the number of files, size, number of rows, and modification time of the partition.
+* **table\_name**: The name of the table for which partition information needs to be queried. Supports tables, dynamic tables, and materialized views.
+* **PARTITION ( partition\_col\_name = partition\_col\_val** \[ , ... ] ): Optional parameter used to specify specific conditions for the partition to be viewed. By specifying the value of the partition key, specific partition information can be filtered out.
+* **where \<expr**>: Optional, can filter based on displayed fields. Supports filtering based on total\_rows, bytes, total\_files, created\_time. Expr supports =, !=, >, <, >=, <=, is null, is not null, between ...and, or, not, <>, in.
+
+# Usage Scenarios
+
+* **View Partition Structure**: Understand the partition strategy of the table and the current partition situation. View partition size and modification time.
+* **Data Management**: When importing, exporting, or maintaining data, understanding partition information helps manage data more efficiently.
+
+# Examples
+
+## View All Partitions
+```SQL
+DROP TABLE IF EXISTS pt_table;
+CREATE TABLE pt_table (order_id INT, customer_id INT, amount DOUBLE) PARTITIONED BY (pt1 string,pt2 string);
+INSERT INTO pt_table
+VALUES (1, 101, 100.0, '2023','01'),
+       (2, 102, 200.0, '2023','02'),
+       (3, 103, 300.0, '2023','03'),
+       (4, 104, 400.0, '2023','04');
+
+SHOW PARTITIONS pt_table;
++-----------------+
+|   partitions    |
++-----------------+
+| pt1=2023/pt2=01 |
+| pt1=2023/pt2=02 |
+| pt1=2023/pt2=03 |
+| pt1=2023/pt2=04 |
++-----------------+
+SHOW PARTITIONS EXTENDED pt_table;
++-----------------+------------+-------+-------------+-------------------------+
+|   partitions    | total_rows | bytes | total_files |      created_time       |
++-----------------+------------+-------+-------------+-------------------------+
+| pt1=2023/pt2=01 | 1          | 3101  | 1           | 2024-12-20 14:25:34.99  |
+| pt1=2023/pt2=02 | 1          | 3102  | 1           | 2024-12-20 14:25:34.99  |
+| pt1=2023/pt2=03 | 1          | 3102  | 1           | 2024-12-20 14:25:34.99  |
+| pt1=2023/pt2=04 | 2          | 3119  | 1           | 2024-12-20 14:25:34.99  |
++-----------------+------------+-------+-------------+-------------------------+
+```
+The above command will return all partition information of the `sales_data` table.
+
+## View Specific Partition
+```SQL
+SHOW PARTITIONS pt_table PARTITION (pt1 = '2023');
++-----------------+
+|   partitions    |
++-----------------+
+| pt1=2023/pt2=01 |
+| pt1=2023/pt2=02 |
+| pt1=2023/pt2=03 |
+| pt1=2023/pt2=04 |
++-----------------+
+SHOW PARTITIONS pt_table PARTITION (pt1 = '2023',pt2='01');
++-----------------+
+|   partitions    |
++-----------------+
+| pt1=2023/pt2=01 |
++-----------------+
+```
+## Use where to filter based on displayed fields
+```SQL
+--Filter partitions with total rows greater than 1
+SHOW PARTITIONS EXTENDED pt_table WHERE total_rows>1;
++-----------------+------------+-------+-------------+-------------------------+
+|   partitions    | total_rows | bytes | total_files |      created_time       |
++-----------------+------------+-------+-------------+-------------------------+
+| pt1=2023/pt2=04 | 2          | 3119  | 1           | 2024-12-20 14:25:34.99  |
++-----------------+------------+-------+-------------+-------------------------+
+```
+
+

package/bin/skills/lakehouse-doc-en/references/llama-index.md

@@ -0,0 +1,52 @@
+# Introduction to LlamaIndex
+
+LlamaIndex is an application data framework based on large language models (LLM), designed for context-enhanced applications. This type of LLM system is known as a RAG system, or "Retrieval-Augmented Generation". LlamaIndex provides the necessary abstractions to more easily ingest, construct, and access private or domain-specific data, so that this data can be securely and reliably injected into the LLM for more accurate text generation.
+
+The key to data ingestion in LlamaIndex lies in loading and transforming. After loading documents, you can process them through transformation and output nodes. LlamaIndex can load data stored in cloud data warehouse Lakehouse through the Database Reader.
+
+## Example Code
+```
+from llama_index.readers.database import DatabaseReader
+
+import streamlit as st
+
+username = st.secrets.lakehouse.username
+password = st.secrets.lakehouse.password
+account = st.secrets.lakehouse.account
+endpoint = st.secrets.lakehouse.endpoint
+workspace = st.secrets.lakehouse.workspace
+schema = st.secrets.lakehouse.schema
+virtualcluster = st.secrets.lakehouse.virtualcluster
+
+CONNECTION_STRING = (
+    f"clickzetta://{username}:{password}@"
+    f"{account}.{endpoint}/{workspace}?schema={schema}&virtualcluster={virtualcluster}"
+)
+
+db = DatabaseReader(uri=CONNECTION_STRING, schema=schema)
+```
+## Available Methods for SQLDatabase
+```
+print(type(db.sql_database.from_uri))
+print(type(db.sql_database.get_single_table_info))
+print(type(db.sql_database.get_table_columns))
+print(type(db.sql_database.get_usable_table_names))
+print(type(db.sql_database.insert_into_table))
+print(type(db.sql_database.run_sql))
+```
+```
+query = f"""
+    SELECT
+        CONCAT(name, ' is ', age, ' years old.') AS text
+    FROM public.users
+    WHERE age >= 18
+    """
+
+documents = db.load_data(query=query)
+
+index = VectorStoreIndex.from_documents(documents)
+
+```
+### Reference Documentation
+
+[Llama-Index Database Reader](https://docs.llamaindex.ai/en/stable/examples/data_connectors/DatabaseReaderDemo.html)

package/bin/skills/lakehouse-doc-en/references/load-data-local.md

@@ -0,0 +1,85 @@
+# Import Local Data
+
+This document provides a detailed introduction on how to import local data into the Lakehouse platform. Currently, Lakehouse supports three main modes of local data import:
+
+1. Upload local files using the PUT command and import them into Lakehouse.
+2. **Visual upload via the Lakehouse Studio page**: Suitable for small data file uploads, providing a user-friendly interface and simplified upload process.
+3. **Upload data using the Jdbc client**: Suitable for technical users, especially those who need to batch process small amounts of data, supporting quick processing of CSV files and scripted, automated operations. (This feature has been deprecated in jdbc version 2.0.0, it is recommended to use the PUT command for uploads)
+
+## Reference Documents
+
+[Download data using the client COPY command](copy.md)
+
+## Application Scenarios
+
+* **Put command to upload files**: Suitable for source file uploads and requires SQL for conversion. It is recommended to use SQL to convert or handle abnormal data during the upload process. Supports CSV, PARQUET, ORC.
+* **Lakehouse Studio page**: Suitable for users who need to upload small data files, supports CSV, PARQUET, AVRO, ORC, TEXT formats, but does not include compressed file formats. It is recommended to decompress locally before uploading.
+* **Jdbc client**: Only supports CSV file format, does not support compressed files, suitable for quick processing and automated data import tasks. In versions after JDBC 2.0.0, the local COPY command has been deprecated. We recommend using the PUT method to upload data to the volume, and then using the server-side COPY command for import.
+
+# Use Cases
+
+## Upload data using the PUT command
+
+Lakehouse currently has some [Internal Volume](internal_volume.md) built-in to store files. Internal Volume currently supports two object types: USER VOLUME and TABLE VOLUME. We use the Put command to upload files to the Internal Volume and then use the COPY command to import the Volume data into the table.
+
+**Prerequisites**
+
+* [Command line tool](connect-with-cli.md) installed. Alternatively, you can use open-source tools like DBeaver, SQL Workbench/J to execute the command.
+* INSERT permission on the target table.
+
+1. Execute the PUT command in the command line to upload the file to the TABLE VOLUME.
+
+```SQL
+--Upload file to the root directory of user volume
+PUT '/Users/Downloads/data.csv' TO TABLE VOLUME t_copy_from_volume FILE 'data.csv';
+```
+
+2. Use the [COPY INTO](copy-into-table.md) command to import file data into the target table
+
+```SQL
+COPY INTO t_copy_from_volume FROM TABLE VOLUME t_copy_from_volume(id int, name string)  USING csv  
+OPTIONS(
+        'header'='true',
+        'lineSep'='\n'
+)
+FILES ('data.csv')
+--Delete files in the volume to save storage
+PURGE=TRUE;
+;
+```
+
+## Upload Using Lakehouse Studio Page
+
+Usage Restrictions
+
+* **File Format Restrictions**: Complex types such as ARRAY, MAP, STRUCT, JSON, INTERVAL are not supported. For complex type data, it is recommended to map using STRING type and convert through Lakehouse SQL functions.
+* **File Size Restrictions**: The maximum size of a single file supported by the Lakehouse Studio page and Jdbc client is 2GB.
+* **COPY Command Restrictions**: The COPY command cannot be used to upload local files on the Studio page. This command requires specifying the local file path, which the Studio page cannot access.
+  In data management, the top area also provides an "Upload" function, which supports uploading local files to the Singdata Lakehouse platform.
+
+  ![](.topwrite/assets/image_1739882370719.png =296)
+
+Click the "Upload" button to easily load data from local files to the Singdata Lakehouse platform. It supports csv and txt formats, and the total size of uploaded files cannot exceed 2GB.
+
+![](.topwrite/assets/image_1739882380425.png =402)
+
+**Format Description**
+
+* Encountering Errors: How to handle error scenarios such as abnormal data in data rows.
+
+* Column Separator: The separator between columns, only a single character is allowed. For csv files, the default is a comma.
+
+* Line Break: Set the handling method for line breaks, Windows system uses \r\n, Linux, and MAC systems use \n.
+
+* Ignore Header: Whether to include the header in the uploaded file.
+
+* Null Value Representation: Specify the representation of null values in the file.
+
+* Cluster: Data upload can only be performed after selecting a cluster.
+
+* Data Write Method:
+
+  * Append Write: Directly append without processing historical data.
+  * Clear and Write: Clear historical data in the table first, then write data.
+
+^

package/bin/skills/lakehouse-doc-en/references/load-data-oss.md

@@ -0,0 +1,175 @@
+# Batch import data from Object Storage（OSS）
+
+This document details how to use the Lakehouse SQL engine to import data from object storage. Currently, Lakehouse supports two main data import modes:
+
+1. **Import using Volume**: Import data by creating and managing Volumes on object storage.
+2. **Import using Copy command**: Load data directly from object storage using the SQL COPY command.
+
+## Reference Documentation
+
+[Data Lake Query](structure_data_analysis.md)
+
+[COPY INTO](copy-into-table.md)
+
+## Application Scenarios
+
+* Quickly read large amounts of data using the performance advantages of the SQL engine, efficiently handling large-scale datasets.
+* Support data transformation using SQL during the data import process, achieving ETL (Extract, Transform, Load) processes.
+* It is recommended to choose a General Purpose Virtual Cluster when importing data to meet the needs of batch jobs and data loading jobs.
+
+## Usage Restrictions
+
+* **Object Storage Support**: Currently, the target object storage for Volume only supports Alibaba Cloud OSS and Tencent Cloud COS.
+* **Cost Description**: Downloading files from external Volume may incur object storage download fees on the cloud account. Please refer to the billing description of the respective cloud service provider for specific fees. If Lakehouse and object storage are located in the same region, using the internal network ENDPOINT can avoid additional costs.
+* **Cross-Cloud Import**: Currently, cross-cloud service provider data import is not supported (it will be supported in future versions).
+
+## Use Cases
+
+### Import CSV Data from OSS using Volume
+
+This document details how to use Lakehouse's Volume and COPY command to import the public dataset of [Brazilian E-commerce](https://www.kaggle.com/datasets/olistbr/brazilian-ecommerce?select=olist_customers_dataset.csv) from Alibaba Cloud Object Storage Service (OSS). Alternatively, you can directly download the dataset for this case through [this link](https://czsampledata.oss-cn-shanghai.aliyuncs.com/eCommerce/BrazilianECommerce/olist_customers_dataset.csv?Expires=1713960305\&OSSAccessKeyId=TMP.3Kj9FumEnKg87NyAXLcgdBykW427fGRqHzTyiLfNtki6Vagmg1zMHEfVcqov1PXETvKM7DKauBXyah4YNWhfdgHNufoq2j\&Signature=afXWkoRTi%2BercYhvlsPKdrpv0Fg%3D\&x-oss-request-payer=requester) and then upload it to OSS. This process includes table creation, object storage connection configuration, Volume management, and data loading and status checking.
+
+#### Prerequisites
+
+* Ensure the target table `brazilian_customer` has been created:
+
+```SQL
+create table brazilian_customer( 
+  customer_id STRING,
+  customer_unique_id STRING,
+  customer_zip_code_prefix INT,
+  customer_city STRING,
+  customer_state STRING
+  );
+```
+
+* Have INSERT permission on the target table.
+
+#### Create CONNECTION and VOLUME for connecting object storage
+
+* Create a STORAGE CONNECTION to store and desensitize the connection information of object storage, which is convenient for reuse and management in Lakehouse.
+* Create an EXTERNAL VOLUME to manage the data on OSS.
+
+```SQL
+-- Store the connection information of the object storage. In Lakehouse, the access key (ak) will be desensitized. At the same time, the connection can be conveniently reused in multiple places.
+-- The endpoint uses the internal network of OSS because both Lakehouse and OSS are in Shanghai, so the internal network can be directly connected.
+CREATE STORAGE CONNECTION  braziliandata_conn
+    TYPE oss
+    ENDPOINT = 'oss-cn-shanghai-internal.aliyuncs.com'
+    access_id = 'xxxx'
+    access_key = 'xxxx'
+    comments = 'OSS public endpoint';
+ -- View the created connection
+ SHOW CONNECTIONS;
+-- Create Volume to manage the data on the object storage
+CREATE EXTERNAL VOLUME braziliandata_csv
+    location 'oss://yourbucketname/eCommerce/BrazilianECommerce/'
+    using connection braziliandata_conn
+    directory = (
+        enable=true,
+        auto_refresh=true
+    );
+  SHOW VOLUMES;
+```
+
+#### **Using Volume to Load Data**
+
+* Specify the files that need to be read from the Volume in the `files` parameter.
+* You can set parameters for the CSV file in `options`, such as the delimiter, etc. Refer to the documentation for specific settings.
+* In this case, the data will be transformed during loading, excluding records where the city is 'curitiba'.
+
+```SQL
+-- Exclude the city 'curitiba' when loading data
+insert into brazilian_customer
+select * from volume braziliandata_csv (
+  customer_id STRING,
+  customer_unique_id STRING,
+  customer_zip_code_prefix INT,
+  customer_city STRING,
+  customer_state STRING
+)using csv 
+ options(
+    'header'='true',
+    'sep'=','
+ ) files('olist_customers_dataset.csv') 
+ where customer_city !='curitiba';
+```
+
+#### View Import Data Status
+
+Check the job execution status in the job run history of Lakehouse to confirm whether the data import was successful.
+
+![](.topwrite/assets/image_1739882452329.png =777)
+
+### Import Data from OSS Using COPY Command
+
+This article introduces how to use Lakehouse's COPY command to import a public dataset of [Brazilian E-commerce](https://www.kaggle.com/datasets/olistbr/brazilian-ecommerce?select=olist_customers_dataset.csv) from Alibaba Cloud Object Storage Service (OSS), or you can directly download the dataset for this case through [this link](https://czsampledata.oss-cn-shanghai.aliyuncs.com/eCommerce/BrazilianECommerce/olist_geolocation_dataset.csv?Expires=1713960430\&OSSAccessKeyId=TMP.3Kj9FumEnKg87NyAXLcgdBykW427fGRqHzTyiLfNtki6Vagmg1zMHEfVcqov1PXETvKM7DKauBXyah4YNWhfdgHNufoq2j\&Signature=2bCPx2sokSkMGpwfkipZqfmoWlE%3D\&x-oss-request-payer=requester) and then upload it to OSS. This process involves creating the data table, connecting and configuring the Volume, as well as loading the data and checking the status.
+
+#### Prerequisites
+
+* Ensure that the target table `brazilian_geolocation` has been created:
+
+```SQL
+create table brazilian_geolocation( 
+  geolocation_zip_code_prefix INT,
+  geolocation_lat DECIMAL(10,8),
+  geolocation_lng DECIMAL(11,8),
+  geolocation_city STRING,
+  geolocation_state STRING
+  );
+```
+
+* Have INSERT permission on the target table.
+
+#### Create CONNECTION and VOLUME for connecting object storage
+
+* Create a STORAGE CONNECTION to store and desensitize the connection information of the object storage, so that it can be reused and managed multiple times in the Lakehouse.
+
+* Create an EXTERNAL VOLUME to manage the data on OSS.
+
+* ```SQL
+    --Store the connection information of the object storage. In Lakehouse, the access key (ak) will be desensitized. At the same time, the connection can be conveniently reused and managed in multiple places.
+    --The endpoint uses the internal network of OSS because both it and Lakehouse are in Shanghai, so the internal network can be directly connected.
+    CREATE STORAGE CONNECTION  braziliandata_conn
+        TYPE oss
+        ENDPOINT = 'oss-cn-shanghai-internal.aliyuncs.com'
+        access_id = 'xxxx'
+        access_key = 'xxxx'
+        comments = 'OSS public endpoint';
+     --View the created connection
+     SHOW CONNECTIONS;
+    --Create Volume to manage the data on the object storage
+    CREATE EXTERNAL VOLUME braziliandata_csv
+        location 'oss://czsampledata/eCommerce/BrazilianECommerce/'
+        using connection braziliandata_conn
+        directory = (
+            enable=true,
+            auto_refresh=true
+        );
+      SHOW VOLUMES;
+  ```
+
+#### Using the COPY Command to Load Data into a Table
+
+Use the COPY command to load data from an OSS Volume into the `brazilian_customer` table.
+
+```SQL
+COPY  INTO brazilian_customer FROM VOLUME  
+braziliandata_csv (
+  customer_id STRING,
+  customer_unique_id STRING,
+  customer_zip_code_prefix INT,
+  customer_city STRING,
+  customer_state STRING
+)using csv 
+ options(
+    'header'='true',
+    'sep'=','
+ ) files('olist_geolocation_dataset.csv') ;
+```
+
+#### View Import Data Status
+
+Check the job execution status in the job run history of Lakehouse to confirm whether the data import was successful.
+
+![](.topwrite/assets/image_1739954649263.png)

package/bin/skills/lakehouse-doc-en/references/load-history-function.md

@@ -0,0 +1,14 @@
+#### load\_history function
+
+**Function description**: The load\_history function is used to view the history of COPY job imported files for a table, with a retention period of 7 days. At the same time, Pipe will avoid re-importing existing files based on load\_history during execution, ensuring data uniqueness.
+
+**Function syntax**:
+```SQL
+load_history('schema_name.table_name')
+```
+* **schema\_name.table\_name**: Specify the table name to view the import history.
+
+**Use Case**:
+```SQL
+SELECT * FROM load_history('myschema.mytable');
+```

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

@@ -0,0 +1,17 @@
+#### load_history Function
+
+**Feature Description**: The load_history function is used to view the history of files imported by COPY jobs for a table, with a retention period of 7 days. Additionally, Pipe avoids duplicate imports of existing files based on the load_history, ensuring data uniqueness during execution.
+
+**Function Syntax**:
+
+```SQL
+load_history('schema_name.table_name')
+```
+
+* **schema_name.table_name**: Specifies the name of the table for which to view the import history.
+
+**Usage Example**:
+
+```SQL
+SELECT * FROM load_history('myschema.mytable');
+```

package/bin/skills/lakehouse-doc-en/references/logging-in.md

@@ -0,0 +1,68 @@
+# Logging in to Singdata Lakehouse
+
+You can log in to Singdata Lakehouse in many ways.
+
+If you’re getting started with Singdata Lakehouse, start by using [Singdata Lakehouse Studio](studio_overview.md) or [Singdata Lakehouse  CLI](connect-with-cli.md), the command line client that you can download. After you get comfortable using Singdata Lakehouse, you can explore connecting to Singdata Lakehouse with other methods.
+
+^
+
+## Account Registration
+
+Before using Singdata services, you must create an account. Currently, a registration code (invitation code) is required. After obtaining the registration code by contacting our sales team, you can visit <https://accounts.singdata.com/register> to sign up.
+
+1. **Visit the** [registration page](https://accounts.singdata.com/register). On the registration page, follow the prompts to enter your desired username and password. The username you enter here will be the first user created under your new account and will be granted administrator privileges.
+2. **Enter your** **Email address**: Please provide the email address that you used to obtain the invitation code, then click the “Get Code” button. A verification code will be sent to this email address. Enter the received verification code in the “Verification Code” field. This email address will serve both as the registered email for the account and for the first user created under this account.
+3. **Enter the invitation code**: Input the invitation code sent by the Singdata sales team. Each invitation code can only be used once and **must** match the bound phone number.
+
+:-: ![](/.topwrite/assets/image_1761728631383.png)
+
+After completing the steps above, click “Register Now” to finalize your account registration. You will see a success message with a link to your account login page. Please keep this address in a safe place for future use. The user created during registration will automatically become the administrator of the account. Click “Go to Login” on the success message and use the username and password you set during registration to sign in.
+
+***
+
+## Logging into Your Account
+
+Once you have successfully registered, you can log in with your account name, username, and password.
+
+![](.topwrite/assets/image_1741178602186.png)
+
+1. **Using Your Account-Specific Login URL**: Go to `https://<your_account_name>.accounts.singdata.com/login`. On the login page, enter your username and password, then click “Login.”
+
+   * If you have forgotten your username or password, click the “Forgot Username?” or “Forgot Password?” button and use the phone number associated with that user to recover it.
+   * If you have forgotten your account name, click “Forgot Account Name?” and verify using the phone number associated with the account.
+
+2. **Using the General Login Page**: Go to [https://accounts.singdata.com/login](https://accounts.clickzetta.com/login) to log in. Enter your 8-digit account name (shown when you completed registration), then click “Login” to be directed to the account’s login page. In the login prompt, enter the correct username and password, then click “Login.”
+
+   * If you have forgotten your account name, click “Forget Account” on the account login page and verify using the phone number you used at registration to retrieve it.
+
+   ^
+
+## Your Singdata Lakehouse account identifier
+
+All access to Singdata Lakehouse is through your account identifier. See [Manage Account](manageaccounts.md) for details.
+
+^
+
+## Logging in using Singdata Lakehouse CLI
+
+Singdata Lakehouse CLI is the command line client for connecting to Singdata Lakehouse to execute SQL queries and perform all DDL and DML operations, including loading data into and unloading data out of datalake files and database tables.
+
+For more detailed instructions, see [Singdata Lakehouse  CLI](connect-with-cli.md)
+
+^
+
+## Connecting using other methods
+
+In addition to the Singdata Lakehouse web interface and CLI, Singdata Lakehouse supports numerous other methods for connecting, including:
+
+* Using 3rd-party client services and applications that support JDBC.
+* Using 3rd-party client services and applications that support JDBC via MySQL JDBC driver.
+* Developing applications that connect through the Singdata Lakehouse connectors/drivers for Python SQL Alchemy, Zettapark, Spark, etc.
+
+However, connecting to Singdata Lakehouse using these other methods requires additional installation, configuration, and development tasks. For more information, see [Applications and tools for connecting to Singdata Lakehouse](tutorial_connect_to_lakehouse.md).
+
+^
+
+For more information about the tasks you can perform in Singdata Lakehouse  Studio, refer to [Singdata Lakehouse  Studio quick tour](lakehousestudiotour.md).
+
+For more information about the detail manual guides of Singdata Lakehouse  Studio, refer to [Singdata Lakehouse  Studio manual guides](studio_manual.md).