Attribute types (S, N, B, BOOL, L, M) in DynamoDB - Deep Dive

Overview - Attribute types (S, N, B, BOOL, L, M)

What is it?

Attribute types in DynamoDB define the kind of data stored in each item attribute. They include simple types like strings (S), numbers (N), and binary data (B), as well as complex types like lists (L) and maps (M). These types help DynamoDB understand how to store, index, and retrieve data efficiently. Knowing attribute types is essential for designing your database schema and writing queries.

Why it matters

Without clear attribute types, DynamoDB wouldn't know how to handle or compare data, leading to errors or inefficient storage. Attribute types ensure data is stored correctly and queries return expected results. This makes your application reliable and fast, especially when dealing with diverse data like text, numbers, or nested objects.

Where it fits

Before learning attribute types, you should understand basic database concepts like tables, items, and attributes. After mastering attribute types, you can learn about DynamoDB operations like querying, scanning, and indexing, which rely on these types to work properly.

Mental Model

Core Idea

Attribute types in DynamoDB tell the database what kind of data each piece of information is, so it can store and handle it correctly.

Think of it like...

Think of attribute types like labeled boxes in a storage room: one box for letters (strings), one for coins (numbers), one for photos (binary), and some boxes that hold smaller boxes inside (lists and maps). Knowing the label helps you find and use the right box quickly.

┌─────────────┐
│  DynamoDB   │
│  Attribute  │
│    Types    │
└─────────────┘
     │  │  │  │  │  │
     │  │  │  │  │  └─ Map (M): key-value pairs
     │  │  │  │  └──── List (L): ordered collection
     │  │  │  └────── BOOL: true or false
     │  │  └──────── Binary (B): raw data
     │  └────────── Number (N): numeric values
     └──────────── String (S): text data

Build-Up - 7 Steps

1

Foundation

Basic attribute types overview

Concept: Introduce the simplest attribute types: String (S), Number (N), and Binary (B).

DynamoDB stores data in attributes, each with a type. The simplest types are: - S (String): Text like names or descriptions. - N (Number): Numeric values like age or price. - B (Binary): Raw data like images or encrypted info. Each attribute must declare its type so DynamoDB knows how to handle it.

Result

You can store text, numbers, and raw data correctly in DynamoDB items.

Understanding these basic types is crucial because they form the foundation for all data storage in DynamoDB.

2

Foundation

Boolean and null attribute types

Concept: Learn about Boolean (BOOL) type and how DynamoDB handles null or empty values.

Besides S, N, and B, DynamoDB supports BOOL for true/false values. This is useful for flags like 'isActive'. DynamoDB also supports NULL type to represent missing or empty data explicitly. This helps keep data consistent and queries predictable.

Result

You can store true/false flags and represent missing data clearly.

Knowing how to represent true/false and missing data prevents confusion and errors in your application logic.

3

Intermediate

Complex attribute types: Lists (L)

🤔Before reading on: do you think a list in DynamoDB can hold different types of data or only one type? Commit to your answer.

Concept: Introduce the List (L) type, which holds an ordered collection of attributes, possibly of mixed types.

The List (L) type lets you store multiple values in order, like an array. Each item in the list can be any attribute type, including other lists or maps. For example, a list can hold strings, numbers, and even nested objects together. This flexibility helps model complex data structures.

Result

You can store ordered collections of mixed data types inside a single attribute.

Understanding that lists can hold mixed types allows you to design flexible and rich data models in DynamoDB.

4

Intermediate

Complex attribute types: Maps (M)

🤔Before reading on: do you think a map in DynamoDB is like a list or a dictionary? Commit to your answer.

Concept: Explain the Map (M) type, which stores key-value pairs, similar to a dictionary or object.

The Map (M) type stores attributes as key-value pairs, where keys are strings and values can be any attribute type. This lets you nest data inside an item, like storing an address with street, city, and zip code fields inside one attribute. Maps can also contain other maps or lists, enabling deep nesting.

Result

You can represent structured, nested data inside a single attribute.

Knowing how to use maps helps you organize related data together, making your database more intuitive and easier to query.

5

Intermediate

Combining attribute types in practice

🤔Before reading on: do you think you can mix lists and maps inside each other in DynamoDB? Commit to your answer.

Concept: Show how to combine lists and maps to model complex real-world data.

You can nest lists inside maps and maps inside lists to create complex data structures. For example, a user profile attribute might be a map containing a list of phone numbers and another map for address details. This nesting allows DynamoDB to store rich, hierarchical data in a single item.

Result

You can model complex objects with nested lists and maps in DynamoDB.

Understanding nesting unlocks the power of DynamoDB to handle real-world data beyond flat tables.

6

Advanced

Attribute types impact on querying and indexing

🤔Before reading on: do you think all attribute types can be used as keys for indexes? Commit to your answer.

Concept: Explain how attribute types affect which attributes can be keys and how queries work.

DynamoDB requires key attributes (partition and sort keys) to be of type String (S), Number (N), or Binary (B). Complex types like List (L) or Map (M) cannot be keys. This means when designing your table and indexes, you must choose key attributes carefully. Also, some query operations behave differently depending on attribute types, like comparisons on numbers vs strings.

Result

You learn to design keys and queries that work efficiently with DynamoDB's type rules.

Knowing type restrictions on keys prevents design mistakes that cause query failures or poor performance.

7

Expert

Surprising behavior of attribute types in DynamoDB

🤔Before reading on: do you think DynamoDB treats numbers with different formats (like '1' and '1.0') as equal? Commit to your answer.

Concept: Reveal subtle behaviors and edge cases with attribute types, especially numbers and binary data.

DynamoDB stores numbers as variable precision decimals, so '1' and '1.0' are considered equal in queries and keys. Also, binary data is base64-encoded internally, which can cause confusion when comparing or displaying. Another surprise is that empty strings are not allowed as attribute values, unlike some other databases. These quirks affect how you prepare and query data.

Result

You avoid subtle bugs related to data equality and storage format.

Understanding these internal behaviors helps you write robust applications and avoid unexpected query results.

Under the Hood

DynamoDB stores each attribute with a type tag that tells the system how to encode, store, and compare the data. Simple types like strings and numbers are stored in a straightforward way, while complex types like lists and maps are stored as nested structures with type information for each element. When querying or indexing, DynamoDB uses these type tags to perform correct comparisons and data retrieval.

Why designed this way?

DynamoDB was designed for flexibility and speed at scale. Using explicit attribute types allows it to optimize storage and queries while supporting complex data models. The choice to separate simple and complex types balances ease of use with performance. Some design decisions, like disallowing empty strings, simplify internal indexing and avoid ambiguous data states.

┌───────────────┐
│   Item Data   │
│ ┌───────────┐ │
│ │ Attribute │ │
│ │  Value    │ │
│ │ ┌───────┐ │ │
│ │ │ Type  │ │ │
│ │ │  S/N/B│ │ │
│ │ └───────┘ │ │
│ └───────────┘ │
└─────┬─────────┘
      │
┌─────▼─────────┐
│ Storage Layer │
│ Encodes data  │
│ by type tag   │
└─────┬─────────┘
      │
┌─────▼─────────┐
│ Query Engine  │
│ Uses type to  │
│ compare data  │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think you can use a List (L) attribute as a partition key? Commit to yes or no.

Common Belief: You can use any attribute type, including lists or maps, as a partition or sort key.

Reality: Only String (S), Number (N), or Binary (B) types can be used as partition or sort keys in DynamoDB.

Why it matters: Trying to use complex types as keys causes table creation or query errors, blocking your application.

Quick: Do you think DynamoDB allows empty strings as attribute values? Commit to yes or no.

Common Belief: Empty strings are allowed as valid string attribute values in DynamoDB.

Reality: DynamoDB does not allow empty strings; they are rejected during writes.

Why it matters: Assuming empty strings are allowed can cause unexpected write failures and data inconsistencies.

Quick: Do you think the number '1' and '1.0' are treated differently in DynamoDB? Commit to yes or no.

Common Belief: Numbers with different formats like '1' and '1.0' are treated as different values.

Reality: DynamoDB treats '1' and '1.0' as equal numbers for storage and comparison.

Why it matters: Misunderstanding this can lead to confusion when querying or indexing numeric data.

Quick: Do you think Boolean attributes can be stored as strings like 'true' or 'false'? Commit to yes or no.

Common Belief: Boolean values must be stored as strings 'true' or 'false' in DynamoDB.

Reality: DynamoDB has a native BOOL type for true/false values; storing them as strings is incorrect.

Why it matters: Using strings instead of BOOL can cause incorrect query behavior and data interpretation.

Expert Zone

1

DynamoDB's internal number representation uses variable precision decimals, which affects equality and sorting in subtle ways.

2

Maps and Lists are stored with type information for each element, enabling complex nested queries but increasing storage size.

3

Boolean and NULL types are stored efficiently but can affect conditional expressions differently than strings or numbers.

When NOT to use

Avoid using complex nested Maps or Lists as primary keys or index keys; instead, flatten data or use composite keys with simple types. For highly relational data, consider relational databases or graph databases instead of DynamoDB.

Production Patterns

In production, developers often use Maps to group related attributes (like address or preferences) and Lists for collections (like tags or history). Keys are carefully chosen as Strings or Numbers for efficient indexing. Attribute types guide query design, especially when using filters and conditional updates.

Connections

JSON data structures

DynamoDB's Maps and Lists correspond closely to JSON objects and arrays.

Understanding JSON helps grasp how DynamoDB stores nested data and how to serialize/deserialize it in applications.

Type systems in programming languages

DynamoDB attribute types are similar to data types in programming languages like strings, numbers, and booleans.

Knowing programming type systems helps predict how DynamoDB will store and compare data, improving schema design.

File system storage

Attribute types in DynamoDB are like file formats in storage systems, guiding how data is saved and read.

Recognizing this connection clarifies why type information is essential for efficient data retrieval and integrity.

Common Pitfalls

#1 Using a List attribute as a partition key.

Wrong approach:

CREATE TABLE Users (UserId L PRIMARY KEY);

Correct approach:

CREATE TABLE Users (UserId S PRIMARY KEY);

Root cause:

Misunderstanding that only simple types (S, N, B) can be keys.

#2 Storing Boolean values as strings 'true' or 'false'.

Wrong approach:

Item = { "isActive": { "S": "true" } }

Correct approach:

Item = { "isActive": { "BOOL": true } }

Root cause:

Confusing string representation with native Boolean type.

#3 Attempting to store empty strings as attribute values.

Wrong approach:

Item = { "Name": { "S": "" } }

Correct approach:

Item = { "Name": { "NULL": true } }

Root cause:

Not knowing DynamoDB disallows empty strings and requires NULL type for missing data.

Key Takeaways

DynamoDB attribute types define how data is stored, compared, and retrieved, making them essential for database design.

Simple types like String, Number, and Binary are used for keys and basic data, while Lists and Maps allow complex nested structures.

Only simple types can be used as partition or sort keys; complex types cannot serve as keys.

DynamoDB treats numbers with different formats as equal and disallows empty strings, which affects data handling.

Understanding attribute types deeply helps avoid common mistakes and unlocks powerful data modeling capabilities in DynamoDB.