20 databases to pick in 2023 - simplified
Tags: database, tutorial, beginners, backend
Published: 2023-06-09 19:27:31

> Hi, I'm John, Multi Startup Builder.
> I enjoy both coding and marketing.
> See all my 20 products here
> → [johnrush.me](https://johnrush.me/)
> → [my BIO ](https://twitter.com/johnrushx/bio)
> → [Say Hi to me On Twitter](https://twitter.com/johnrushx)
> → [Try my website builder](https://unicornplatform.com/)

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! 

![ExcitedComputerGuy](https://media.giphy.com/media/y4E6VumnBbIfm/giphy.gif)

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

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

![ExcitedComputerGuy](https://media.giphy.com/media/mGj3SVN7xbPQ4/giphy.gif)

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

```javascript
// 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" });
```

![hipster](https://media.giphy.com/media/HBbA0gf8uemuQ/giphy.gif)

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

```sql
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.

![FancyCat](https://media.giphy.com/media/vgGTiKVDMYMw0/giphy.gif)

## 4. Oracle - The Enterprise Behemoth

```sql
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.

![big bro](https://media.giphy.com/media/v0ok8uhZvw3yE/giphy.gif)

## 5. Cassandra - Distributed Dynamo

```python
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

```python
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.

![UsainBolt](https://media.giphy.com/media/d4blalI6x2oc4xAA/giphy.gif)

## 7. MariaDB - MySQL’s Open-Source Sibling 

```sql
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

```python
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

```sql
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

```cypher
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

```bash
$ 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.

![blond](https://media.giphy.com/media/Jxhb1p6wm1eTu/giphy.gif)

## 12. CockroachDB - NewSQL Innovator

```sql
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

```sql
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.

![BigBang](https://media.giphy.com/media/10kxE34bJPaUO4/giphy.gif)

## 14. Google Cloud Spanner - The Global Database

```javascript
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

```python
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

```python
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

```sql
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.

![WorkHorse](https://media.giphy.com/media/l0MYt5jPR6QX5pnqM/giphy.gif)

## 18. Apache HBase - Big Data Behemoth

```java
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

```sql
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

```javascript
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

```sh
# 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

```python
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

```python
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

```python
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.

![Steroids](https://media.giphy.com/media/eiFmw5bO0sNg2sXgv6/giphy.gif)

## 25. MeiliSearch - Full-Text Search Extraordinaire 

```python
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!

![MindBlown](https://media.giphy.com/media/SIYutztmnf75jZQrVj/giphy.gif)

If this tour has left you hungry for more amazing content, don't forget to follow me on Twitter [@johnrushx](https://twitter.com/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](https://johnrush.me/)
> → [my BIO ](https://twitter.com/johnrushx/bio)
> → [Say Hi to me On Twitter](https://twitter.com/johnrushx)
> → [Try my website builder](https://unicornplatform.com/)