mbutrovich commented on code in PR #3724: URL: https://github.com/apache/iceberg-rust/pull/3724#discussion_r4621321844
########## crates/iceberg/src/arrow/manifest_filter.rs: ########## @@ -0,0 +1,1245 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Filtering manifests read into Arrow by a scan's row filter. + +use std::collections::HashMap; +use std::sync::Arc; + +use arrow_arith::boolean::{and, is_null, not, or}; +use arrow_array::cast::AsArray; +use arrow_array::types::Int32Type; +use arrow_array::{ + Array, ArrayRef, BinaryArray, BooleanArray, Decimal128Array, Float32Array, Float64Array, + Int32Array, Int64Array, RecordBatch, Scalar, +}; +use arrow_buffer::{BooleanBuffer, BooleanBufferBuilder}; +use arrow_ord::cmp::{gt, gt_eq, lt, lt_eq}; +use arrow_schema::ArrowError; +use arrow_select::take::take; +use fnv::FnvHashSet; +use typed_builder::TypedBuilder; + +use crate::error::invalid_data; +use crate::expr::visitors::bound_predicate_visitor::{BoundPredicateVisitor, visit}; +use crate::expr::visitors::inclusive_projection::project_partition_filter; +use crate::expr::visitors::manifest_evaluator::IN_PREDICATE_LIMIT; +use crate::expr::{Bind, BoundPredicate, BoundReference, Predicate}; +use crate::spec::decimal_utils::i128_from_be_bytes; +use crate::spec::{Datum, PartitionSpecRef, PrimitiveLiteral, PrimitiveType, SchemaRef}; +use crate::{Error, ErrorKind, Result}; + +/// Evaluates a row filter against batches from +/// [`read_manifest_list`](crate::arrow::read_manifest_list), with the same +/// results as the manifest pruning in [`TableScan`](crate::scan::TableScan). +/// +/// # Example +/// +/// ``` +/// use std::sync::Arc; +/// +/// use iceberg::arrow::{ManifestFilter, read_manifest_list}; +/// use iceberg::expr::Reference; +/// use iceberg::spec::{Datum, NestedField, PartitionSpec, PrimitiveType, Schema, Type}; +/// +/// let schema = Arc::new( +/// Schema::builder() +/// .with_fields(vec![ +/// NestedField::required(1, "id", Type::Primitive(PrimitiveType::Long)).into(), +/// ]) +/// .build()?, +/// ); +/// let filter = ManifestFilter::builder() +/// .schema(schema.clone()) +/// .partition_specs(vec![Arc::new(PartitionSpec::unpartition_spec())]) +/// .filter(Reference::new("id").equal_to(Datum::long(1))) +/// .build()?; +/// +/// let bytes = std::fs::read(concat!( +/// env!("CARGO_MANIFEST_DIR"), +/// "/testdata/manifests_lists/manifest-list-v2-2.avro" +/// ))?; +/// for batch in read_manifest_list(&bytes)? { +/// // An unpartitioned manifest may contain any row. +/// let mask = filter.manifest_list_mask(&batch?)?; +/// assert!(mask.values().iter().all(|might_match| might_match)); +/// } +/// # Ok::<(), Box<dyn std::error::Error>>(()) +/// ``` +#[derive(Debug, TypedBuilder)] +#[builder(build_method(into = Result<ManifestFilter>))] +pub struct ManifestFilter { + schema: SchemaRef, + partition_specs: Vec<PartitionSpecRef>, + filter: Predicate, + #[builder(default = true)] + case_sensitive: bool, + /// The filter projected to each spec's partition values, by spec ID. + #[builder(setter(skip), default)] + partition_filters: HashMap<i32, PartitionFilter>, +} + +#[derive(Debug)] +struct PartitionFilter { + field_count: usize, + filter: BoundPredicate, +} + +impl From<ManifestFilter> for Result<ManifestFilter> { + fn from(mut manifest_filter: ManifestFilter) -> Self { + // `TableScanBuilder::with_filter` rewrites NOT the same way, and the + // projection rejects NOT. + let filter = manifest_filter.filter.clone().rewrite_not().bind( + manifest_filter.schema.clone(), + manifest_filter.case_sensitive, + )?; + for spec in &manifest_filter.partition_specs { + let partition_filter = PartitionFilter { + field_count: spec.fields().len(), + // A spec that references a dropped source column can't prune, as + // in `TableScan`. + filter: project_partition_filter( + &manifest_filter.schema, + spec, + &filter, + manifest_filter.case_sensitive, + )? + .unwrap_or(BoundPredicate::AlwaysTrue), + }; + let previous = manifest_filter + .partition_filters + .insert(spec.spec_id(), partition_filter); + if previous.is_some() { + return Err(invalid_data!( + "duplicate partition spec ID {}", + spec.spec_id() + )); + } + } + Ok(manifest_filter) + } +} + +impl ManifestFilter { + /// Returns true for each manifest in `batch` that may contain rows matching + /// the filter, judged by its partition summaries. + /// + /// # Errors + /// + /// Returns an error if `batch` doesn't have the schema that + /// [`read_manifest_list`](crate::arrow::read_manifest_list) returns, if a + /// manifest's partition spec isn't one the filter was built with, or if its + /// partition summaries don't match the spec. + pub fn manifest_list_mask(&self, batch: &RecordBatch) -> Result<BooleanArray> { + let spec_ids = column(batch, "partition_spec_id")? + .as_primitive_opt::<Int32Type>() + .ok_or_else(|| invalid_data!("partition_spec_id is not an int column"))?; + let partitions = column(batch, "partitions")? + .as_list_opt::<i32>() + .ok_or_else(|| invalid_data!("partitions is not a list column"))?; + let summaries = SummaryColumns::try_new(partitions.values())?; + + // A manifest without partition summaries may contain any row, as in + // `ManifestEvaluator`. + let mut rows_by_spec: HashMap<i32, Vec<usize>> = HashMap::new(); + for row in 0..batch.num_rows() { + if partitions.is_valid(row) && partitions.value_length(row) > 0 { + if spec_ids.is_null(row) { + return Err(invalid_data!("manifest has no partition_spec_id")); + } + rows_by_spec + .entry(spec_ids.value(row)) + .or_default() + .push(row); + } + } + + let mut mask = BooleanBufferBuilder::new(batch.num_rows()); + mask.append_n(batch.num_rows(), true); + for (spec_id, rows) in rows_by_spec { + let partition_filter = self + .partition_filters + .get(&spec_id) + .ok_or_else(|| invalid_data!("no partition spec with ID {spec_id}"))?; + let mut starts = Vec::with_capacity(rows.len()); + for &row in &rows { + let length = usize::try_from(partitions.value_length(row))?; + if length != partition_filter.field_count { + return Err(invalid_data!( + "manifest has {length} partition summaries but partition spec {spec_id} has {} fields", + partition_filter.field_count + )); + } + starts.push(partitions.value_offsets()[row]); + } + if matches!(partition_filter.filter, BoundPredicate::AlwaysTrue) { + continue; + } + let mut visitor = SummaryVisitor { + summaries: &summaries, + starts, + fields: HashMap::new(), + }; + let spec_mask = visit(&mut visitor, &partition_filter.filter)?; + for (index, row) in rows.into_iter().enumerate() { + mask.set_bit(row, spec_mask.value(index)); + } + } + Ok(BooleanArray::new(mask.finish(), None)) + } +} + +fn column<'a>(batch: &'a RecordBatch, name: &str) -> Result<&'a ArrayRef> { + batch + .column_by_name(name) + .ok_or_else(|| invalid_data!("manifest list batch has no {name} column")) +} + +/// The `field_summary` columns of a manifest list's `partitions`, with one row +/// per summary. +struct SummaryColumns<'a> { + contains_null: &'a BooleanArray, + contains_nan: &'a BooleanArray, + lower_bound: &'a BinaryArray, + upper_bound: &'a BinaryArray, +} + +impl<'a> SummaryColumns<'a> { + fn try_new(summaries: &'a ArrayRef) -> Result<Self> { + let summaries = summaries + .as_struct_opt() + .ok_or_else(|| invalid_data!("partitions is not a list of structs"))?; + let field = |name: &str| { + summaries + .column_by_name(name) + .ok_or_else(|| invalid_data!("partition summaries have no {name} field")) + }; + let boolean = |name: &str| { + field(name)? + .as_boolean_opt() + .ok_or_else(|| invalid_data!("partition summary {name} is not a boolean")) + }; + let binary = |name: &str| { + field(name)? + .as_binary_opt::<i32>() + .ok_or_else(|| invalid_data!("partition summary {name} is not binary")) + }; + Ok(Self { + contains_null: boolean("contains_null")?, + contains_nan: boolean("contains_nan")?, + lower_bound: binary("lower_bound")?, + upper_bound: binary("upper_bound")?, + }) + } +} + +/// One partition field's summaries for the rows being evaluated. +struct FieldSummaries { + contains_null: BooleanArray, + /// Null where the manifest list doesn't say. + contains_nan: BooleanArray, + lower_bound: BinaryArray, + upper_bound: BinaryArray, + /// The bounds decoded into arrays that order values the way `Datum` does. + lower: ArrayRef, + upper: ArrayRef, + is_floating: bool, +} + +impl FieldSummaries { + /// Whether every partition value is null, as in `ManifestEvaluator`. + fn are_all_null(&self) -> Result<BooleanArray> { + let all_null = and(&self.contains_null, &is_null(&self.lower_bound)?)?; + if self.is_floating { + // NaN values have no bounds either, so a float field is all null + // only if it's known to contain no NaN. + let no_nan = null_as_false(¬(&self.contains_nan)?); + Ok(and(&all_null, &no_nan)?) + } else { + Ok(all_null) + } + } +} + +/// Evaluates a partition filter over the summaries of the manifests whose +/// summaries start at `starts`. +struct SummaryVisitor<'a> { + summaries: &'a SummaryColumns<'a>, + starts: Vec<i32>, + /// Summaries by partition field position, taken when a predicate first + /// references the field. + fields: HashMap<usize, FieldSummaries>, +} + +impl SummaryVisitor<'_> { + fn field(&mut self, reference: &BoundReference) -> Result<&FieldSummaries> { + let position = reference.accessor().position(); + if !self.fields.contains_key(&position) { + let field_type = reference + .field() + .field_type + .as_primitive_type() + .ok_or_else(|| invalid_data!("partition field is not a primitive type"))?; + let offset = i32::try_from(position)?; + let indices = Int32Array::from( + self.starts + .iter() + .map(|start| { + start + .checked_add(offset) + .ok_or_else(|| invalid_data!("partition summary index overflows")) + }) + .collect::<Result<Vec<_>>>()?, + ); + let take_boolean = |array: &BooleanArray| -> Result<BooleanArray> { + Ok(take(array, &indices, None)?.as_boolean().clone()) + }; + let take_binary = |array: &BinaryArray| -> Result<BinaryArray> { + Ok(take(array, &indices, None)?.as_binary::<i32>().clone()) + }; + let lower_bound = take_binary(self.summaries.lower_bound)?; + let upper_bound = take_binary(self.summaries.upper_bound)?; + let summaries = FieldSummaries { + contains_null: null_as_false(&take_boolean(self.summaries.contains_null)?), + contains_nan: take_boolean(self.summaries.contains_nan)?, + lower: decode_bounds(&lower_bound, field_type)?, + upper: decode_bounds(&upper_bound, field_type)?, + lower_bound, + upper_bound, + is_floating: matches!(field_type, PrimitiveType::Float | PrimitiveType::Double), + }; + self.fields.insert(position, summaries); + } + Ok(&self.fields[&position]) + } + + fn constant(&self, value: bool) -> BooleanArray { + let values = if value { + BooleanBuffer::new_set(self.starts.len()) + } else { + BooleanBuffer::new_unset(self.starts.len()) + }; + BooleanArray::new(values, None) + } +} + +impl BoundPredicateVisitor for SummaryVisitor<'_> { + type T = BooleanArray; + + fn always_true(&mut self) -> Result<BooleanArray> { + Ok(self.constant(true)) + } + + fn always_false(&mut self) -> Result<BooleanArray> { + Ok(self.constant(false)) + } + + fn and(&mut self, lhs: BooleanArray, rhs: BooleanArray) -> Result<BooleanArray> { + Ok(and(&lhs, &rhs)?) + } + + fn or(&mut self, lhs: BooleanArray, rhs: BooleanArray) -> Result<BooleanArray> { + Ok(or(&lhs, &rhs)?) + } + + fn not(&mut self, _inner: BooleanArray) -> Result<BooleanArray> { + Err(Error::new( + ErrorKind::Unexpected, + "not operator is not supported in partition filter", + )) + } + + fn is_null(&mut self, reference: &BoundReference, _: &BoundPredicate) -> Result<BooleanArray> { + Ok(self.field(reference)?.contains_null.clone()) + } + + fn not_null(&mut self, reference: &BoundReference, _: &BoundPredicate) -> Result<BooleanArray> { + Ok(not(&self.field(reference)?.are_all_null()?)?) + } + + fn is_nan(&mut self, reference: &BoundReference, _: &BoundPredicate) -> Result<BooleanArray> { + let field = self.field(reference)?; + let no_nan = null_as_false(¬(&field.contains_nan)?); + Ok(not(&or(&no_nan, &field.are_all_null()?)?)?) + } + + fn not_nan(&mut self, reference: &BoundReference, _: &BoundPredicate) -> Result<BooleanArray> { + // A field is all NaN if it contains NaN but no null and has no bounds. + let field = self.field(reference)?; + let all_nan = and( + &and( + &null_as_false(&field.contains_nan), + ¬(&field.contains_null)?, + )?, + &is_null(&field.lower_bound)?, + )?; + Ok(not(&all_nan)?) + } + + fn less_than( + &mut self, + reference: &BoundReference, + datum: &Datum, + _: &BoundPredicate, + ) -> Result<BooleanArray> { + let literal = literal_scalar(datum)?; + compare(lt, &self.field(reference)?.lower, &literal) + } + + fn less_than_or_eq( + &mut self, + reference: &BoundReference, + datum: &Datum, + _: &BoundPredicate, + ) -> Result<BooleanArray> { + let literal = literal_scalar(datum)?; + compare(lt_eq, &self.field(reference)?.lower, &literal) + } + + fn greater_than( + &mut self, + reference: &BoundReference, + datum: &Datum, + _: &BoundPredicate, + ) -> Result<BooleanArray> { + let literal = literal_scalar(datum)?; + compare(gt, &self.field(reference)?.upper, &literal) + } + + fn greater_than_or_eq( + &mut self, + reference: &BoundReference, + datum: &Datum, + _: &BoundPredicate, + ) -> Result<BooleanArray> { + let literal = literal_scalar(datum)?; + compare(gt_eq, &self.field(reference)?.upper, &literal) + } + + fn eq( + &mut self, + reference: &BoundReference, + datum: &Datum, + _: &BoundPredicate, + ) -> Result<BooleanArray> { + let literal = literal_scalar(datum)?; + let field = self.field(reference)?; + Ok(and( + &compare(lt_eq, &field.lower, &literal)?, + &compare(gt_eq, &field.upper, &literal)?, + )?) + } + + fn not_eq( + &mut self, + _: &BoundReference, + _: &Datum, + _: &BoundPredicate, + ) -> Result<BooleanArray> { + // The bounds aren't necessarily values in the manifest, so they can't + // rule out a value other than the literal. + Ok(self.constant(true)) + } + + fn starts_with( + &mut self, + reference: &BoundReference, + datum: &Datum, + _: &BoundPredicate, + ) -> Result<BooleanArray> { + let prefix = string_literal(datum, "Cannot perform starts_with on non-string value")?; + let field = self.field(reference)?; + // Matches `ManifestEvaluator`, which compares the prefix with each + // bound truncated to the prefix length. + let values = BooleanBuffer::collect_bool(field.lower_bound.len(), |row| { + let (Some(lower), Some(upper)) = ( + field + .lower_bound + .is_valid(row) + .then(|| field.lower_bound.value(row)), + field + .upper_bound + .is_valid(row) + .then(|| field.upper_bound.value(row)), + ) else { + return false; + }; + prefix >= &lower[..lower.len().min(prefix.len())] + && prefix <= &upper[..upper.len().min(prefix.len())] + }); + Ok(BooleanArray::new(values, None)) + } + + fn not_starts_with( + &mut self, + reference: &BoundReference, + datum: &Datum, + _: &BoundPredicate, + ) -> Result<BooleanArray> { + let prefix = string_literal(datum, "Cannot perform not_starts_with on non-string value")?; + let field = self.field(reference)?; + // Every value starts with the prefix only if both bounds do. + let values = BooleanBuffer::collect_bool(field.lower_bound.len(), |row| { + if field.contains_null.value(row) + || field.lower_bound.is_null(row) + || field.upper_bound.is_null(row) + { + return true; + } + let both_start_with_prefix = field.lower_bound.value(row).starts_with(prefix) + && field.upper_bound.value(row).starts_with(prefix); + !both_start_with_prefix + }); + Ok(BooleanArray::new(values, None)) + } + + fn r#in( + &mut self, + reference: &BoundReference, + literals: &FnvHashSet<Datum>, + _: &BoundPredicate, + ) -> Result<BooleanArray> { + let field = self.field(reference)?; + // A missing lower bound means every value is null or NaN. + let has_lower = not(&is_null(&field.lower_bound)?)?; + if literals.len() > IN_PREDICATE_LIMIT { + return Ok(has_lower); + } + let no_upper = is_null(&field.upper_bound)?; + let mut any_inside = BooleanArray::new(BooleanBuffer::new_unset(has_lower.len()), None); + for literal in literals { + let literal = literal_scalar(literal)?; + let inside = and( + &compare(lt_eq, &field.lower, &literal)?, + &or(&no_upper, &compare(gt_eq, &field.upper, &literal)?)?, + )?; + any_inside = or(&any_inside, &inside)?; + } + Ok(and(&has_lower, &any_inside)?) + } + + fn not_in( + &mut self, + _: &BoundReference, + _: &FnvHashSet<Datum>, + _: &BoundPredicate, + ) -> Result<BooleanArray> { + // The bounds aren't necessarily values in the manifest, so they can't + // rule out values other than the literals. + Ok(self.constant(true)) + } +} + +/// Compares `bounds` with `literal`, with false where a bound is missing. +fn compare( + op: fn( + &dyn arrow_array::Datum, + &dyn arrow_array::Datum, + ) -> std::result::Result<BooleanArray, ArrowError>, + bounds: &ArrayRef, + literal: &Scalar<ArrayRef>, +) -> Result<BooleanArray> { + Ok(null_as_false(&op(bounds, literal)?)) +} + +fn null_as_false(array: &BooleanArray) -> BooleanArray { + match array.nulls() { + Some(nulls) => BooleanArray::new(array.values() & nulls.inner(), None), + None => array.clone(), + } +} + +fn string_literal<'a>(datum: &'a Datum, message: &str) -> Result<&'a [u8]> { + match datum.literal() { + PrimitiveLiteral::String(value) => Ok(value.as_bytes()), + _ => Err(Error::new(ErrorKind::Unexpected, message)), + } +} + +/// Decodes binary single-value serialized bounds the way +/// `Datum::try_from_bytes` does, into an array that Arrow orders the way +/// `Datum` does. Both order floats by IEEE 754 `totalOrder`. Strings, binary, +/// fixed, and uuid compare bytewise, so their bounds stay as they are. +fn decode_bounds(bounds: &BinaryArray, field_type: &PrimitiveType) -> Result<ArrayRef> { + fn decode<T>( + bounds: &BinaryArray, + decode: impl Fn(&[u8]) -> Result<T>, + ) -> Result<Vec<Option<T>>> { + bounds + .iter() + .map(|bound| bound.map(&decode).transpose()) + .collect() + } + + let array: ArrayRef = match field_type { + PrimitiveType::Boolean => { + Arc::new(BooleanArray::from(decode( + bounds, + |bytes| Ok(bytes != [0]), + )?)) + } + PrimitiveType::Int | PrimitiveType::Date => { + Arc::new(Int32Array::from(decode(bounds, |bytes| { + Ok(i32::from_le_bytes(bytes.try_into()?)) + })?)) + } + PrimitiveType::Long => Arc::new(Int64Array::from(decode(bounds, |bytes| { + // A 4-byte bound was written before the field was promoted from int. + Ok(match bytes.len() { + 4 => i64::from(i32::from_le_bytes(bytes.try_into()?)), + _ => i64::from_le_bytes(bytes.try_into()?), + }) + })?)), + PrimitiveType::Time + | PrimitiveType::Timestamp + | PrimitiveType::Timestamptz + | PrimitiveType::TimestampNs + | PrimitiveType::TimestamptzNs => Arc::new(Int64Array::from(decode(bounds, |bytes| { + Ok(i64::from_le_bytes(bytes.try_into()?)) + })?)), + PrimitiveType::Float => Arc::new(Float32Array::from(decode(bounds, |bytes| { + Ok(f32::from_le_bytes(bytes.try_into()?)) + })?)), + PrimitiveType::Double => Arc::new(Float64Array::from(decode(bounds, |bytes| { + // A 4-byte bound was written before the field was promoted from float. + Ok(match bytes.len() { + 4 => f64::from(f32::from_le_bytes(bytes.try_into()?)), + _ => f64::from_le_bytes(bytes.try_into()?), + }) + })?)), + // The default precision and scale are safe because only the order of + // unscaled values matters, and binding gives the literal the field's + // scale. `literal_scalar` uses the same default, so the types match. + PrimitiveType::Decimal { .. } => { + Arc::new(Decimal128Array::from(decode(bounds, |bytes| { + i128_from_be_bytes(bytes) + .ok_or_else(|| invalid_data!("Can't convert bytes to i128: {bytes:?}")) + })?)) + } + PrimitiveType::String + | PrimitiveType::Uuid + | PrimitiveType::Fixed(_) + | PrimitiveType::Binary => Arc::new(bounds.clone()), + PrimitiveType::Unknown | PrimitiveType::Geometry(_) | PrimitiveType::Geography(_) => { + return Err(Error::new( + ErrorKind::FeatureUnsupported, + format!("Partition summaries of type {field_type} are not supported"), + )); + } + }; + Ok(array) +} + +/// Converts a literal to a one-element array of the type `decode_bounds` +/// returns for the literal's type. +fn literal_scalar(datum: &Datum) -> Result<Scalar<ArrayRef>> { + let array: ArrayRef = match datum.literal() { + PrimitiveLiteral::Boolean(value) => Arc::new(BooleanArray::from(vec![*value])), + PrimitiveLiteral::Int(value) => Arc::new(Int32Array::from(vec![*value])), + PrimitiveLiteral::Long(value) => Arc::new(Int64Array::from(vec![*value])), + PrimitiveLiteral::Float(value) => Arc::new(Float32Array::from(vec![value.into_inner()])), + PrimitiveLiteral::Double(value) => Arc::new(Float64Array::from(vec![value.into_inner()])), + PrimitiveLiteral::Int128(value) => Arc::new(Decimal128Array::from(vec![*value])), + PrimitiveLiteral::String(value) => Arc::new(BinaryArray::from_vec(vec![value.as_bytes()])), + PrimitiveLiteral::Binary(value) => Arc::new(BinaryArray::from_vec(vec![value.as_slice()])), + PrimitiveLiteral::UInt128(value) => { + // Uuid bounds are big-endian, which orders them like the integer. + Arc::new(BinaryArray::from_vec(vec![value.to_be_bytes().as_slice()])) + } + PrimitiveLiteral::AboveMax | PrimitiveLiteral::BelowMin => { Review Comment: String bounds aren't checked for valid UTF-8 here, unlike [`Datum::try_from_bytes`](https://github.com/apache/iceberg-rust/blob/641f59049e0aefad0c60e19915ecdb54933e002f/crates/iceberg/src/spec/values/datum.rs#L438-L440). The comparisons only need the bytes, and the [expressions spec](https://github.com/apache/iceberg/blob/13135ae08148b010276fc9c5eb1cfbf2e6e8289c/format/expressions-spec.md?plain=1#L165) orders strings by their UTF-8 bytes. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected] --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
