feat: insert functionality added

Author: HelloJowet

docs/data_engineering/data_lakehouse/delta_lake/rust.md

@@ -1,35 +1,61 @@
 # delta-rs
 
-This guide provides an introduction to using the Delta Lake Rust library (delta-rs).
+This guide provides an introduction to using the [Delta Lake Rust library (delta-rs)](https://github.com/delta-io/delta-rs).
 
 ## Install dependencies
 
 ```toml
 [dependencies]
-deltalake = { version = "0.22.3", features = ["s3"] }
+deltalake = { version = "0.22.3", features = ["datafusion", "s3"] }
 ```
 
-## Create table
+## Initial setup
 
 ```rust
-use deltalake::kernel::DataType;
-use deltalake::{DeltaOps, DeltaTable, DeltaTableBuilder, DeltaTableError};
+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);
+}
+
 /// Builds a `DeltaOps` instance for the specified Delta table.
-/// Enabling operations such as creating, reading, and writing data in the Delta Lake format.
+/// Enabling operations such as creating, reading and writing data in the Delta Lake format.
 fn get_delta_ops(table_name: &str) -> Result<DeltaOps, DeltaTableError> {
     let delta_table = DeltaTableBuilder::from_uri(format!("s3://data-lakehouse/{}", table_name)).build()?;
 
     Ok(DeltaOps::from(delta_table))
 }
 
+#[tokio::main()]
+async fn main() {
+    configure_s3()
+}
+```
+
+## Create table
+
+```rust
+use deltalake::kernel::DataType;
+use deltalake::{DeltaTable, DeltaTableError};
+
+// ...
+
 async fn create_table(table_name: &str) -> Result<DeltaTable, DeltaTableError> {
     let delta_ops = get_delta_ops(table_name)?;
 
     let table = delta_ops
         .create()
-        .with_table_name("employee")
+        .with_table_name(table_name)
         .with_column("id", DataType::INTEGER, false, Default::default())
         .with_column("name", DataType::STRING, false, Default::default())
         .await?;
@@ -39,19 +65,50 @@ async fn create_table(table_name: &str) -> Result<DeltaTable, DeltaTableError> {
 
 #[tokio::main()]
 async fn main() {
+    configure_s3()
+
     let table_name = "employee";
+    create_table(&table_name).await.expect("Table creation failed");
+}
+```
 
-    // 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");
+## Insert
 
-    // Register AWS S3 handlers for Delta Lake operations.
-    deltalake::aws::register_handlers(None);
+```rust
+use deltalake::arrow::array::{Int32Array, RecordBatch, StringArray};
+use deltalake::arrow::datatypes::{DataType as ArrowDataType, Field, Schema as ArrowSchema};
+use deltalake::protocol::SaveMode;
+use deltalake::{DeltaTable, DeltaTableError};
+use std::sync::Arc;
 
-    create_table(&table_name).await.expect("Table creation failed");
+// ...
+
+async fn insert(table_name: &str, save_mode: SaveMode) -> Result<DeltaTable, DeltaTableError> {
+    // Define the schema for the record
+    let schema = Arc::new(ArrowSchema::new(vec![
+        Field::new("int", ArrowDataType::Int32, false),
+        Field::new("string", ArrowDataType::Utf8, true),
+    ]));
+
+    // Create a employee record
+    let ids = Int32Array::from(vec![1, 2, 3]);
+    let names = StringArray::from(vec!["Tom", "Tim", "Titus"]);
+    let employee_record = RecordBatch::try_new(schema, vec![Arc::new(ids), Arc::new(names)]).unwrap();
+
+    let delta_ops = get_delta_ops(table_name)?;
+    // Insert record
+    let table = delta_ops.write(vec![employee_record]).with_save_mode(save_mode).await?;
+
+    Ok(table)
+}
+
+#[tokio::main()]
+async fn main() {
+    // ...
+
+    let table_name = "employee";
+    insert(&table_name, SaveMode::Append).await.expect("Insert failed");
 }
 ```
+
+The default save mode for the `delta_ops.write` function is `SaveMode::Append`. To overwrite existing data instead of appending, use `SaveMode::Overwrite`.