Enum qrlew::relation::Relation

pub enum Relation {
    Table(Table),
    Map(Map),
    Reduce(Reduce),
    Join(Join),
    Set(Set),
    Values(Values),
}

A Relation enum Inspired by: https://calcite.apache.org/ similar to: https://docs.rs/sqlparser/latest/sqlparser/ast/enum.TableFactor.html

Variants

Table(Table)

Map(Map)

Reduce(Reduce)

Join(Join)

Set(Set)

Values(Values)

Implementations

impl Relation

pub fn join_with_grouping_values( self, grouping_values: Relation ) -> Result<Relation>

We join the self Relation with the grouping_values Relation; We use a LEFT OUTER join for guaranteeing that all the possible grouping keys are released

impl Relation

pub fn privacy_unit_row(self) -> Self

Add the field for the row privacy

pub fn privacy_unit(self, referred_field: &str) -> Self

Add the field containing the privacy unit

pub fn with_referred_field( self, referring_id: String, referred_relation: Arc<Relation>, referred_id: String, referred_field: String, referred_field_name: String ) -> Relation

Add a field designated with a foreign relation and a field

pub fn with_field_path( self, relations: &Hierarchy<Arc<Relation>>, field_path: PrivacyUnitPath ) -> Relation

Add a field designated with a “field path”

impl Relation

pub fn dot<W: Write>(&self, w: &mut W, opts: &[&str]) -> Result<()>

Render the Relation to dot

impl Relation

pub fn with_name(self, name: String) -> Relation

Rename a Relation

pub fn identity_with_field(self, name: &str, expr: Expr) -> Relation

Add a field that derives from existing fields

pub fn identity_insert_field( self, index: usize, inserted_name: &str, inserted_expr: Expr ) -> Relation

Insert a field that derives from existing fields

pub fn with_field(self, name: &str, expr: Expr) -> Relation

Add a field that derives from input fields

pub fn insert_field( self, index: usize, inserted_name: &str, inserted_expr: Expr ) -> Relation

Insert a field that derives from input fields

pub fn filter_fields<P: Fn(&str) -> bool>(self, predicate: P) -> Relation

Filter fields

pub fn map_fields<F: Fn(&str, Expr) -> Expr>(self, f: F) -> Relation

Map fields

pub fn rename_fields<F: Fn(&str, &Expr) -> String>(self, f: F) -> Relation

Rename fields

pub fn sums_by_group(self, groups: &[&str], values: &[(&str, &str)]) -> Self

Returns a Relation::Reduce built from the current Relation.

• The group by columns are specified in the groups parameter.
• The aggregates are the sum of the columns, where each column is identified by the second element of the corresponding tuple in the values parameter.

Field names of the output Relation:

• If the aggregation is First, the field name is the name of the column.
• If the aggregation is Sum, the field name is the first element of the corresponding tuple in the values parameter.

pub fn l1_norms(self, entities: &str, groups: &[&str], values: &[&str]) -> Self

Compute L1 norms of the vectors formed by the group values for each entities

pub fn l2_norms(self, entities: &str, groups: &[&str], values: &[&str]) -> Self

Compute L2 norms of the vectors formed by the group values for each entities

pub fn scale( self, entities: &str, named_values: &[(&str, &str)], scale_factors: Relation ) -> Self

Returns a Relation with rescaled columns specified in values.

The resulting relation consists of:

• The original fields from the current relation.
• Rescaled columns, where each rescaled column is a product of the original column (specified by the second element of the corresponding tuple in values) and its scaling factor output by scale_factors Relation

pub fn l2_clipped_sums( self, entities: &str, groups: &[&str], named_value_clippings: &[(&str, &str, f64)] ) -> Self

For each coordinate, rescale the columns by 1 / greatest(1, norm_l2/C) where the l2 norm is computed for each elecment of vectors The self relation must contain the vectors, base and coordinates columns For the grouping columns, the name of the output fields is the name of the column For the clipping values, it is given by the first item of each tuple in value_clippings

pub fn add_gaussian_noise(self, name_sigmas: &[(&str, f64)]) -> Relation

Add gaussian noise of a given standard deviation to the given columns

pub fn add_clipped_gaussian_noise(self, name_sigmas: &[(&str, f64)]) -> Relation

Add gaussian noise of a given standard deviation to the given columns, while keeping the column min and max

pub fn filter(self, predicate: Expr) -> Relation

Returns a Relation::Map that inputs self and filter by predicate

pub fn filter_columns( self, columns: BTreeMap<&str, (Option<Value>, Option<Value>, Vec<Value>)> ) -> Relation

Returns a filtered Relation

Arguments

• columns: Vec<(column_name, minimal_value, maximal_value, possible_values)>

For example, filter_columns(vec![("my_col", Value::float(2.), Value::float(10.), vec![Value::integer(4), Value::integer(9)])]) returns a filtered Relation whose filter is equivalent to (my_col > 2.) and (my_col < 10) and (my_col in (4, 9)

pub fn poisson_sampling(self, proba: f64) -> Relation

Poisson sampling of a relation. It samples each line with probability 0 <= proba <= 1

pub fn sampling_without_replacements( self, rate: f64, rate_multiplier: f64 ) -> Relation

sampling without replacemnts. It creates a Map using self as an imput which applies WHERE RANDOM() < rate_multiplier * rate ORDER BY RANDOM() LIMIT rate*size and preserves the input schema fields. WHERE RANDOM() < rate_multiplier * rate is for optimization purposes

pub fn distinct(self) -> Relation

GROUP BY all the fields. This mimicks the sql DISTINCT in the SELECT clause.

pub fn distinct_aggregates( self, column: &str, group_by: Vec<&str>, aggregates: Vec<(&str, Aggregate)> ) -> Relation

Build a relation whose output fields are to the aggregations in aggregates applied on the UNIQUE values of the column column and grouped by the columns in group_by. If grouping_by is not empty, we order by the grouping expressions.

pub fn public_values_column(&self, col_name: &str) -> Result<Relation>

pub fn public_values(&self) -> Result<Relation>

pub fn cross_join(self, right: Self) -> Result<Relation>

Returns the cross join between self and right where the output names of the fields are conserved. This fails if one column name is contained in both relations

pub fn natural_inner_join(self, right: Self) -> Relation

Returns the outer join between self and right where the output names of the fields are conserved. The joining criteria is the equality of columns with the same name

impl Relation

pub fn inputs(&self) -> Vec<&Relation>

pub fn input_schemas(&self) -> Vec<&Schema>

pub fn input_fields(&self) -> Vec<&Field>

pub fn table() -> TableBuilder<WithoutSchema>

Build a table

pub fn map() -> MapBuilder<WithoutInput>

Build a map

pub fn reduce() -> ReduceBuilder<WithoutInput>

Build a reduce

pub fn join() -> JoinBuilder<WithoutInput, WithoutInput>

Build a reduce

pub fn set() -> SetBuilder<WithoutInput, WithoutInput>

Build a reduce

pub fn values() -> ValuesBuilder

Build a values

impl Relation

pub fn with_attributes<'a, Attributes: Clone>( &'a self, attributes: Attributes ) -> RelationWithAttributes<'a, Attributes>

Add attributes to Relation

pub fn with_default_attributes<'a, Attributes: Clone + Default>( &'a self ) -> RelationWithAttributes<'a, Attributes>

Add attributes to Relation

impl Relation

pub fn set_attributes<'a, Attributes: 'a + Clone + Debug + Hash + Eq, S: 'a + SetAttributesVisitor<'a, Attributes>>( &'a self, set_attributes_visitor: S ) -> RelationWithAttributes<'a, Attributes>

Take a relation and set rewriting rules

impl Relation

pub fn set_rewriting_rules<'a, S: 'a + SetRewritingRulesVisitor<'a>>( &'a self, set_rewriting_rules_visitor: S ) -> RelationWithRewritingRules<'a>

Take a relation and set rewriting rules

impl Relation

pub fn compose<'a>( &'a self, relations: &'a Hierarchy<Arc<Relation>> ) -> Relation

impl Relation

pub fn rewrite_as_privacy_unit_preserving<'a>( &'a self, relations: &'a Hierarchy<Arc<Relation>>, synthetic_data: Option<SyntheticData>, privacy_unit: PrivacyUnit, dp_parameters: DpParameters ) -> Result<RelationWithDpEvent>

Rewrite the query so that the privacy unit is tracked through the query.

pub fn rewrite_with_differential_privacy<'a>( &'a self, relations: &'a Hierarchy<Arc<Relation>>, synthetic_data: Option<SyntheticData>, privacy_unit: PrivacyUnit, dp_parameters: DpParameters ) -> Result<RelationWithDpEvent>

Rewrite the query so that it is differentially private.

impl Relation

pub fn uniform_adjustment<'a>(&'a self, weight: f64) -> RelationWithWeight

pub fn differenciated_adjustment<'a>( &'a self, relations: &'a Hierarchy<Arc<Relation>>, tables_and_weights: Vec<(Vec<String>, f64)> ) -> RelationWithWeight

pub fn uniform_poisson_sampling<'a>(&'a self, proba: f64) -> Relation

pub fn differenciated_poisson_sampling<'a>( &'a self, relations: &'a Hierarchy<Arc<Relation>>, tables_and_sampling_probabilities: Vec<(Vec<String>, f64)> ) -> Relation

pub fn uniform_sampling_without_replacements<'a>( &'a self, rate: f64, rate_multiplier: f64 ) -> Relation

Trait Implementations

impl<'a> Acceptor<'a> for Relation

Implement the Acceptor trait

fn dependencies(&'a self) -> Dependencies<'a, Self>

All the sub-objects to visit

fn accept<O: Clone, V: Visitor<'a, Self, O>>(&'a self, visitor: V) -> O

fn iter(&'a self) -> Iter<'a, Self>

fn iter_with<O: Clone, V: Visitor<'a, Self, O>>( &'a self, visitor: V ) -> IterWith<'a, O, Self, V>

impl Clone for Relation

fn clone(&self) -> Relation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DataTyped for Relation

fn data_type(&self) -> DataType

Return the DataType atached to the object

fn has_data_type(&self, data_type: &DataType) -> bool

Return whether the object has exactly the given type

fn is_contained_by(&self, data_type: &DataType) -> bool

Return whether the object has a type contained in the given type

impl Debug for Relation

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

Formats the value using the given formatter.

impl Display for Relation

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

Formats the value using the given formatter.

impl Dot for Relation

fn display_dot(&self) -> Result<()>

impl From<&Relation> for Query

Based on the FromRelationVisitor implement the From trait

fn from(value: &Relation) -> Self

Converts to this type from the input type.

impl From<DpRelation> for Relation

fn from(value: DpRelation) -> Self

Converts to this type from the input type.

impl From<Join> for Relation

fn from(v: Join) -> Self

Converts to this type from the input type.

impl From<Map> for Relation

fn from(v: Map) -> Self

Converts to this type from the input type.

impl From<PupRelation> for Relation

fn from(value: PupRelation) -> Self

Converts to this type from the input type.

impl From<Reduce> for Relation

fn from(v: Reduce) -> Self

Converts to this type from the input type.

impl From<Relation> for SDRelation

fn from(value: Relation) -> Self

Converts to this type from the input type.

impl From<SDRelation> for Relation

fn from(value: SDRelation) -> Self

Converts to this type from the input type.

impl From<Set> for Relation

fn from(v: Set) -> Self

Converts to this type from the input type.

impl From<Table> for Relation

fn from(v: Table) -> Self

Converts to this type from the input type.

impl From<Values> for Relation

fn from(v: Values) -> Self

Converts to this type from the input type.

impl Hash for Relation

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 Index<usize> for Relation

type Output = Field

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> IntoIterator for &'a Relation

type Item = &'a Relation

The type of the elements being iterated over.

type IntoIter = FilterMap<Iterator<'a, &'a Relation, Identity, Relation>, fn(_: (&'a Relation, State<&'a Relation>)) -> Option<&'a Relation>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Relation

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Ready<Relation> for JoinBuilder<WithInput, WithInput>

type Error = Error

fn try_build(self) -> Result<Relation>

Try to build

fn build(self) -> Output

Build and panic in case of error

impl Ready<Relation> for MapBuilder<WithInput>

type Error = Error

fn try_build(self) -> Result<Relation>

Try to build

fn build(self) -> Output

Build and panic in case of error

impl Ready<Relation> for ReduceBuilder<WithInput>

type Error = Error

fn try_build(self) -> Result<Relation>

Try to build

fn build(self) -> Output

Build and panic in case of error

impl Ready<Relation> for SetBuilder<WithInput, WithInput>

type Error = Error

fn try_build(self) -> Result<Relation>

Try to build

fn build(self) -> Output

Build and panic in case of error

impl Ready<Relation> for TableBuilder<WithSchema>

type Error = Error

fn try_build(self) -> Result<Relation>

Try to build

fn build(self) -> Output

Build and panic in case of error

impl Ready<Relation> for ValuesBuilder

type Error = Error

fn try_build(self) -> Result<Relation>

Try to build

fn build(self) -> Output

Build and panic in case of error

impl<'a, T: QueryToRelationTranslator + Copy + Clone> TryFrom<(QueryWithRelations<'a>, T)> for Relation

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: (QueryWithRelations<'a>, T)) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<QueryWithRelations<'a>> for Relation

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: QueryWithRelations<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relation> for Join

type Error = Error

The type returned in the event of a conversion error.

fn try_from(relation: Relation) -> Result<Self>

Performs the conversion.

impl TryFrom<Relation> for Map

type Error = Error

The type returned in the event of a conversion error.

fn try_from(relation: Relation) -> Result<Self>

Performs the conversion.

impl TryFrom<Relation> for PupRelation

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Relation) -> Result<Self>

Performs the conversion.

impl TryFrom<Relation> for Reduce

type Error = Error

The type returned in the event of a conversion error.

fn try_from(relation: Relation) -> Result<Self>

Performs the conversion.

impl TryFrom<Relation> for Set

type Error = Error

The type returned in the event of a conversion error.

fn try_from(relation: Relation) -> Result<Self>

Performs the conversion.

impl TryFrom<Relation> for Table

type Error = Error

The type returned in the event of a conversion error.

fn try_from(relation: Relation) -> Result<Self>

Performs the conversion.

impl TryFrom<Relation> for Values

type Error = Error

The type returned in the event of a conversion error.

fn try_from(relation: Relation) -> Result<Self>

Performs the conversion.

impl Variant for Relation

fn name(&self) -> &str

Return the name

fn schema(&self) -> &Schema

Return the Schema

fn size(&self) -> &Integer

Return the size bounds

fn inputs(&self) -> Vec<&Relation>

Return the inputs

fn input_hierarchy(&self) -> Hierarchy<&Relation>

Return the input hierarchy

fn fields(&self) -> Vec<&Field>

Return the fields

fn field_from_index(&self, index: usize) -> Result<&Field>

Access a field of the Relation by index

impl With<(&str, Expr)> for Relation

fn with(self, (name, expr): (&str, Expr)) -> Self

impl Eq for Relation

impl StructuralPartialEq for Relation