Struct Projection 

pub struct Projection<'a, TD> { /* private fields */ }

Projection expression builder that automatically includes the table’s key attributes.

Projection<'a, TD> builds a DynamoDB ProjectionExpression that limits which attributes are returned by a Get or Query/Scan operation. It always includes the table’s partition key (and sort key for composite-key tables) so that the resulting Item<TD> upholds its invariant of always containing the key attributes.

Attribute names that are DynamoDB reserved words are automatically escaped with # expression attribute name placeholders.

Examples

Projecting a subset of user attributes:

use dynamodb_facade::Projection;

// Request only "name" and "email" — PK and SK are added automatically.
let proj = Projection::<PlatformTable>::new(["name", "email"]);

// The rendered expression includes PK, SK, and the requested fields.
let rendered = format!("{proj}");
assert_eq!(format!("{proj}"), "PK,SK,email,name");
let rendered_with_placeholders = format!("{proj:#}");
assert!(rendered_with_placeholders.contains("#p0 = name"));

Implementations

impl<'a, TD: TableDefinition> Projection<'a, TD>

where Self: KeySchemaProjection<'a, TD::KeySchema, <TD::KeySchema as KeySchema>::Kind>,

pub fn new(attrs: impl IntoIterator<Item = impl Into<Cow<'a, str>>>) -> Self

Creates a projection from an iterator of attribute names.

The table’s key attributes (PK, and SK for composite-key tables) are always prepended to the provided list, ensuring the resulting Item<TD> is always valid for the table schema.

Duplicate attribute names are deduplicated automatically.

Examples

use dynamodb_facade::Projection;

// Project "name" and "email"; PK + SK are added automatically.
let proj = Projection::<PlatformTable>::new(["name", "email"]);

let rendered = format!("{proj}");
assert!(rendered.contains("PK"));
assert!(rendered.contains("SK"));
assert!(rendered.contains("name"));
assert!(rendered.contains("email"));
let rendered_with_placeholders = format!("{proj:#}");
assert!(rendered_with_placeholders.contains("#p0 = name"));

pub fn keys_only() -> Self

Creates a projection that contains only the table’s key attributes.

The result is a projection that includes exactly PK (for simple-key tables) or PK + SK (for composite-key tables).

This is useful when you want to list or scan matching items without fetching any payload data — for example, collecting the keys of all enrollments for a user before issuing a batch delete.

Examples

use dynamodb_facade::Projection;

// PlatformTable has composite key PK + SK — those are the only attributes returned.
let proj = Projection::<PlatformTable>::keys_only();

let rendered = format!("{proj}");
assert_eq!(rendered, "PK,SK");

Trait Implementations

impl<'a, TD: Clone> Clone for Projection<'a, TD>

fn clone(&self) -> Projection<'a, TD>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, TD: Debug> Debug for Projection<'a, TD>

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

Formats the value using the given formatter.

impl<TD> Display for Projection<'_, TD>

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

Formats the value using the given formatter.