Bird
Raised Fist0
DynamoDBquery~10 mins

DynamoDB vs MongoDB vs Cassandra - Interactive Practice

Choose your learning style10 modes available

Start learning this pattern below

Jump into concepts and practice - no test required

or
Recommended
Test this pattern10 questions across easy, medium, and hard to know if this pattern is strong
Practice - 5 Tasks
Answer the questions below
1fill in blank
easy

Complete the code to create a DynamoDB table with a primary key named 'UserId'.

DynamoDB
table = dynamodb.create_table(
    TableName='Users',
    KeySchema=[{'AttributeName': '[1]', 'KeyType': 'HASH'}],
    AttributeDefinitions=[{'AttributeName': 'UserId', 'AttributeType': 'S'}],
    ProvisionedThroughput={'ReadCapacityUnits': 5, 'WriteCapacityUnits': 5}
)
Drag options to blanks, or click blank then click option'
AUsername
BUserId
CEmail
DId
Attempts:
3 left
💡 Hint
Common Mistakes
Using a different attribute name than defined in AttributeDefinitions.
2fill in blank
medium

Complete the code to insert an item into a DynamoDB table named 'Users'.

DynamoDB
table.put_item(Item={'UserId': '123', 'Name': '[1]'})
Drag options to blanks, or click blank then click option'
ABob
BAlice
CCharlie
DDavid
Attempts:
3 left
💡 Hint
Common Mistakes
Using a number or invalid type for the 'Name' attribute.
3fill in blank
hard

Fix the error in the query to get an item by 'UserId' from DynamoDB.

DynamoDB
response = table.get_item(Key={'[1]': '123'})
Drag options to blanks, or click blank then click option'
AUserID
BuserId
CUserId
Duserid
Attempts:
3 left
💡 Hint
Common Mistakes
Using incorrect casing for the key attribute name.
4fill in blank
hard

Fill both blanks to write a MongoDB query that finds documents where 'age' is greater than 25.

DynamoDB
db.collection.find({ 'age': { '[1]': [2] } })
Drag options to blanks, or click blank then click option'
A$gt
B$lt
C25
D30
Attempts:
3 left
💡 Hint
Common Mistakes
Using '$lt' instead of '$gt'.
Using wrong comparison value.
5fill in blank
hard

Fill all three blanks to write a Cassandra CQL query that selects 'name' and 'email' from 'users' where 'id' equals 10.

DynamoDB
SELECT [1], [2] FROM users WHERE [3] = 10;
Drag options to blanks, or click blank then click option'
Aname
Bemail
Cid
Duser_id
Attempts:
3 left
💡 Hint
Common Mistakes
Using wrong column names.
Using 'user_id' instead of 'id'.

Practice

(1/5)
1. Which database is best known for automatic scaling and simple key-value access?
easy
A. Cassandra
B. DynamoDB
C. MongoDB
D. MySQL

Solution

  1. Step 1: Understand DynamoDB's core feature

    DynamoDB is designed for simple key-value access and automatic scaling.
  2. Step 2: Compare with other databases

    MongoDB focuses on flexible document storage, Cassandra on high availability for huge data.
  3. Final Answer:

    DynamoDB -> Option B
  4. Quick Check:

    Automatic scaling + key-value = DynamoDB [OK]
Hint: Automatic scaling with key-value means DynamoDB [OK]
Common Mistakes:
  • Confusing MongoDB's flexible documents with key-value simplicity
  • Thinking Cassandra automatically scales like DynamoDB
  • Choosing MySQL which is relational, not key-value
2. Which of the following is the correct way to describe MongoDB's data model?
easy
A. Column-family store with automatic partitioning
B. Simple key-value pairs with fixed schema
C. Flexible document storage with rich queries
D. Relational tables with strict schema

Solution

  1. Step 1: Identify MongoDB's data model

    MongoDB stores data as flexible JSON-like documents allowing rich queries.
  2. Step 2: Eliminate other options

    Column-family store describes Cassandra, key-value with fixed schema fits DynamoDB less, relational tables fit SQL databases.
  3. Final Answer:

    Flexible document storage with rich queries -> Option C
  4. Quick Check:

    MongoDB = flexible documents + rich queries [OK]
Hint: MongoDB = flexible JSON documents + rich queries [OK]
Common Mistakes:
  • Confusing MongoDB with Cassandra's column-family model
  • Thinking MongoDB uses fixed schema like relational DB
  • Mixing key-value with document storage
3. Given a large dataset requiring high availability and fast writes across multiple data centers, which database is most suitable?
medium
A. MongoDB
B. DynamoDB
C. SQLite
D. Cassandra

Solution

  1. Step 1: Analyze requirements for high availability and multi-datacenter writes

    Cassandra is designed for huge data with high availability and multi-region replication.
  2. Step 2: Compare other options

    MongoDB supports replication but less optimized for huge scale multi-datacenter writes; DynamoDB is scalable but less focused on multi-datacenter writes; SQLite is local and not distributed.
  3. Final Answer:

    Cassandra -> Option D
  4. Quick Check:

    High availability + multi-datacenter = Cassandra [OK]
Hint: Huge data + multi-region writes = Cassandra [OK]
Common Mistakes:
  • Choosing DynamoDB for multi-datacenter writes
  • Confusing SQLite as distributed database
  • Assuming MongoDB handles huge multi-region writes best
4. You try to use MongoDB's flexible document queries on DynamoDB but get errors. What is the likely cause?
medium
A. DynamoDB does not support flexible document queries like MongoDB
B. DynamoDB requires SQL syntax for queries
C. MongoDB uses column-family data model incompatible with DynamoDB
D. DynamoDB only supports relational tables

Solution

  1. Step 1: Understand query capabilities of DynamoDB

    DynamoDB supports key-value and simple queries but not rich flexible document queries like MongoDB.
  2. Step 2: Eliminate incorrect causes

    DynamoDB does not use SQL syntax, is not column-family, and is not relational.
  3. Final Answer:

    DynamoDB does not support flexible document queries like MongoDB -> Option A
  4. Quick Check:

    DynamoDB lacks MongoDB's flexible queries [OK]
Hint: DynamoDB lacks MongoDB's rich document query support [OK]
Common Mistakes:
  • Assuming DynamoDB uses SQL syntax
  • Confusing data models between MongoDB and Cassandra
  • Thinking DynamoDB supports relational tables
5. You need a database for an app that requires flexible JSON documents, automatic scaling, and global availability. Which approach best fits this need?
hard
A. Use DynamoDB with JSON support and global tables
B. Use MongoDB with sharding and replica sets only
C. Use Cassandra with column-family tables and no JSON support
D. Use SQLite with local JSON extensions

Solution

  1. Step 1: Identify features needed

    The app needs flexible JSON documents, automatic scaling, and global availability.
  2. Step 2: Match features to databases

    DynamoDB supports JSON documents, automatic scaling, and global tables for availability. MongoDB supports JSON but global availability requires extra setup and scaling is manual. Cassandra lacks native JSON support and SQLite is local only.
  3. Final Answer:

    Use DynamoDB with JSON support and global tables -> Option A
  4. Quick Check:

    JSON + auto scale + global = DynamoDB [OK]
Hint: DynamoDB global tables + JSON = best for scaling + availability [OK]
Common Mistakes:
  • Choosing MongoDB without considering scaling complexity
  • Ignoring Cassandra's lack of JSON support
  • Selecting SQLite which is not distributed