rocket_db_pools::diesel::prelude

Trait PgNetExpressionMethods

Source 
pub trait PgNetExpressionMethods: Sized + Expression {
    // Provided methods
    fn contains<T>(
        self,
        other: T,
    ) -> Grouped<ContainsNet<Self, <T as AsExpression<Inet>>::Expression>>
       where T: AsExpression<Inet> { ... }
    fn contains_or_eq<T>(
        self,
        other: T,
    ) -> Grouped<ContainsNetLoose<Self, <T as AsExpression<Inet>>::Expression>>
       where T: AsExpression<Inet> { ... }
    fn is_contained_by<T>(
        self,
        other: T,
    ) -> Grouped<IsContainedByNet<Self, <T as AsExpression<Inet>>::Expression>>
       where T: AsExpression<Inet> { ... }
    fn is_contained_by_or_eq<T>(
        self,
        other: T,
    ) -> Grouped<IsContainedByNetLoose<Self, <T as AsExpression<Inet>>::Expression>>
       where T: AsExpression<Inet> { ... }
    fn overlaps_with<T>(
        self,
        other: T,
    ) -> Grouped<OverlapsWith<Self, <T as AsExpression<Inet>>::Expression>>
       where T: AsExpression<Inet> { ... }
    fn and<T>(
        self,
        other: T,
    ) -> Grouped<AndNet<Self, <T as AsExpression<Inet>>::Expression>>
       where T: AsExpression<Inet> { ... }
    fn or<T>(
        self,
        other: T,
    ) -> Grouped<OrNet<Self, <T as AsExpression<Inet>>::Expression>>
       where T: AsExpression<Inet> { ... }
    fn diff<T>(
        self,
        other: T,
    ) -> Grouped<DifferenceNet<Self, <T as AsExpression<Inet>>::Expression>>
       where T: AsExpression<Inet> { ... }
}
Expand description

PostgreSQL specific methods present between CIDR/INET expressions

Provided Methods§

Source

fn contains<T>( self, other: T, ) -> Grouped<ContainsNet<Self, <T as AsExpression<Inet>>::Expression>>
where T: AsExpression<Inet>,

Creates a PostgreSQL >> expression.

This operator returns whether a subnet strictly contains another subnet or address.

§Example
diesel::insert_into(hosts)
    .values(vec![address.eq(IpNetwork::from_str("10.0.2.3/24").unwrap()),
                 address.eq(IpNetwork::from_str("10.0.3.4/23").unwrap())])
    .execute(conn)?;

let my_hosts = hosts.select(id)
    .filter(address.contains(IpNetwork::from_str("10.0.2.5").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![1, 2], my_hosts);

let my_hosts = hosts.select(id)
    .filter(address.contains(IpNetwork::from_str("10.0.2.5/24").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![2], my_hosts);

let my_hosts = hosts.select(id)
    .filter(address.contains(IpNetwork::from_str("10.0.3.31").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![2], my_hosts);
Source

fn contains_or_eq<T>( self, other: T, ) -> Grouped<ContainsNetLoose<Self, <T as AsExpression<Inet>>::Expression>>
where T: AsExpression<Inet>,

Creates a PostgreSQL >>= expression.

This operator returns whether a subnet contains or is equal to another subnet.

§Example
diesel::insert_into(hosts)
    .values(vec![address.eq(IpNetwork::from_str("10.0.2.3/24").unwrap()),
                 address.eq(IpNetwork::from_str("10.0.3.4/23").unwrap())])
    .execute(conn)?;

let my_hosts = hosts.select(id)
    .filter(address.contains_or_eq(IpNetwork::from_str("10.0.2.5").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![1, 2], my_hosts);

let my_hosts = hosts.select(id)
    .filter(address.contains_or_eq(IpNetwork::from_str("10.0.2.5/24").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![1, 2], my_hosts);

let my_hosts = hosts.select(id)
    .filter(address.contains_or_eq(IpNetwork::from_str("10.0.3.31").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![2], my_hosts);
Source

fn is_contained_by<T>( self, other: T, ) -> Grouped<IsContainedByNet<Self, <T as AsExpression<Inet>>::Expression>>
where T: AsExpression<Inet>,

Creates a PostgreSQL << expression.

This operator returns whether a subnet or address is strictly contained by another subnet.

§Example
diesel::insert_into(hosts)
    .values(vec![address.eq(IpNetwork::from_str("10.0.2.3/24").unwrap()),
                 address.eq(IpNetwork::from_str("10.0.3.4/23").unwrap())])
    .execute(conn)?;

let my_hosts = hosts.select(id)
    .filter(address.is_contained_by(IpNetwork::from_str("10.0.2.5/24").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(my_hosts.len(), 0);

let my_hosts = hosts.select(id)
    .filter(address.is_contained_by(IpNetwork::from_str("10.0.3.31/23").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![1], my_hosts);

let my_hosts = hosts.select(id)
    .filter(address.is_contained_by(IpNetwork::from_str("10.0.3.31/22").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![1, 2], my_hosts);
Source

fn is_contained_by_or_eq<T>( self, other: T, ) -> Grouped<IsContainedByNetLoose<Self, <T as AsExpression<Inet>>::Expression>>
where T: AsExpression<Inet>,

Creates a PostgreSQL >>= expression.

This operator returns whether a subnet is contained by or equal to another subnet.

§Example
diesel::insert_into(hosts)
    .values(vec![address.eq(IpNetwork::from_str("10.0.2.3/24").unwrap()),
                 address.eq(IpNetwork::from_str("10.0.3.4/23").unwrap())])
    .execute(conn)?;

let my_hosts = hosts.select(id)
    .filter(address.is_contained_by_or_eq(IpNetwork::from_str("10.0.2.5/24").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![1], my_hosts);

let my_hosts = hosts.select(id)
    .filter(address.is_contained_by_or_eq(IpNetwork::from_str("10.0.3.31/23").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![1, 2], my_hosts);
Source

fn overlaps_with<T>( self, other: T, ) -> Grouped<OverlapsWith<Self, <T as AsExpression<Inet>>::Expression>>
where T: AsExpression<Inet>,

Creates a PostgreSQL && expression.

This operator returns whether a subnet contains or is contained by another subnet.

§Example
diesel::insert_into(hosts)
    .values(vec![address.eq(IpNetwork::from_str("10.0.2.3/24").unwrap()),
                 address.eq(IpNetwork::from_str("10.0.3.4/23").unwrap())])
    .execute(conn)?;

let my_hosts = hosts.select(id)
    .filter(address.overlaps_with(IpNetwork::from_str("10.0.2.5/24").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![1, 2], my_hosts);

let my_hosts = hosts.select(id)
    .filter(address.overlaps_with(IpNetwork::from_str("10.0.3.31/24").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![2], my_hosts);

let my_hosts = hosts.select(id)
    .filter(address.overlaps_with(IpNetwork::from_str("10.0.3.31/23").unwrap()))
    .load::<i32>(conn)?;
assert_eq!(vec![1, 2], my_hosts);
Source

fn and<T>( self, other: T, ) -> Grouped<AndNet<Self, <T as AsExpression<Inet>>::Expression>>
where T: AsExpression<Inet>,

Creates a PostgreSQL & expression.

This operator computes the bitwise AND between two network addresses.

§Example
diesel::insert_into(hosts)
    .values(vec![address.eq(IpNetwork::from_str("10.0.2.3").unwrap())])
    .execute(conn)?;

let addr = hosts
    .select(address.and(IpNetwork::from_str("0.0.0.255").unwrap()))
    .first::<IpNetwork>(conn)?;
assert_eq!(addr, IpNetwork::from_str("0.0.0.3").unwrap());
Source

fn or<T>( self, other: T, ) -> Grouped<OrNet<Self, <T as AsExpression<Inet>>::Expression>>
where T: AsExpression<Inet>,

Creates a PostgreSQL | expression.

This operator computes the bitwise OR between two network addresses.

§Example
diesel::insert_into(hosts)
    .values(vec![address.eq(IpNetwork::from_str("10.0.2.3").unwrap())])
    .execute(conn)?;

let addr = hosts
    .select(address.or(IpNetwork::from_str("0.0.0.255").unwrap()))
    .first::<IpNetwork>(conn)?;
assert_eq!(addr, IpNetwork::from_str("10.0.2.255").unwrap());
Source

fn diff<T>( self, other: T, ) -> Grouped<DifferenceNet<Self, <T as AsExpression<Inet>>::Expression>>
where T: AsExpression<Inet>,

Creates a PostgreSQL - expression.

This operator subtracts an address from an address to compute the distance between the two

§Example
diesel::insert_into(hosts)
    .values(vec![address.eq(IpNetwork::from_str("10.0.2.53").unwrap())])
    .execute(conn)?;

let offset = hosts
    .select(address.diff(IpNetwork::from_str("10.0.2.42").unwrap()))
    .first::<i64>(conn)?;
assert_eq!(offset, 11);

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§

Source§

impl<T> PgNetExpressionMethods for T
where T: Expression, <T as Expression>::SqlType: InetOrCidr,