Struct dynamodb_expression::path::Path
source · pub struct Path { /* private fields */ }
Expand description
Represents a DynamoDB document path. For example, foo[3][7].bar[2].baz
.
When used in an Expression
, attribute names in a Path
are
automatically handled as expression attribute names, allowing for names
that would not otherwise be permitted by DynamoDB. For example,
foo[3][7].bar[2].baz
would become something similar to #0[3][7].#1[2].#2
,
and the names would be in the expression_attribute_names
.
See also: Element
, Name
, IndexedField
Examples
The safest way to construct a Path
is to parse it.
use dynamodb_expression::path::Path;
let path: Path = "foo".parse().unwrap();
let path: Path = "foo[3]".parse().unwrap();
let path: Path = "foo[3][7]".parse().unwrap();
let path: Path = "foo[3][7].bar".parse().unwrap();
let path: Path = "bar.baz".parse().unwrap();
let path: Path = "baz[0].foo".parse().unwrap();
This makes the common assumption that each path element is separated by a
period (.
). For example, the path foo.bar
gets treated as if foo
is a
top-level attribute, and bar
is a sub-attribute of foo
. However, .
is
also a valid character in an attribute name.
If you have an attribute name with a .
in it, and need it to not be
treated as a separator, you can construct the Path
a few different ways.
Here are some ways you can correctly construct a Path
using attr.name
as the problematic attribute name.
use dynamodb_expression::path::{Element, Path};
// As a top-level attribute name:
let path = Path::name("attr.name");
// If the top-level attribute, `foo`, has a sub-attribute named `attr.name`:
let path = Path::from_iter([
Element::name("foo"),
Element::name("attr.name"),
]);
// If top-level attribute `foo`, item 3 (i.e., `foo[3]`) has a sub-attribute
// named `attr.name`:
let path = Path::from_iter([
Element::indexed_field("foo", 3),
Element::name("attr.name"),
]);
// If top-level attribute `foo`, item 3, sub-item 7 (i.e., `foo[3][7]`) has
// an attribute named `attr.name`:
let path = Path::from_iter([
Element::indexed_field("foo", [3, 7]),
Element::name("attr.name"),
]);
Each of these are ways to create a Path
instance for foo[3][7].bar[2].baz
.
use dynamodb_expression::{path::{Element, Path}};
// A `Path` can be parsed from a string
let path: Path = "foo[3][7].bar[2].baz".parse().unwrap();
// `Path` implements `FromIterator` for items that are `Element`s.
let path = Path::from_iter([
Element::indexed_field("foo", [3, 7]),
Element::indexed_field("bar", 2),
Element::name("baz"),
]);
// Of course, that means you can `.collect()` into a `Path`.
let path: Path = [
Element::indexed_field("foo", [3, 7]),
Element::indexed_field("bar", 2),
Element::name("baz"),
]
.into_iter()
.collect();
// `Element` can be converted into from string/index tuples. Where the
// string is the attribute name. In this case, an "index" is an array,
// slice, `Vec` of, or a single `usize`.
//
// It's smart about it, though. If if there's one or zero indexes it'll do
// the right thing. This helps when you're chaining iterator adapters and
// the results are values with inconsistent numbers of indexes.
let path = Path::from_iter(
[
("foo", vec![3, 7]),
("bar", vec![2]),
("baz", vec![]),
]
.map(Element::from),
);
// `Path` implements `FromIterator` for items that are `Into<Element>`.
// So, the above example can be simplified.
let path = Path::from_iter([
("foo", vec![3, 7]),
("bar", vec![2]),
("baz", vec![]),
]);
If you have a document path where an attribute name includes a period
(.
), you will need to explicitly create the Element
s for that Path
.
// If the attribute name is `foo.bar`:
let path = Path::from(Element::name("foo.bar"));
// If the item at `foo[3]` has an attribute named `bar.baz`:
let path = Path::from_iter([
Element::indexed_field("foo", 3),
Element::name("bar.baz")
]);
A Name
can be converted into a Path
.
use dynamodb_expression::path::{Element, Name, Path};
let name = Name::from("foo");
let path = Path::from(name);
assert_eq!(Path::from(Element::name("foo")), path);
Implementations§
source§impl Path
impl Path
sourcepub fn name<T>(name: T) -> Selfwhere
T: Into<Name>,
pub fn name<T>(name: T) -> Selfwhere T: Into<Name>,
Constructs a Path
for a single attribute name (with no indexes or
sub-attributes). If you have a attribute name with one or more indexes,
use Path::indexed_field()
.
sourcepub fn indexed_field<N, I>(name: N, indexes: I) -> Selfwhere
N: Into<Name>,
I: Indexes,
pub fn indexed_field<N, I>(name: N, indexes: I) -> Selfwhere N: Into<Name>, I: Indexes,
Constructs a Path
for a single attribute name (with no indexes or
sub-attributes). If you have a attribute name with no indexes, you can
pass an empty collection, or use Path::name
.
indexes
here can be an array, slice, Vec
of, or single usize
.
assert_eq!("foo[3]", Path::indexed_field("foo", 3).to_string());
assert_eq!("foo[3]", Path::indexed_field("foo", [3]).to_string());
assert_eq!("foo[3]", Path::indexed_field("foo", &[3]).to_string());
assert_eq!("foo[3]", Path::indexed_field("foo", vec![3]).to_string());
assert_eq!("foo[7][4]", Path::indexed_field("foo", [7, 4]).to_string());
assert_eq!("foo[7][4]", Path::indexed_field("foo", &[7, 4]).to_string());
assert_eq!("foo[7][4]", Path::indexed_field("foo", vec![7, 4]).to_string());
assert_eq!("foo", Path::indexed_field("foo", []).to_string());
assert_eq!("foo", Path::indexed_field("foo", &[]).to_string());
assert_eq!("foo", Path::indexed_field("foo", vec![]).to_string());
See also: IndexedField
, Element::indexed_field
source§impl Path
impl Path
Methods relating to building condition and filter expressions.
sourcepub fn equal<T>(self, right: T) -> Conditionwhere
T: Into<Operand>,
pub fn equal<T>(self, right: T) -> Conditionwhere T: Into<Operand>,
Check if the value at this Path
is equal to the given value.
sourcepub fn not_equal<T>(self, right: T) -> Conditionwhere
T: Into<Operand>,
pub fn not_equal<T>(self, right: T) -> Conditionwhere T: Into<Operand>,
Check if the value at this Path
is not equal to the given value.
sourcepub fn greater_than<T>(self, right: T) -> Conditionwhere
T: Into<Operand>,
pub fn greater_than<T>(self, right: T) -> Conditionwhere T: Into<Operand>,
Check if the value at this Path
is greater than the given value.
sourcepub fn greater_than_or_equal<T>(self, right: T) -> Conditionwhere
T: Into<Operand>,
pub fn greater_than_or_equal<T>(self, right: T) -> Conditionwhere T: Into<Operand>,
Check if the value at this Path
is greater than or equal to the given value.
sourcepub fn less_than<T>(self, right: T) -> Conditionwhere
T: Into<Operand>,
pub fn less_than<T>(self, right: T) -> Conditionwhere T: Into<Operand>,
Check if the value at this Path
is less than the given value.
sourcepub fn less_than_or_equal<T>(self, right: T) -> Conditionwhere
T: Into<Operand>,
pub fn less_than_or_equal<T>(self, right: T) -> Conditionwhere T: Into<Operand>,
Check if the value at this Path
is less than or equal to the given value.
sourcepub fn between<L, U>(self, lower: L, upper: U) -> Conditionwhere
L: Into<Operand>,
U: Into<Operand>,
pub fn between<L, U>(self, lower: L, upper: U) -> Conditionwhere L: Into<Operand>, U: Into<Operand>,
self BETWEEN b AND c
- true if self
is greater than or equal to b
, and less than or equal to c
.
sourcepub fn in_<I, T>(self, items: I) -> Conditionwhere
I: IntoIterator<Item = T>,
T: Into<Operand>,
pub fn in_<I, T>(self, items: I) -> Conditionwhere I: IntoIterator<Item = T>, T: Into<Operand>,
self IN (b[, ..])
— true if self
is equal to any value in the list.
The list can contain up to 100 values. It must have at least 1.
sourcepub fn attribute_exists(self) -> Condition
pub fn attribute_exists(self) -> Condition
True if the item contains the attribute specified by Path
.
sourcepub fn attribute_not_exists(self) -> Condition
pub fn attribute_not_exists(self) -> Condition
True if the attribute specified by Path
does not exist in the item.
sourcepub fn attribute_type(self, attribute_type: Type) -> Condition
pub fn attribute_type(self, attribute_type: Type) -> Condition
True if the attribute at the specified Path
is of a particular data type.
sourcepub fn begins_with<T>(self, prefix: T) -> Conditionwhere
T: Into<StringOrRef>,
pub fn begins_with<T>(self, prefix: T) -> Conditionwhere T: Into<StringOrRef>,
True if the attribute specified by Path
begins with a particular substring.
sourcepub fn contains<V>(self, operand: V) -> Conditionwhere
V: Into<Scalar>,
pub fn contains<V>(self, operand: V) -> Conditionwhere V: Into<Scalar>,
True if the attribute specified by Path
is one of the following:
- A
String
that contains a particular substring. - A
Set
that contains a particular element within the set. - A
List
that contains a particular element within the list.
The operand must be a String
if the attribute specified by path is a String
.
If the attribute specified by path is a Set
, the operand must be the set’s element type.
source§impl Path
impl Path
Methods relating to building update expressions.
sourcepub fn math(self) -> MathBuilder
pub fn math(self) -> MathBuilder
Sets this as the destination in a Math
builder.
sourcepub fn list_append(self) -> ListAppendBuilder
pub fn list_append(self) -> ListAppendBuilder
Sets this as the destination in a ListAppend
builder.
sourcepub fn if_not_exists(self) -> IfNotExistsBuilder
pub fn if_not_exists(self) -> IfNotExistsBuilder
Sets this as the destination in an IfNotExists
builder.
Trait Implementations§
source§impl<T> FromIterator<T> for Pathwhere
T: Into<Element>,
impl<T> FromIterator<T> for Pathwhere T: Into<Element>,
source§fn from_iter<I>(iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
fn from_iter<I>(iter: I) -> Selfwhere I: IntoIterator<Item = T>,
source§impl Ord for Path
impl Ord for Path
source§impl PartialEq for Path
impl PartialEq for Path
source§impl PartialOrd for Path
impl PartialOrd for Path
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl TryFrom<Path> for Name
impl TryFrom<Path> for Name
source§fn try_from(path: Path) -> Result<Self, Self::Error>
fn try_from(path: Path) -> Result<Self, Self::Error>
A Path
consisting of a single, unindexed attribute can be converted
into a Name
.
use dynamodb_expression::path::{Element, Name, Path};
let path: Path = "foo".parse().unwrap();
let name = Name::try_from(path).unwrap();
assert_eq!(Name::from("foo"), name);
If the Path
has indexes, or has sub-attributes, it cannot be
converted, and the original Path
is returned.
let path: Path = "foo[0]".parse().unwrap();
let err = Name::try_from(path.clone()).unwrap_err();
assert_eq!(path, err);
let path: Path = "foo.bar".parse().unwrap();
let err = Name::try_from(path.clone()).unwrap_err();
assert_eq!(path, err);
impl Eq for Path
impl StructuralEq for Path
impl StructuralPartialEq for Path
Auto Trait Implementations§
impl RefUnwindSafe for Path
impl Send for Path
impl Sync for Path
impl Unpin for Path
impl UnwindSafe for Path
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.