feat: time travel docs added

Author: HelloJowet

docs/data_engineering/data_lakehouse/delta_lake/rust/01_create_table.md

@@ -1,4 +1,6 @@
-# Create Table
+description: delta-rs, rust, create table
+
+# Create table
 
 ```rust
 use deltalake::{kernel::DataType, DeltaOps};

docs/data_engineering/data_lakehouse/delta_lake/rust/02_insert_data.md

@@ -1,3 +1,5 @@
+description: delta-rs, rust, insert data
+
 # Insert data
 
 ```rust

docs/data_engineering/data_lakehouse/delta_lake/rust/03_load_table.md

@@ -1,28 +1,32 @@
+description: delta-rs, rust, load table
+
 # Load table
 
+## Open table
+
 ```rust
-use deltalake::operations::collect_sendable_stream;
-use deltalake::DeltaOps;
 
 #[tokio::main()]
 async fn main() {
     // ...
 
-    let (_, stream) = DeltaOps(table).load().await.expect("Load failed");
-    let records = collect_sendable_stream(stream).await.unwrap();
-
-    println!("{:?}", records)
+    let table = deltalake::open_table("s3://data-lakehouse/employee").await.expect("Load failed");
 }
 ```
 
-or
+## Load table data
 
 ```rust
+use deltalake::operations::collect_sendable_stream;
+use deltalake::DeltaOps;
 
 #[tokio::main()]
 async fn main() {
     // ...
 
-    let table = deltalake::open_table("s3://data-lakehouse/employee").await.expect("Load failed");
+    let (_, stream) = DeltaOps(table).load().await.expect("Load failed");
+    let records = collect_sendable_stream(stream).await.unwrap();
+
+    println!("{:?}", records)
 }
 ```

docs/data_engineering/data_lakehouse/delta_lake/rust/04_time_travel.md

@@ -0,0 +1,16 @@
+description: delta-rs, rust, time travel
+
+# Time travel
+
+To load the previous state of a table, you can use the `open_table_with_version` function:
+
+```rust
+let version = 1;
+let mut table = deltalake::open_table_with_version("s3://data-lakehouse/employee", version).await.expect("Load failed");
+```
+
+If the table is already loaded and you want to change the version number, just use the `load_version` function.
+
+```rust
+table.load_version(2).await.expect("Load failed");
+```

docs/data_engineering/data_lakehouse/delta_lake/rust/integrations/object_storage/s3.md

@@ -1,44 +1,29 @@
-# S3 storage integration
+description: delta-rs, rust, S3 storage integration
 
-```rust
-use deltalake::{DeltaOps, DeltaTableBuilder, DeltaTableError};
-use std::env;
-
-fn configure_s3() {
-    // Set S3 configuration options using environment variables
-    env::set_var("AWS_ENDPOINT_URL", "http://localhost:5561");
-    env::set_var("AWS_REGION", "us-east-1");
-    env::set_var("AWS_ACCESS_KEY_ID", "admin");
-    env::set_var("AWS_SECRET_ACCESS_KEY", "password");
-    env::set_var("AWS_ALLOW_HTTP", "true");
-    env::set_var("AWS_S3_ALLOW_UNSAFE_RENAME", "true");
-
-    // Register AWS S3 handlers for Delta Lake operations
-    deltalake::aws::register_handlers(None);
-}
+# S3
 
-/// Builds a `DeltaOps` instance for the specified Delta table.
-/// Enabling operations such as creating, reading and writing data in the Delta Lake format.
-async fn get_delta_ops(table_name: &str, load_state: bool) -> Result<DeltaOps, DeltaTableError> {
-    let delta_table_builder = DeltaTableBuilder::from_uri(format!("s3://data-lakehouse/{}", table_name));
-    let delta_table = match load_state {
-        // Load the existing table state
-        true => delta_table_builder.load().await?,
-        // Build the table without loading existing state
-        false => delta_table_builder.build()?,
-    };
-
-    Ok(DeltaOps::from(delta_table))
-}
+```rust
+use std::collections::HashMap;
 
 #[tokio::main()]
 async fn main() {
-    configure_s3();
+    // Register AWS S3 handlers for Delta Lake operations
+    deltalake::aws::register_handlers(None);
 
-    let table_name = "employee";
-    let load_state = false;
-    let delta_ops = get_delta_ops(table_name, load_state).await.expect("Failed to create data_ops object");
+    let mut storage_options = HashMap::new();
+    storage_options.insert("AWS_ENDPOINT_URL".to_string(), "http://localhost:5561".to_string());
+    storage_options.insert("AWS_REGION".to_string(), "us-east-1".to_string());
+    storage_options.insert("AWS_ACCESS_KEY_ID".to_string(), "admin".to_string());
+    storage_options.insert("AWS_SECRET_ACCESS_KEY".to_string(), "password".to_string());
+    storage_options.insert("AWS_ALLOW_HTTP".to_string(), "true".to_string());
+    storage_options.insert("AWS_S3_ALLOW_UNSAFE_RENAME".to_string(), "true".to_string());
+
+    let table = deltalake::open_table_with_storage_options("s3://data-lakehouse/employee", storage_options)
+        .await
+        .expect("Load failed");
 }
 ```
 
-If the table doesn't exist yet, the `load_state` parameter in `get_delta_ops` should be set to `false`, as setting it to `true` would attempt to read a non-existent state, resulting in an error. On the other hand, if you want to read from an existing table, `load_state` must be set to `true` to successfully load the data; otherwise, the load operation will fail.
+You can set the storage option parameters as environment variables too.
+
+S3 requires a locking provider by default ([more information](https://delta-io.github.io/delta-rs/usage/writing/writing-to-s3-with-locking-provider/)). If you don't want to use a locking provider, you can disable it by setting the `AWS_S3_ALLOW_UNSAFE_RENAME` variable to `true`.