sf 0.1.1

Simple snowflake like unique IDs generator.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use crate::id::Id;
use diesel::backend::Backend;
use diesel::deserialize::FromSql;
use diesel::expression::AsExpression;
use diesel::serialize::{IsNull, Output, ToSql};
use diesel::sql_types::{BigInt, Nullable};
use std::error::Error;
use std::io::Write;

type DieselError = Box<Error + Send + Sync>;

#[derive(FromSqlRow, SqlType)]
#[diesel(foreign_derive)]
#[allow(dead_code)]
struct Proxy(Id);

impl AsExpression<BigInt> for Id {
    type Expression = <i64 as AsExpression<BigInt>>::Expression;
    fn as_expression(self) -> Self::Expression {
        <i64 as AsExpression<BigInt>>::as_expression(Into::<i64>::into(self))
    }
}

impl<'a> AsExpression<BigInt> for &'a Id {
    type Expression = <i64 as AsExpression<BigInt>>::Expression;
    fn as_expression(self) -> Self::Expression {
        <i64 as AsExpression<BigInt>>::as_expression(Into::<i64>::into(self))
    }
}

impl AsExpression<Nullable<BigInt>> for Id {
    type Expression = <i64 as AsExpression<Nullable<BigInt>>>::Expression;
    fn as_expression(self) -> Self::Expression {
        <i64 as AsExpression<Nullable<BigInt>>>::as_expression(
            Into::<i64>::into(self),
        )
    }
}

impl<'a> AsExpression<Nullable<BigInt>> for &'a Id {
    type Expression = <i64 as AsExpression<Nullable<BigInt>>>::Expression;
    fn as_expression(self) -> Self::Expression {
        <i64 as AsExpression<Nullable<BigInt>>>::as_expression(
            Into::<i64>::into(self),
        )
    }
}

impl<DB: Backend<RawValue = [u8]>> FromSql<BigInt, DB> for Id {
    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, DieselError> {
        <i64 as FromSql<_, DB>>::from_sql(bytes)
            .and_then(|i| Ok(Into::<Id>::into(i)))
    }
}

impl<DB: Backend> ToSql<BigInt, DB> for Id {
    fn to_sql<W: Write>(
        &self,
        out: &mut Output<W, DB>,
    ) -> Result<IsNull, DieselError> {
        let i: i64 = self.into();
        <i64 as ToSql<BigInt, DB>>::to_sql(&i, out)
    }
}