A Comprehensive Guide to Installing and Using sxt-proof-of-sql 🚀

Saturday, Jan 11, 2025 | 5 minute read

GitHub Trend

Revolutionary tech ensures data integrity through Zero-Knowledge proofs, allowing you to validate SQL queries without accessing sensitive information. Boost performance with NVIDIA GPUs and enjoy seamless installation on Linux! 🚀🔐📊

Delving into sxt-proof-of-sql: A Game Changer for Data Validation 💡

With the advent of the data age, data security and accuracy have become increasingly important. Companies are facing numerous challenges in ensuring the integrity and authenticity of data during processing, which has become a focal point for everyone. 📊

sxt-proof-of-sql is a revolutionary technology developed by Space and Time. As a Zero-Knowledge (ZK) Prover, it aims to provide unprecedented support for validating SQL queries! Through the advanced technology of zero-knowledge proofs, sxt-proof-of-sql allows users to verify the correctness of SQL queries without directly accessing the data, thereby establishing a strong line of defense for corporate data security 🔐!

Installation Preparation 🛠️

To successfully use sxt-proof-of-sql, the first step is to ensure that your development environment meets specific requirements. First and foremost, make sure your operating system is Linux x86_64, and it is highly recommended to utilize an NVIDIA GPU for better performance! Below are the tools and software you need to prepare:

1. Operating System: It is recommended to use Linux x86_64. This is because many optimizations and features of the project are specifically developed for this platform!
2. NVIDIA GPU and Drivers: While machines without a GPU can still run the project, using an NVIDIA GPU can significantly boost performance and is a great option!
3. Required Tools:
   • Install lld by running sudo apt install lld: This is a linker used for Rust project compilation.
   • Install clang by running sudo apt install clang: This is a high-performance compiler that can speed up the code compilation process—super handy!
4. Rust: Ensure you have Rust 1.81.0 installed. Quickly visit the Rust Official Site for installation instructions.

Environment Configuration 💻

If you’re using a non-Linux machine or one without a GPU, don’t worry! Here are a couple of ways to help you set up your environment effortlessly:

• Solution #1: You can enable the CPU version of Blitzar by setting the BLITZAR_BACKEND environment variable and simply running the following command:

  export BLITZAR_BACKEND=cpu
  cargo test --all-features --all-targets
  

  This way, the project can run on the CPU, making it more convenient for users without GPUs!

• Solution #2: You can disable the blitzar feature in the code repository and test using the following command:

  cargo test --no-default-features --features="arrow cpu-perf"
  

  This way, you can operate without any GPU acceleration.

Running Example Code 🎉

Once you have installed all the necessary software, it’s time to try out the example code that comes with sxt-proof-of-sql! This code will help you understand how to use this open-source project. Next, we will detail how to run a simple “Hello World” example.

Running the “Hello World” Example 🗣️

This example demonstrates how to generate and verify a proof for the SQL query SELECT b FROM table WHERE a = 2. The data for the sample query is shown in the table below:

To run this example, just enter the following command in the terminal:

cargo run --example hello_world 

Note: If your environment doesn’t have a GPU, you can disable Blitzar by adding the --no-default-features flag:

cargo run --example hello_world --no-default-features --features="rayon test"

Sample Output 📊

After running the example, you should see output similar to the following:

Warming up GPU... 520.959485ms
Loading data... 3.229767ms
Parsing Query... 1.870256ms
Generating Proof... 467.45371ms
Verifying Proof... 7.106864ms
Valid proof!
Query result: OwnedTable { table: {Ident { value: "b", quote_style: None }: VarChar(["hello", "world"])} }

Look! This output showcases the entire process from loading data to verifying the proof, with time information giving you an insight into the duration of each step—really cool!

CSV Database Example 📂

The next example will show you how to use a CSV database. To install the CSV example, you can use the following command:

cargo install --example posql_db --path crates/proof-of-sql 

Running this command will install an example database encompassing Proof of SQL functionality. Although this example may require some additional configuration before being published to crates.io, we look forward to your attempts!

Performance Benchmark Example 🚀

To better showcase the speed and efficiency of sxt-proof-of-sql, we conducted benchmark tests! These tests aim to confirm performance under various conditions, and to obtain accurate results, we utilized multiple advanced NVIDIA GPUs.

During the tests, we first generated a series of randomly populated tables, followed by running several SQL queries on the data within the tables to validate the efficiency of Proof of SQL. Let’s take a look at the critical queries executed:

1. Query #1 - SELECT b FROM table WHERE a = 0
2. Query #2 - SELECT * FROM table WHERE ((a = 0) or (b = 1)) and (not (c = 'a'))
3. Query #3 - SELECT b, SUM(a) as sum_a, COUNT(*) as c FROM table WHERE (c = 'a' OR c = 'b') AND b > 0 GROUP BY b

The results from the queries are quite astonishing! For example, processing a query on 200,000 rows of data can be completed in sub-second time, while handling 100,000,000 rows takes approximately one minute.

Using sxt-proof-of-sql in Rust 🦀

You can also refer to the posql_db example in the project to learn how to leverage sxt-proof-of-sql! This example shows how to set up a database and execute SQL queries. Just clone the repository and run the following command:

cargo run --example posql_db

Code Example 📜

Here’s a core code snippet from posql_db:

fn main() {
    let db = Database::new("example.db").unwrap(); // Create a new database instance
    db.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)").unwrap(); // Create a table
    db.execute("INSERT INTO users (name) VALUES ('Alice')").unwrap(); // Insert a record
    let mut stmt = db.prepare("SELECT * FROM users").unwrap(); // Prepare the query
    let rows = stmt.query_map([], |row| {
        Ok(User {
            id: row.get(0)?, // Fetch id
            name: row.get(1)?, // Fetch name
        })
    }).unwrap();
    
    for user in rows {
        println!("Found user: {:?}", user.unwrap()); // Print user information
    }
}

In this example, you can see how to programmatically create a database, create a table, insert records, and execute queries while printing the results—simple yet efficient!

With these steps and examples, you should be able to quickly get started with sxt-proof-of-sql and further explore and develop upon this foundation! 🎉