Pros of Cassandra

• Better scalability and performance for write-heavy workloads
• Simpler architecture with no single point of failure
• More flexible data model with support for wide rows and dynamic columns

Cons of Cassandra

• Less mature ecosystem and tooling compared to HBase
• Limited support for complex queries and joins
• Eventual consistency model may not be suitable for all use cases

Code Comparison

Cassandra CQL:

CREATE TABLE users (
  user_id uuid PRIMARY KEY,
  name text,
  email text
);

HBase Shell:

create 'users', 'info'
put 'users', '1', 'info:name', 'John Doe'
put 'users', '1', 'info:email', 'john@example.com'

Both Cassandra and HBase are distributed NoSQL databases, but they have different data models and use cases. Cassandra uses a wide-column store model and is optimized for write-heavy workloads, while HBase is based on Google's BigTable and is better suited for read-heavy workloads with strong consistency requirements.

Cassandra's decentralized architecture allows for easier scaling and higher availability, but it comes at the cost of eventual consistency. HBase, on the other hand, provides strong consistency and better support for complex queries, but its architecture is more complex and relies on a separate distributed file system (usually HDFS).

When choosing between the two, consider your specific use case, scalability requirements, and consistency needs.

Pros of Accumulo

• Enhanced security features, including cell-level security and visibility labels
• Better support for high-cardinality row keys and fast lookups
• More efficient data compaction and improved write performance

Cons of Accumulo

• Smaller community and ecosystem compared to HBase
• Steeper learning curve due to unique features and abstractions
• Less widespread adoption in industry, potentially limiting job opportunities

Code Comparison

Accumulo:

Scanner scanner = connector.createScanner("table", auths);
scanner.setRange(new Range("row1", "row2"));
scanner.fetchColumnFamily("cf");
for (Entry<Key, Value> entry : scanner) {
    // Process entry
}

HBase:

Scan scan = new Scan(Bytes.toBytes("row1"), Bytes.toBytes("row2"));
scan.addFamily(Bytes.toBytes("cf"));
ResultScanner scanner = table.getScanner(scan);
for (Result result : scanner) {
    // Process result
}

Both Accumulo and HBase are distributed NoSQL databases built on top of Hadoop. While they share similar foundations, Accumulo offers advanced security features and better performance in certain scenarios. However, HBase benefits from a larger community and wider adoption. The code comparison shows similarities in their scanning APIs, with slight differences in syntax and method names.

Pros of RocksDB

• Designed for high-performance storage with better read/write speeds
• Optimized for SSDs and fast storage devices
• More flexible and customizable for specific use cases

Cons of RocksDB

• Lacks built-in distributed system capabilities
• Requires more manual configuration and tuning
• Limited support for complex queries compared to HBase

Code Comparison

RocksDB (C++):

rocksdb::DB* db;
rocksdb::Options options;
options.create_if_missing = true;
rocksdb::Status status = rocksdb::DB::Open(options, "/path/to/db", &db);

HBase (Java):

Configuration config = HBaseConfiguration.create();
Connection connection = ConnectionFactory.createConnection(config);
Table table = connection.getTable(TableName.valueOf("tablename"));

RocksDB is a high-performance embedded database for key-value data, optimized for fast storage. It offers better read/write speeds and is more customizable for specific use cases. However, it lacks built-in distributed capabilities and requires more manual configuration.

HBase, on the other hand, is a distributed, scalable database built on top of Hadoop. It provides better support for complex queries and comes with built-in distributed system capabilities. However, it may have lower performance for certain workloads compared to RocksDB.

The code examples show the basic setup for each database. RocksDB uses C++ and focuses on local storage, while HBase uses Java and emphasizes distributed operations.

Pros of Hadoop

• More versatile for general-purpose distributed computing and data processing
• Better suited for batch processing of large datasets
• Wider ecosystem with tools like Pig, Hive, and Spark integration

Cons of Hadoop

• Higher complexity and steeper learning curve
• Less efficient for real-time data access and processing
• Requires more hardware resources for optimal performance

Code Comparison

Hadoop (MapReduce example):

public class WordCount extends Configured implements Tool {
  public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable> {
    private final static IntWritable one = new IntWritable(1);
    private Text word = new Text();
    public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
      StringTokenizer itr = new StringTokenizer(value.toString());

HBase (Data manipulation example):

Table table = connection.getTable(TableName.valueOf("mytable"));
Put put = new Put(Bytes.toBytes("row1"));
put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("qual1"), Bytes.toBytes("value1"));
table.put(put);

Hadoop is better suited for large-scale data processing and analytics, while HBase excels at providing real-time read/write access to large datasets. Hadoop offers a more comprehensive ecosystem for various data processing tasks, but HBase provides faster access to specific data points within massive datasets.

Pros of MongoDB

• Flexible schema design allows for easier adaptation to changing data structures
• Better performance for read-heavy workloads and real-time analytics
• Simpler setup and configuration, especially for smaller scale deployments

Cons of MongoDB

• Less suitable for complex, multi-row transactions compared to HBase
• May consume more storage space due to document-based structure
• Lacks some advanced features like cell-level security available in HBase

Code Comparison

MongoDB query example:

db.users.find({ age: { $gt: 25 } }).sort({ name: 1 })

HBase query example (using Java API):

Scan scan = new Scan();
scan.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("age"));
scan.setFilter(new SingleColumnValueFilter(
    Bytes.toBytes("cf"), Bytes.toBytes("age"),
    CompareOperator.GREATER, Bytes.toBytes("25")));

Both MongoDB and HBase are popular NoSQL databases, but they serve different use cases. MongoDB excels in flexibility and ease of use, making it suitable for rapid development and document-oriented data. HBase, on the other hand, offers better scalability for massive datasets and provides stronger consistency guarantees, making it more appropriate for certain big data applications.