Name: 20 databases to pick in 2023 - simplified
Rating: 4.5 (8755 reviews)
Author: johnrushx

Hi, I'm John, Multi Startup Builder.
I enjoy both coding and marketing.
See all my 20 products here
→ johnrush.me
→ my BIO
→ Say Hi to me On Twitter
→ Try my website builder

You thought you knew databases?

What database to use in 2023?
Which database is the best?
Which database is mostly used?
Which database is perfect?
Which database is most powerful?
What database is better than SQL?
Is MongoDB still popular?
Why is MySQL so popular?
Best database?

Think again!

I'm about to introduce you to 25 funky fresh databases that'll blow your socks off.

From classic favorites to cutting-edge newcomers,
get ready for a wild ride through database land!

1. MySQL - The Classic

CREATE TABLE users (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255));
INSERT INTO users (name) VALUES ('John Rush');
SELECT * FROM users;

MySQL is the trusted granddaddy of databases – it's been around since the dawn of time and somehow keeps getting better.
With solid performance and compatibility with almost every programming language on Earth, this old-timer isn't going anywhere.

2. MongoDB - NoSQL Hipster Kid

// Connect to MongoDB and insert a document
const { MongoClient } = require("mongodb");
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri);
await client.connect();
const db = client.db("mydb");
await db.collection("users").insertOne({ name: "John Rush" });

MongoDB is that cool NoSQL kid who doesn't care about rules.

It's all about storing data in flexible JSON-like documents, making it the go-to choice for developers looking for a schema-less solution.

3. PostgreSQL - The Sophisticated One

CREATE TABLE users (id SERIAL PRIMARY KEY, name VARCHAR(255));
INSERT INTO users (name) VALUES ('John Rush');
SELECT * FROM users;

PostgreSQL might just be the perfect blend of performance, features, and elegance.

With its powerful query language and support for custom types, this open-source gem has earned its place among top databases.

4. Oracle - The Enterprise Behemoth

CREATE TABLE users (id NUMBER GENERATED BY DEFAULT ON NULL AS IDENTITY PRIMARY KEY, name VARCHAR2(255));
INSERT INTO users (name) VALUES ('John Rush');
SELECT * FROM users;

Oracle is like that popular kid at school who gets straight A's but also plays on every sports team – it does everything well!

Sure, you'll need deep pockets to keep up with this high-roller database system used by major enterprises worldwide.

5. Cassandra - Distributed Dynamo

from cassandra.cluster import Cluster

cluster = Cluster(["127.0.0.1"])
session = cluster.connect()

session.execute("""
    CREATE KEYSPACE mykeyspace 
    WITH replication={'class':'SimpleStrategy', 'replication_factor':1}
""")

session.set_keyspace("mykeyspace")
session.execute("""
    CREATE TABLE users (
        id UUID PRIMARY KEY,
        name text
    )
""")

Cassandra is the queen bee of distributed databases – she's got scalability and fault tolerance for days! If you're looking to build a massive, high-performing application, this NoSQL database might be your new best friend.

6. Redis - The Speedster

import redis

r = redis.Redis(host="localhost", port=6379)
r.set("name", "John Rush")
print(r.get("name"))

Redis is that one friend who can sprint faster than Usain Bolt while juggling flaming chainsaws. This in-memory data store is blazingly fast and perfect for caching or real-time applications.

7. MariaDB - MySQL’s Open-Source Sibling

CREATE TABLE users (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255));
INSERT INTO users (name) VALUES ('John Rush');
SELECT * FROM users;

MariaDB shares much of its DNA with MySQL but focuses on being open-source and community-driven. It's like choosing between Pepsi and Coke – they both quench your thirst; it just depends on which flavor you prefer!

8. SQLite - The Lightweight Champion

import sqlite3

conn = sqlite3.connect(":memory:")
c = conn.cursor()
c.execute("""CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);""")
c.execute("""INSERT INTO users (name) VALUES ('John Rush');""")
conn.commit()

for row in c.execute("SELECT * FROM users"):
    print(row)

SQLite packs a punch in a featherweight package. It's a self-contained, serverless SQL database that's perfect for small projects and applications where simplicity is key.

9. YugabyteDB - The Postgres Powerhouse

CREATE TABLE users (id SERIAL PRIMARY KEY, name VARCHAR(255));
INSERT INTO users (name) VALUES ('John Rush');
SELECT * FROM users;

YugabyteDB takes the best of PostgreSQL and adds distributed magic sauce! This high-performance, cloud-native database supports horizontal scaling and multi-cloud deployments while maintaining full compatibility with Postgres.

10. Neo4j - All About Relationships

CREATE (john:User {name: "John Rush"});
MATCH (user:User) RETURN user;

Neo4j makes complicated relationships look like child's play with its graph-based data model. Traverse complex networks at lightning speeds – making it ideal for social networking or recommendation engines!

11. Dolt - Git Meets Database World

$ dolt init && dolt sql <<EOF
CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255)
);
INSERT INTO users(name) VALUES ("John Rush");
SELECT * FROM_users;
EOF

Dolt lets you branch out from the norm by combining MySQL-style databases with Git-like version control features! Experiment without fear; merge changes when ready in this innovative hybrid database system.

12. CockroachDB - NewSQL Innovator

CREATE TABLE users (id UUID DEFAULT gen_random_uuid() PRIMARY KEY, name STRING);
INSERT INTO users (name) VALUES ('John Rush');
SELECT * FROM users;

CockroachDB skitters into view as a powerful NewSQL solution built from the ground up for cloud-native environments. With Postgres compatibility and horizontal scaling, it's a force to be reckoned with!

13. Planetscale - Scaling MySQL to Infinity

CREATE TABLE users (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255));
INSERT INTO users (name) VALUES ('John Rush');
SELECT * FROM users;

Remember YouTube's struggles scaling MySQL? Well, Planetscale does just that! It takes VTest technology developed by YouTube and offers a fully managed serverless platform for scaling MySQL without breaking a sweat.

14. Google Cloud Spanner - The Global Database

const {Spanner} = require("@google-cloud/spanner");
const spanner = new Spanner();
const instance = spanner.instance("my-instance");
const database = instance.database("my-database");

await database.run({
    sql: "CREATE TABLE Users (Id STRING(MAX) NOT NULL, Name STRING(MAX)) PRIMARY KEY(Id)"
});

await database.run({ sql: "INSERT Users (Id, Name) VALUES('1', 'John Rush')" });

Need consistent data across continents? Google Cloud Spanner has got you covered! This globally distributed SQL database ensures your data is always available while providing strong consistency guarantees.

15. Xata - Spreadsheet-like Simplicity

import xatasheet_client as xata

client = xata.Client()
sheet_id = client.create_sheet(title="Users")
rows_added_count = client.insert_rows(sheet_id= sheet_id,
                                      rows=[{"column": "Name", "value": "John Rush"}])
print(f"Rows added count: {rows_added_count}")

Xata brings spreadsheet-level simplicity to relational databases! Built on top of Postgres and Elasticsearch, it offers full-text search, easy-to-visualize relationships, and an API for TypeScript and Python.

16. Amazon Aurora - AWS's Database Darling

import boto3
rds = boto3.client("rds-data")

response = rds.execute_statement(
    resourceArn="arn:aws:rds:us-west-2:123456789012:cluster:mysql-cluster",
    secretArn="arn:aws:secretsmanager:us-west-2::secret:mysql-pass",
    sql="CREATE TABLE users (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255));"
)

Amazon Aurora brings the power of MySQL or PostgreSQL to the AWS ecosystem with even better performance! It scales automatically while integrating seamlessly with other AWS services.

17. Microsoft SQL Server - The Trusted Workhorse

CREATE TABLE Users (Id INT IDENTITY(1,1) PRIMARY KEY NOT NULL,
                    Name NVARCHAR(MAX));
INSERT INTO Users(Name) VALUES(N'John Rush');
SELECT * FROM Users;

Microsoft SQL Server has been a reliable powerhouse in the database world for decades! With strong security features and integration with Azure cloud services, it remains a popular choice among businesses large and small.

18. Apache HBase - Big Data Behemoth

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

Put putData = new Put(Bytes.toBytes("row"));
putData.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("name"), Bytes.toBytes("John Rush"));
table.put(putData);

ResultScanner resultsScanner = table.getScanner(new Scan());
for (Result res : resultsScanner) {
    System.out.println(res);
}

Apache HBase is the go-to choice for those dealing with massive amounts of unstructured data! As a part of the Apache Hadoop ecosystem, it offers high write throughput and low-latency reads.

19. TimescaleDB - Time Series Titan

CREATE TABLE users (
    time TIMESTAMPTZ NOT NULL,
    name TEXT NOT NULL
);
SELECT create_hypertable('users', 'time');
INSERT INTO users(time, name) VALUES(NOW(), 'John Rush');
SELECT * FROM users;

TimescaleDB takes PostgreSQL and adds a time series twist! Built as an extension to PostgreSQL, this newcomer shines when you're dealing with large-scale data that changes over time – such as IoT devices or analytics.

20. FaunaDB - Serverless Superstar

const faunadb = require("faunadb");
const q = faunadb.query;
const client = new faunadb.Client({ secret: "your-secret-key" });

await client.query(
  q.CreateCollection({ name: "users" })
);

await client.query(
  q.Create(q.Collection("users"), { data: { name: "John Rush" } })
);

FaunaDB swoops in as a serverless cloud database designed for modern applications. It offers GraphQL and custom functions, along with global consistency and built-in security features.

21. InfluxData - DevOps Dynamo

# Write Data
curl --request POST 'http://localhost:8086/write?db=mydb' \
--data-binary 'user,name="John Rush"'
# Query Data
curl --get 'http://localhost:8086/query' \
--data-urlencode "db=mydb&q=SELECT * FROM user"

InfluxData is tailor-made for monitoring metrics and events in your infrastructure. Its powerful query language can help identify trends, anomalies, or other valuable insights from your time-series data.

22. Memgraph - Graph Database Prodigy

from mgclient import connect

connection = connect(host='127.0.0.1', port=7687)
cursor = connection.cursor()

cursor.execute('CREATE (:User{name:"John Rush"})')
cursor.execute('MATCH (u:User) RETURN u.name')
for row in cursor.fetchall():
    print(row)

Memgraph is a high-performance, in-memory graph database built for real-time analytics. Its compatibility with Cypher query language makes it an excellent choice for those familiar with Neo4j.

23. Riak KV - Key-Value Connoisseur

import riak

client = riak.RiakClient()
bucket = client.bucket("users")
user_key = bucket.new("johnrush", data={"name": "John Rush"})
user_key.store()

fetched_user = bucket.get("johnrush")
print(fetched_user.data)

Riak KV provides a highly available and distributed key-value store that can handle heavy loads without breaking a sweat. It's perfect for use cases like gaming, ad tech, or mobile applications.

24. KeyDB - Redis on Steroids

from keydb import Client as KeyDBClient

keydb_client = KeyDBClient(host="localhost", port=6379)
keydb_client.set("name", "John Rush")
print(keydb_client.get("name"))

KeyDB takes everything you love about Redis and cranks it up to eleven! With multithreading support and improved performance, this open-source alternative might just be your new go-to caching solution.

25. MeiliSearch - Full-Text Search Extraordinaire

import meilisearch

client = meilisearch.Client('http://127.0.0.1:7700')
index = client.create_index(uid='users')

index.add_documents([{'id': '1', 'name': 'John Rush'}])
results = index.search('John')
print(results.hits)

MeiliSearch brings the power of full-text search to your fingertips with minimal setup! This ultra-fast, typo-tolerant search engine can be integrated into any application in a matter of minutes.

There you have it – 25 databases that'll make you rethink everything you thought you knew about data storage!

If this tour has left you hungry for more amazing content, don't forget to follow me on Twitter @johnrushx where I share my thoughts on transforming the software development world.

Hi, I'm John, Multi Startup Builder.
I enjoy both coding and marketing.
See all my 20 products here
→ johnrush.me
→ my BIO
→ Say Hi to me On Twitter
→ Try my website builder