Comparing Cassandra and DynamoDB: A Side-By-Side Guide

Database technologies have gone through revolutions in the last decade. With just a handful of databases before, there are now multiple options — selecting the right one for a new project is often a challenge. The last decade saw the rise in popularity of NoSQL databases, which remove some of the complexities of relational databases for use cases that don’t require structured queries. This article attempts to compare two popular NoSQL databases: DynamoDB and Cassandra. It highlights their features and compares database operations.

Evolution

Cassandra is an open-source database released under the Apache License. It was originally built by Facebook for internal use and open-sourced in 2008. Ongoing development and stewardship of Cassandra is handled by the Apache Software Foundation. The latest version available at the time of writing is 5.0.

DynamoDB is owned by AWS. It was developed by Amazon to handle the large volume of data for their cart operations. Initially used internally, it was launched as a service in AWS in 2012.

Feature Comparison

Comparison of Database Operations

StringBuilder sb = new StringBuilder("INSERT INTO ")
      .append(TABLE_NAME).append("(key, value) ")
      .append("VALUES (").append(keyVal)
      .append(", '").append(valueVal).append("');");
	String query = sb.toString();
    session.execute(query);

Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder().region(region).build();
HashMap<String, AttributeValue> itemValues = new HashMap<>();
itemValues.put(key, AttributeValue.builder().s(keyVal).build());
itemValues.put(value, AttributeValue.builder().s(valueVal).build());
PutItemRequest request = PutItemRequest.builder().tableName(tableName).item(itemValues).build();
PutItemResponse response = ddb.putItem(request);

UPDATE keyspace.tablename 
SET column1 = 'col1Val',column1 = 'col2Val' 
  WHERE id = 'id123';

HashMap<String, AttributeValue> itemKey = new HashMap<>();
itemKey.put(key, AttributeValue.builder().s(keyVal).build());
HashMap<String, AttributeValueUpdate> updatedValues = new HashMap<>();
updatedValues.put(name, AttributeValueUpdate.builder().value(AttributeValue.builder().s(updateVal).build())
              .action(AttributeAction.PUT)
              .build());
UpdateItemRequest request = UpdateItemRequest.builder().tableName(tableName).key(itemKey)
                .attributeUpdates(updatedValues)
                .build();
ddb.updateItem(request);

//Delete data from specific columns in a row
DELETE col1, col2 FROM keyspace.table WHERE id = 'id123';
//Delete a row
DELETE  FROM keyspace.table WHERE id = 'id123';

HashMap<String, AttributeValue> keyToDelete = new HashMap<>();
keyToDelete.put(key, AttributeValue.builder().s(keyVal).build());
DeleteItemRequest deleteReq = DeleteItemRequest.builder().tableName(tableName).key(keyToDelete).build();
ddb.deleteItem(deleteReq);

//Select specific  columns in a row
SELECT col1, col2 FROM keyspace.table WHERE id = 'id123';
//Select all columns in a row
SELECT *  FROM keyspace.table WHERE id = 'id123';

// Set up an alias for the partition key name 
HashMap<String, String> attrNameAlias = new HashMap<String, String>();
attrNameAlias.put(partitionAlias, partitionKeyName);
 // Set up mapping of the partition name with the value.
HashMap<String, AttributeValue> attrValues = new HashMap<>();
attrValues.put(":" + partitionKeyName, AttributeValue.builder().s(partitionKeyVal).build());
QueryRequest queryReq = QueryRequest.builder()
  .tableName(tableName)
  .keyConditionExpression(partitionAlias + " = :" + partitionKeyName)
  .expressionAttributeNames(attrNameAlias)
  .expressionAttributeValues(attrValues)
                .build();
QueryResponse response = ddb.query(queryReq);

Conclusion

Apache Cassandra offers flexibility and control, making it suitable for applications requiring high availability and scalability, provided there is expertise to manage its complexity. There are enterprise edition versions of Cassandra like ScalaDB, AstraDB from DataStax, AWS Keyspaces, etc., available from different vendors. They also provide serverless versions, taking away the overhead of maintaining the DB.

Amazon DynamoDB, as a fully managed service, simplifies operations and provides scalability. It’s ideal for teams that want to focus on application development without getting into the nitty-gritty of infrastructure or capacity planning. DynamoDB’s seamless integration with other AWS services, built-in security, and automatic backups make it a strong choice for cloud-native applications and microservices. On the other hand, Cassandra provides more tuning knobs and control for on-prem or hybrid environments. 

Ultimately, the right choice depends on your team's operational maturity, latency tolerance, and budget flexibility. Both databases are powerful in their own ways — it’s just a matter of matching them to your specific use case and long-term strategy.