Struct firestore_structured_query::FieldPath

source · 
pub struct FieldPath(/* private fields */);
Expand description

A Firestore Field Path.

https://firebase.google.com/docs/firestore/quotas#collections_documents_and_fields

  • Must separate field names with a single period (.)
  • May be passed as a dot-delimited (.) string of segments where each segment is either a simple field name or a quoted field name (defined below).

A simple field name is one where all of the following are true:

  • Contains only the characters a-z, A-Z, 0-9, and underscore (_)
  • Does not start with 0-9

A quoted field name starts and ends with the backtick character (`). For example, foo.`x&y` refers to the x&y field nested under the foo field. To construct a field name with the backtick character, escape the backtick character with the backslash character (\). For convenience, you can avoid quoted field names by passing the field path as a FieldPath object (for example, see JavaScript FieldPath).

§Examples

use firestore_structured_query::FieldPath;
use google_api_proto::google::firestore::v1::structured_query;

let field_path1 = FieldPath::raw("field1");
assert_eq!(
    structured_query::FieldReference::from(field_path1),
    structured_query::FieldReference {
        field_path: "field1".to_string(),
    }
);

Implementations§

source§

impl FieldPath

source

pub fn new<I>(field_names: I) -> Self
where I: IntoIterator, I::Item: Into<String>,

Creates a new field path.

§Examples
use firestore_structured_query::FieldPath;
use google_api_proto::google::firestore::v1::structured_query;

// simple field name
let field_path1 = FieldPath::new(["field1"]);
assert_eq!(
    structured_query::FieldReference::from(field_path1),
    structured_query::FieldReference {
        field_path: "field1".to_string(),
    }
);
let field_path2 = FieldPath::new(["field1", "field2"]);
assert_eq!(
    structured_query::FieldReference::from(field_path2),
    structured_query::FieldReference {
        field_path: "field1.field2".to_string(),
    }
);
let field_path3 = FieldPath::new(["foo", "x&y"]);
assert_eq!(
    structured_query::FieldReference::from(field_path3),
    structured_query::FieldReference {
        field_path: "foo.`x&y`".to_string(),
    }
);
let field_path4 = FieldPath::new(["a`b", r#"a\b"#]);
assert_eq!(
    structured_query::FieldReference::from(field_path4),
    structured_query::FieldReference {
        field_path: r#"`a\`b`.`a\\b`"#.to_string(),
    }
);
source

pub fn raw<S>(field_path: S) -> Self
where S: Into<String>,

Creates a new field path without escaping.

§Examples
use firestore_structured_query::FieldPath;
use google_api_proto::google::firestore::v1::structured_query;

let field_path1 = FieldPath::raw("field1");
assert_eq!(
    structured_query::FieldReference::from(field_path1),
    structured_query::FieldReference {
        field_path: "field1".to_string(),
    }
);
source§

impl FieldPath

source

pub fn array_contains<T>(&self, value: T) -> Result<Filter>
where T: IntoValue,

Creates a new FieldFilter with the ArrayContains operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.FieldFilter.Operator.ARRAY_CONTAINS

§Examples
use firestore_structured_query::{FieldPath, IntoValue, Result};
use google_api_proto::google::firestore::v1::{structured_query, value::ValueType, Value};
struct S(i64);
impl IntoValue for S {
    fn into_value(self) -> Result<Value> {
        Ok(Value {
            value_type: Some(ValueType::IntegerValue(self.0)),
        })
    }
}
let filter1 = FieldPath::raw("field7").array_contains(Value {
    value_type: Some(ValueType::IntegerValue(7)),
})?;
let filter2 = FieldPath::raw("field7").array_contains(S(7))?;
let expected = structured_query::Filter {
    filter_type: Some(structured_query::filter::FilterType::FieldFilter(
        structured_query::FieldFilter {
            field: Some(structured_query::FieldReference {
                field_path: "field7".to_string(),
            }),
            op: structured_query::field_filter::Operator::ArrayContains as i32,
            value: Some(Value {
                value_type: Some(ValueType::IntegerValue(7)),
            }),
        },
    )),
};
assert_eq!(structured_query::Filter::from(filter1), expected);
assert_eq!(structured_query::Filter::from(filter2), expected);
source

pub fn array_contains_any<T>(&self, value: T) -> Result<Filter>
where T: IntoValue,

Creates a new FieldFilter with the ArrayContainsAny operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.FieldFilter.Operator.ARRAY_CONTAINS_ANY

§Examples
use firestore_structured_query::{FieldPath, IntoValue, Result};
use google_api_proto::google::firestore::v1::{
    structured_query, value::ValueType, ArrayValue, Value,
};
struct S(Vec<i64>);
impl IntoValue for S {
    fn into_value(self) -> Result<Value> {
        Ok(Value {
            value_type: Some(ValueType::ArrayValue(ArrayValue {
                values: self
                    .0
                    .into_iter()
                    .map(|i| Value {
                        value_type: Some(ValueType::IntegerValue(i)),
                    })
                    .collect(),
            })),
        })
    }
}
let filter1 = FieldPath::raw("field9").array_contains_any(Value {
    value_type: Some(ValueType::ArrayValue(ArrayValue {
        values: vec![Value {
            value_type: Some(ValueType::IntegerValue(9)),
        }],
    })),
})?;
let filter2 = FieldPath::raw("field9").array_contains_any(S(vec![9]))?;
let expected = structured_query::Filter {
    filter_type: Some(structured_query::filter::FilterType::FieldFilter(
        structured_query::FieldFilter {
            field: Some(structured_query::FieldReference {
                field_path: "field9".to_string(),
            }),
            op: structured_query::field_filter::Operator::ArrayContainsAny as i32,
            value: Some(Value {
                value_type: Some(ValueType::ArrayValue(ArrayValue {
                    values: vec![Value {
                        value_type: Some(ValueType::IntegerValue(9)),
                    }],
                })),
            }),
        },
    )),
};
assert_eq!(structured_query::Filter::from(filter1), expected);
assert_eq!(structured_query::Filter::from(filter2), expected);
source

pub fn equal<T>(&self, value: T) -> Result<Filter>
where T: IntoValue,

Creates a new FieldFilter with the Equal operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.FieldFilter.Operator.EQUAL

§Examples
use firestore_structured_query::{FieldPath, IntoValue, Result};
use google_api_proto::google::firestore::v1::{structured_query, value::ValueType, Value};
struct S(i64);
impl IntoValue for S {
    fn into_value(self) -> Result<Value> {
        Ok(Value {
            value_type: Some(ValueType::IntegerValue(self.0)),
        })
    }
}
let filter1 = FieldPath::raw("field5").equal(Value {
    value_type: Some(ValueType::IntegerValue(5)),
})?;
let filter2 = FieldPath::raw("field5").equal(S(5))?;
let expected = structured_query::Filter {
    filter_type: Some(structured_query::filter::FilterType::FieldFilter(
        structured_query::FieldFilter {
            field: Some(structured_query::FieldReference {
                field_path: "field5".to_string(),
            }),
            op: structured_query::field_filter::Operator::Equal as i32,
            value: Some(Value {
                value_type: Some(ValueType::IntegerValue(5)),
            }),
        },
    )),
};
assert_eq!(structured_query::Filter::from(filter1), expected);
assert_eq!(structured_query::Filter::from(filter2), expected);
source

pub fn greater_than<T>(&self, value: T) -> Result<Filter>
where T: IntoValue,

Creates a new FieldFilter with the GreaterThan operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.FieldFilter.Operator.GREATER_THAN

§Examples
use firestore_structured_query::{FieldPath, IntoValue, Result};
use google_api_proto::google::firestore::v1::{structured_query, value::ValueType, Value};
struct S(i64);
impl IntoValue for S {
    fn into_value(self) -> Result<Value> {
        Ok(Value {
            value_type: Some(ValueType::IntegerValue(self.0)),
        })
    }
}
let filter1 = FieldPath::raw("field3").greater_than(Value {
    value_type: Some(ValueType::IntegerValue(3)),
})?;
let filter2 = FieldPath::raw("field3").greater_than(S(3))?;
let expected = structured_query::Filter {
    filter_type: Some(structured_query::filter::FilterType::FieldFilter(
        structured_query::FieldFilter {
            field: Some(structured_query::FieldReference {
                field_path: "field3".to_string(),
            }),
            op: structured_query::field_filter::Operator::GreaterThan as i32,
            value: Some(Value {
                value_type: Some(ValueType::IntegerValue(3)),
            }),
        },
    )),
};
assert_eq!(structured_query::Filter::from(filter1), expected);
assert_eq!(structured_query::Filter::from(filter2), expected);
source

pub fn greater_than_or_equal<T>(&self, value: T) -> Result<Filter>
where T: IntoValue,

Creates a new FieldFilter with the GreaterThanOrEqual operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.FieldFilter.Operator.GREATER_THAN_OR_EQUAL

§Examples
use firestore_structured_query::{FieldPath, IntoValue, Result};
use google_api_proto::google::firestore::v1::{structured_query, value::ValueType, Value};
struct S(i64);
impl IntoValue for S {
    fn into_value(self) -> Result<Value> {
        Ok(Value {
            value_type: Some(ValueType::IntegerValue(self.0)),
        })
    }
}
let filter1 = FieldPath::raw("field4").greater_than_or_equal(Value {
    value_type: Some(ValueType::IntegerValue(4)),
})?;
let filter2 = FieldPath::raw("field4").greater_than_or_equal(S(4))?;
let expected = structured_query::Filter {
    filter_type: Some(structured_query::filter::FilterType::FieldFilter(
        structured_query::FieldFilter {
            field: Some(structured_query::FieldReference {
                field_path: "field4".to_string(),
            }),
            op: structured_query::field_filter::Operator::GreaterThanOrEqual as i32,
            value: Some(Value {
                value_type: Some(ValueType::IntegerValue(4)),
            }),
        },
    )),
};
assert_eq!(structured_query::Filter::from(filter1), expected);
assert_eq!(structured_query::Filter::from(filter2), expected);
source

pub fn in<T>(&self, value: T) -> Result<Filter>
where T: IntoValue,

Creates a new FieldFilter with the In operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.FieldFilter.Operator.IN

§Examples
use firestore_structured_query::{FieldPath, IntoValue, Result};
use google_api_proto::google::firestore::v1::{
    structured_query, value::ValueType, ArrayValue, Value,
};
struct S(Vec<i64>);
impl IntoValue for S {
    fn into_value(self) -> Result<Value> {
        Ok(Value {
            value_type: Some(ValueType::ArrayValue(ArrayValue {
                values: self
                    .0
                    .into_iter()
                    .map(|i| Value {
                        value_type: Some(ValueType::IntegerValue(i)),
                    })
                    .collect(),
            })),
        })
    }
}
let filter1 = FieldPath::raw("field8").r#in(Value {
    value_type: Some(ValueType::ArrayValue(ArrayValue {
        values: vec![Value {
            value_type: Some(ValueType::IntegerValue(8)),
        }],
    })),
})?;
let filter2 = FieldPath::raw("field8").r#in(S(vec![8]))?;
let expected = structured_query::Filter {
    filter_type: Some(structured_query::filter::FilterType::FieldFilter(
        structured_query::FieldFilter {
            field: Some(structured_query::FieldReference {
                field_path: "field8".to_string(),
            }),
            op: structured_query::field_filter::Operator::In as i32,
            value: Some(Value {
                value_type: Some(ValueType::ArrayValue(ArrayValue {
                    values: vec![Value {
                        value_type: Some(ValueType::IntegerValue(8)),
                    }],
                })),
            }),
        },
    )),
};
assert_eq!(structured_query::Filter::from(filter1), expected);
assert_eq!(structured_query::Filter::from(filter2), expected);
source

pub fn is_nan(&self) -> Result<Filter>

Creates a new UnaryFilter with the IsNan operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.UnaryFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.UnaryFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.UnaryFilter.Operator.IS_NAN

§Examples
use firestore_structured_query::FieldPath;
use google_api_proto::google::firestore::v1::structured_query;
let filter1 = FieldPath::raw("field11").is_nan()?;
assert_eq!(
    structured_query::Filter::from(filter1),
    structured_query::Filter {
        filter_type: Some(structured_query::filter::FilterType::UnaryFilter(
            structured_query::UnaryFilter {
                op: structured_query::unary_filter::Operator::IsNan as i32,
                operand_type: Some(structured_query::unary_filter::OperandType::Field(
                    structured_query::FieldReference {
                        field_path: "field11".to_string()
                    }
                )),
            },
        )),
    }
);
source

pub fn is_not_nan(&self) -> Result<Filter>

Creates a new UnaryFilter with the IsNotNan operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.UnaryFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.UnaryFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.UnaryFilter.Operator.IS_NOT_NAN

§Examples
use firestore_structured_query::FieldPath;
use google_api_proto::google::firestore::v1::structured_query;
let filter1 = FieldPath::raw("field12").is_not_nan()?;
assert_eq!(
    structured_query::Filter::from(filter1),
    structured_query::Filter {
        filter_type: Some(structured_query::filter::FilterType::UnaryFilter(
            structured_query::UnaryFilter {
                op: structured_query::unary_filter::Operator::IsNotNan as i32,
                operand_type: Some(structured_query::unary_filter::OperandType::Field(
                    structured_query::FieldReference {
                        field_path: "field12".to_string()
                    }
                )),
            },
        )),
    }
);
source

pub fn is_not_null(&self) -> Result<Filter>

Creates a new UnaryFilter with the IsNotNull operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.UnaryFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.UnaryFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.UnaryFilter.Operator.IS_NOT_NULL

§Examples
use firestore_structured_query::FieldPath;
use google_api_proto::google::firestore::v1::structured_query;
let filter1 = FieldPath::raw("field13").is_not_null()?;
assert_eq!(
    structured_query::Filter::from(filter1),
    structured_query::Filter {
        filter_type: Some(structured_query::filter::FilterType::UnaryFilter(
            structured_query::UnaryFilter {
                op: structured_query::unary_filter::Operator::IsNotNull as i32,
                operand_type: Some(structured_query::unary_filter::OperandType::Field(
                    structured_query::FieldReference {
                        field_path: "field13".to_string()
                    }
                )),
            },
        )),
    }
);
source

pub fn is_null(&self) -> Result<Filter>

Creates a new UnaryFilter with the IsNull operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.UnaryFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.UnaryFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.UnaryFilter.Operator.IS_NULL

§Examples
use firestore_structured_query::FieldPath;
use google_api_proto::google::firestore::v1::structured_query;
let filter1 = FieldPath::raw("field14").is_null()?;
assert_eq!(
    structured_query::Filter::from(filter1),
    structured_query::Filter {
        filter_type: Some(structured_query::filter::FilterType::UnaryFilter(
            structured_query::UnaryFilter {
                op: structured_query::unary_filter::Operator::IsNull as i32,
                operand_type: Some(structured_query::unary_filter::OperandType::Field(
                    structured_query::FieldReference {
                        field_path: "field14".to_string()
                    }
                )),
            },
        )),
    }
);
source

pub fn less_than<T>(&self, value: T) -> Result<Filter>
where T: IntoValue,

Creates a new FieldFilter with the LessThan operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.FieldFilter.Operator.LESS_THAN

§Examples
use firestore_structured_query::{FieldPath, IntoValue, Result};
use google_api_proto::google::firestore::v1::{structured_query, value::ValueType, Value};
struct S(i64);
impl IntoValue for S {
    fn into_value(self) -> Result<Value> {
        Ok(Value {
            value_type: Some(ValueType::IntegerValue(self.0)),
        })
    }
}
let filter1 = FieldPath::raw("field1").less_than(Value {
    value_type: Some(ValueType::IntegerValue(1)),
})?;
let filter2 = FieldPath::raw("field1").less_than(S(1))?;
let expected = structured_query::Filter {
    filter_type: Some(structured_query::filter::FilterType::FieldFilter(
        structured_query::FieldFilter {
            field: Some(structured_query::FieldReference {
                field_path: "field1".to_string(),
            }),
            op: structured_query::field_filter::Operator::LessThan as i32,
            value: Some(Value {
                value_type: Some(ValueType::IntegerValue(1)),
            }),
        },
    )),
};
assert_eq!(structured_query::Filter::from(filter1), expected);
assert_eq!(structured_query::Filter::from(filter2), expected);
source

pub fn less_than_or_equal<T>(&self, value: T) -> Result<Filter>
where T: IntoValue,

Creates a new FieldFilter with the LessThanOrEqual operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.FieldFilter.Operator.LESS_THAN_OR_EQUAL

§Examples
use firestore_structured_query::{FieldPath, IntoValue, Result};
use google_api_proto::google::firestore::v1::{structured_query, value::ValueType, Value};
struct S(i64);
impl IntoValue for S {
    fn into_value(self) -> Result<Value> {
        Ok(Value {
            value_type: Some(ValueType::IntegerValue(self.0)),
        })
    }
}
let filter1 = FieldPath::raw("field2").less_than_or_equal(Value {
    value_type: Some(ValueType::IntegerValue(2)),
})?;
let filter2 = FieldPath::raw("field2").less_than_or_equal(S(2))?;
let expected = structured_query::Filter {
    filter_type: Some(structured_query::filter::FilterType::FieldFilter(
        structured_query::FieldFilter {
            field: Some(structured_query::FieldReference {
                field_path: "field2".to_string(),
            }),
            op: structured_query::field_filter::Operator::LessThanOrEqual as i32,
            value: Some(Value {
                value_type: Some(ValueType::IntegerValue(2)),
            }),
        },
    )),
};
assert_eq!(structured_query::Filter::from(filter1), expected);
assert_eq!(structured_query::Filter::from(filter2), expected);
source

pub fn not_equal<T>(&self, value: T) -> Result<Filter>
where T: IntoValue,

Creates a new FieldFilter with the NotEqual operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.FieldFilter.Operator.NOT_EQUAL

§Examples
use firestore_structured_query::{FieldPath, IntoValue, Result};
use google_api_proto::google::firestore::v1::{structured_query, value::ValueType, Value};
struct S(i64);
impl IntoValue for S {
    fn into_value(self) -> Result<Value> {
        Ok(Value {
            value_type: Some(ValueType::IntegerValue(self.0)),
        })
    }
}
let filter1 = FieldPath::raw("field6").not_equal(Value {
    value_type: Some(ValueType::IntegerValue(6)),
})?;
let filter2 = FieldPath::raw("field6").not_equal(S(6))?;
let expected = structured_query::Filter {
    filter_type: Some(structured_query::filter::FilterType::FieldFilter(
        structured_query::FieldFilter {
            field: Some(structured_query::FieldReference {
                field_path: "field6".to_string(),
            }),
            op: structured_query::field_filter::Operator::NotEqual as i32,
            value: Some(Value {
                value_type: Some(ValueType::IntegerValue(6)),
            }),
        },
    )),
};
assert_eq!(structured_query::Filter::from(filter1), expected);
assert_eq!(structured_query::Filter::from(filter2), expected);
source

pub fn not_in<T>(&self, value: T) -> Result<Filter>
where T: IntoValue,

Creates a new FieldFilter with the NotIn operator.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.FieldFilter.Operator.ENUM_VALUES.google.firestore.v1.StructuredQuery.FieldFilter.Operator.NOT_IN

§Examples
use firestore_structured_query::{FieldPath, IntoValue, Result};
use google_api_proto::google::firestore::v1::{
    structured_query, value::ValueType, ArrayValue, Value,
};
struct S(Vec<i64>);
impl IntoValue for S {
    fn into_value(self) -> Result<Value> {
        Ok(Value {
            value_type: Some(ValueType::ArrayValue(ArrayValue {
                values: self
                    .0
                    .into_iter()
                    .map(|i| Value {
                        value_type: Some(ValueType::IntegerValue(i)),
                    })
                    .collect(),
            })),
        })
    }
}
let filter1 = FieldPath::raw("field10").not_in(Value {
    value_type: Some(ValueType::ArrayValue(ArrayValue {
        values: vec![Value {
            value_type: Some(ValueType::IntegerValue(10)),
        }],
    })),
})?;
let filter2 = FieldPath::raw("field10").not_in(S(vec![10]))?;
let expected = structured_query::Filter {
    filter_type: Some(structured_query::filter::FilterType::FieldFilter(
        structured_query::FieldFilter {
            field: Some(structured_query::FieldReference {
                field_path: "field10".to_string(),
            }),
            op: structured_query::field_filter::Operator::NotIn as i32,
            value: Some(Value {
                value_type: Some(ValueType::ArrayValue(ArrayValue {
                    values: vec![Value {
                        value_type: Some(ValueType::IntegerValue(10)),
                    }],
                })),
            }),
        },
    )),
};
assert_eq!(structured_query::Filter::from(filter1), expected);
assert_eq!(structured_query::Filter::from(filter2), expected);
source§

impl FieldPath

source

pub fn ascending(&self) -> Order

Creates a new Order with the Ascending direction.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.Order https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.Direction.ENUM_VALUES.google.firestore.v1.StructuredQuery.Direction.ASCENDING

§Examples
use firestore_structured_query::{FieldPath, Order};
use google_api_proto::google::firestore::v1::structured_query;
let order: Order = FieldPath::raw("field1").ascending();
assert_eq!(
    structured_query::Order::from(order),
    structured_query::Order {
        field: Some(structured_query::FieldReference {
            field_path: "field1".to_string()
        }),
        direction: structured_query::Direction::Ascending as i32
    }
);
source

pub fn descending(&self) -> Order

Creates a new Order with the Descending direction.

https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.Order https://firebase.google.com/docs/firestore/reference/rpc/google.firestore.v1#google.firestore.v1.StructuredQuery.Direction.ENUM_VALUES.google.firestore.v1.StructuredQuery.Direction.DESCENDING

§Examples
use firestore_structured_query::{FieldPath, Order};
use google_api_proto::google::firestore::v1::structured_query;
let order: Order = FieldPath::raw("field1").descending();
assert_eq!(
    structured_query::Order::from(order),
    structured_query::Order {
        field: Some(structured_query::FieldReference {
            field_path: "field1".to_string()
        }),
        direction: structured_query::Direction::Descending as i32
    }
);

Trait Implementations§

source§

impl Clone for FieldPath

source§

fn clone(&self) -> FieldPath

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for FieldPath

source§

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

Formats the value using the given formatter. Read more
source§

impl From<FieldPath> for FieldReference

source§

fn from(FieldPath: FieldPath) -> Self

Converts to this type from the input type.
source§

impl Ord for FieldPath

source§

fn cmp(&self, other: &FieldPath) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

impl PartialEq for FieldPath

source§

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

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

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.
source§

impl PartialOrd for FieldPath

source§

fn partial_cmp(&self, other: &FieldPath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

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

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl Eq for FieldPath

source§

impl StructuralPartialEq for FieldPath

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<Q, K> Comparable<K> for Q
where Q: Ord + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn compare(&self, key: &K) -> Ordering

Compare self to key and return their ordering.
source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
source§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> FromRef<T> for T
where T: Clone,

source§

fn from_ref(input: &T) -> T

Converts to this type from a reference to the input type.
source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoRequest<T> for T

source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more