Struct SimpleUuid 

pub struct SimpleUuid { /* private fields */ }

简单的 UUID v4 实现

Implementations

impl SimpleUuid

pub fn new_v4() -> Self

Examples found in repository

examples/basic_usage.rs (line 106)

fn demonstrate_simplified_uuid() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("Generating UUIDs:");
    
    // Generate multiple UUIDs
    let uuid1 = SimpleUuid::new_v4();
    let uuid2 = SimpleUuid::new_v4();
    let uuid3 = SimpleUuid::new_v4();
    
    println!("  UUID 1: {}", uuid1);
    println!("  UUID 2: {}", uuid2);
    println!("  UUID 3: {}", uuid3);
    println!("  All unique: {}", uuid1 != uuid2 && uuid2 != uuid3 && uuid1 != uuid3);
    
    println!();
    println!("ID Generator:");
    let generator = IdGenerator::new();
    let id1 = generator.generate();
    let id2 = generator.generate();
    
    println!("  ID 1: {}", id1);
    println!("  ID 2: {}", id2);
    println!("  ID 3: {}", generator.with_prefix("user_").generate());
    
    println!();
    println!("Simple IDs:");
    let simple_gen = IdGenerator::new().with_simple_id();
    println!("  Simple ID: {}", simple_gen.generate());
    println!("  Prefixed: {}", simple_gen.with_prefix("order_").generate());

    Ok(())
}

examples/postgresql_example.rs (line 199)

async fn demonstrate_transactions() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("PostgreSQL transactions (BEGIN / COMMIT / ROLLBACK):");
    let db = Database::postgresql(PG_HOST, PG_PORT, PG_DB, PG_USER, PG_PASS).await?;

    // Commit
    let mut tx = db.begin_transaction().await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Dave".into(),
            40.into(),
        ],
    )
    .await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Frank".into(),
            35.into(),
        ],
    )
    .await?;
    tx.commit().await?;
    println!("  ✅ Transaction committed (2 users)");

    // Rollback
    let mut tx = db.begin_transaction().await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Eve".into(),
            45.into(),
        ],
    )
    .await?;
    tx.rollback().await?;
    println!("  ✅ Transaction rolled back (Eve not saved)");

    let result = db.query("SELECT COUNT(*) AS count FROM users", &[]).await?;
    println!("  ✅ Final user count: {:?}", result.rows[0].get("count"));

    db.close().await?;
    Ok(())
}

fn demonstrate_simplified_uuid() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("Generating UUIDs:");

    // Generate multiple UUIDs
    let uuid1 = SimpleUuid::new_v4();
    let uuid2 = SimpleUuid::new_v4();
    let uuid3 = SimpleUuid::new_v4();

    println!("  UUID 1: {}", uuid1);
    println!("  UUID 2: {}", uuid2);
    println!("  UUID 3: {}", uuid3);
    println!(
        "  All unique: {}",
        uuid1 != uuid2 && uuid2 != uuid3 && uuid1 != uuid3
    );

    println!();
    println!("ID Generator:");
    let generator = IdGenerator::new();
    let id1 = generator.generate();
    let id2 = generator.generate();

    println!("  ID 1: {}", id1);
    println!("  ID 2: {}", id2);
    println!(
        "  ID 3: {}",
        generator.with_prefix("user_").generate()
    );

    println!();
    println!("Simple IDs:");
    let simple_gen = IdGenerator::new().with_simple_id();
    println!("  Simple ID: {}", simple_gen.generate());
    println!(
        "  Prefixed: {}",
        simple_gen.with_prefix("order_").generate()
    );

    Ok(())
}

pub fn nil() -> Self

pub fn from_bytes(bytes: [u8; 16]) -> Self

pub fn as_bytes(&self) -> &[u8; 16]

pub fn to_string(&self) -> String

Examples found in repository

examples/postgresql_example.rs (line 199)

async fn demonstrate_transactions() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("PostgreSQL transactions (BEGIN / COMMIT / ROLLBACK):");
    let db = Database::postgresql(PG_HOST, PG_PORT, PG_DB, PG_USER, PG_PASS).await?;

    // Commit
    let mut tx = db.begin_transaction().await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Dave".into(),
            40.into(),
        ],
    )
    .await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Frank".into(),
            35.into(),
        ],
    )
    .await?;
    tx.commit().await?;
    println!("  ✅ Transaction committed (2 users)");

    // Rollback
    let mut tx = db.begin_transaction().await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Eve".into(),
            45.into(),
        ],
    )
    .await?;
    tx.rollback().await?;
    println!("  ✅ Transaction rolled back (Eve not saved)");

    let result = db.query("SELECT COUNT(*) AS count FROM users", &[]).await?;
    println!("  ✅ Final user count: {:?}", result.rows[0].get("count"));

    db.close().await?;
    Ok(())
}

pub fn is_nil(&self) -> bool

pub fn version(&self) -> u8

pub fn variant(&self) -> u8

Trait Implementations

impl Clone for SimpleUuid

fn clone(&self) -> SimpleUuid

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for SimpleUuid

impl Debug for SimpleUuid

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SimpleUuid

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SimpleUuid

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SimpleUuid

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for SimpleUuid

impl FromStr for SimpleUuid

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for SimpleUuid

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SimpleUuid

fn eq(&self, other: &SimpleUuid) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for SimpleUuid

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SimpleUuid