Databáze

Referenční přehled SQL a NoSQL databází: MongoDB, Redis, Cassandra, CouchDB, Neo4j, MySQL a PostgreSQL, doplněný o dovednosti návrhu, indexování a zabezpečení.

Co tato dovednost pokrývá

Tato stránka pokrývá práci s SQL i NoSQL databázovými technologiemi — připojování, dotazování, agregace a indexování v MongoDB, Redis, Cassandře, CouchDB, Neo4j, MySQL a PostgreSQL — spolu se základními postupy návrhu databází, výkonu, zabezpečení a zálohování.

Kdy ji použít

Při připojování nebo autentizaci vůči konkrétnímu databázovému enginu (MongoDB, Redis, Cassandra, CouchDB, Neo4j, MySQL, PostgreSQL)
Při psaní CRUD, agregačních nebo pokročilých dotazů nad dokumentovým, key-value, wide-column nebo grafovým úložištěm
Při návrhu nebo normalizaci relačního schématu a rozhodování, jak ho indexovat
Při diagnostice pomalých dotazů nebo plánování optimalizace výkonu (indexování, connection pooling, cachování, sharding)
Při aplikaci bezpečnostních postupů pro databáze (parametrizované dotazy, řízení přístupu, šifrování) nebo plánování zálohování a obnovy

NoSQL databáze

NoSQL databáze nabízejí flexibilní schéma a jsou navržené pro zpracování velkých objemů nestrukturovaných nebo částečně strukturovaných dat.

MongoDB

MongoDB je dokumentově orientovaná NoSQL databáze, která ukládá dokumenty podobné JSON s dynamickým schématem.

Připojení a autentizace

# Local connection
mongo
mongosh  # New MongoDB shell

# Remote connection
mongo "mongodb://username:password@hostname:27017/database_name"
mongosh "mongodb://username:password@hostname:27017/database_name"

# Connection with options
mongo --host hostname --port 27017 --username user --password --authenticationDatabase admin

Operace s databází

show dbs                  // List databases
db.adminCommand('listDatabases')  // Detailed list
use database_name          // Switch database
db                         // Current database
db.dropDatabase()          // Drop database
db.stats()                 // Database statistics

Operace s kolekcemi

show collections
db.listCollections()
db.createCollection("collection_name")
db.collection_name.stats()
db.collection_name.drop()

CRUD operace

// Insert documents
db.users.insertOne({name: "John", age: 30, email: "john@example.com"})
db.users.insertMany([{name: "Jane", age: 25}, {name: "Bob", age: 35}])

// Find documents
db.users.find()
db.users.find({age: {$gte: 25}})
db.users.find({name: "John"}).pretty()
db.users.findOne({_id: ObjectId("...")})

// Update documents
db.users.updateOne({name: "John"}, {$set: {age: 31}})
db.users.updateMany({age: {$lt: 30}}, {$set: {status: "young"}})
db.users.replaceOne({name: "John"}, {name: "John", age: 32, email: "john.doe@example.com"})

// Delete documents
db.users.deleteOne({name: "John"})
db.users.deleteMany({age: {$lt: 18}})

Pokročilé dotazy

// Comparison
db.users.find({age: {$gt: 25, $lte: 35}})

// Logical
db.users.find({$or: [{age: {$lt: 25}}, {age: {$gt: 35}}]})

// Array & element
db.users.find({skills: {$all: ["JavaScript", "MongoDB"]}})
db.users.find({skills: {$size: 3}})

// Regex
db.users.find({name: {$regex: /^J/}})

Příklad agregace

db.orders.aggregate([
    {$match: {status: "completed"}},
    {$group: {_id: "$customer_id", total: {$sum: "$amount"}}},
    {$sort: {total: -1}},
    {$limit: 10}
])

Indexování

db.users.createIndex({email: 1})             // Single field
db.users.createIndex({name: 1, age: -1})     // Compound
db.articles.createIndex({title: "text"})     // Text
db.places.createIndex({location: "2dsphere"}) // Geospatial
db.users.getIndexes()
db.users.dropIndex({email: 1})

Redis

Redis je in-memory úložiště datových struktur používané jako databáze, cache i message broker.

# Connect
redis-cli -h hostname -p 6379 -a password

Základní příkazy

# Strings
SET key "value"
GET key
INCR counter

# Lists
LPUSH mylist "a"
RPUSH mylist "b"
LRANGE mylist 0 -1

# Sets
SADD myset "member1"
SMEMBERS myset

# Hashes
HSET user:1 name "John" age "30"
HGETALL user:1

# Sorted Sets
ZADD leaderboard 100 "player1"
ZRANGE leaderboard 0 -1 WITHSCORES

Cassandra

Apache Cassandra je distribuovaná NoSQL databáze určená pro velké objemy dat.

cqlsh hostname 9042 -u username -p password

Operace s keyspace

CREATE KEYSPACE mykeyspace WITH REPLICATION = {'class':'SimpleStrategy', 'replication_factor':3};
USE mykeyspace;
DESCRIBE KEYSPACES;

Operace s tabulkami

CREATE TABLE users (user_id uuid PRIMARY KEY, name text, email text, age int);
INSERT INTO users (user_id, name, email, age) VALUES (uuid(), 'John Doe', 'john@example.com', 30);
SELECT * FROM users;
UPDATE users SET age = 31 WHERE user_id = uuid_value;
DELETE FROM users WHERE user_id = uuid_value;

CouchDB

Dokumentově orientovaná databáze s HTTP API a ukládáním dat ve formátu JSON.

# Create database
curl -X PUT http://admin:password@localhost:5984/mydb

# CRUD
curl -X POST http://admin:password@localhost:5984/mydb -H "Content-Type: application/json" -d '{"name":"John","age":30}'
curl -X GET http://admin:password@localhost:5984/mydb/doc_id
curl -X PUT http://admin:password@localhost:5984/mydb/doc_id -H "Content-Type: application/json" -d '{"_rev":"1-xxx","name":"John","age":31}'
curl -X DELETE http://admin:password@localhost:5984/mydb/doc_id?rev=revision_id

Neo4j

Grafová databáze pracující s uzly, vztahy a vlastnostmi.

// Nodes
CREATE (n:Person {name:'John', age:30})
CREATE (m:Person {name:'Jane', age:25})

// Relationships
MATCH (a:Person {name:'John'}), (b:Person {name:'Jane'})
CREATE (a)-[:KNOWS]->(b)

// Queries
MATCH (n:Person) RETURN n
MATCH (a:Person)-[r:KNOWS]->(b:Person) RETURN a, r, b
MATCH path = (a:Person)-[*]-(b:Person) RETURN path

SQL databáze

MySQL

mysql -u username -p database_name

Základní SQL

SHOW DATABASES;
USE database_name;
SHOW TABLES;

CREATE TABLE users (
  id INT AUTO_INCREMENT PRIMARY KEY,
  name VARCHAR(100) NOT NULL,
  email VARCHAR(100) UNIQUE,
  age INT,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO users (name, email, age) VALUES ('John Doe', 'john@example.com', 30);
SELECT * FROM users;
UPDATE users SET age=31 WHERE id=1;
DELETE FROM users WHERE id=1;

Spojení (JOIN)

SELECT u.name, o.amount
FROM users u
JOIN orders o ON u.id = o.user_id;

PostgreSQL

psql "postgresql://username:password@hostname:5432/database_name"

Pokročilé funkce

-- JSON operations
CREATE TABLE products (id SERIAL PRIMARY KEY, data JSONB);
INSERT INTO products (data) VALUES ('{"name":"Laptop","price":999}');
SELECT data->>'name' FROM products WHERE data->>'price'>'500';

-- Full-text search
SELECT * FROM articles WHERE to_tsvector('english', content) @@ to_tsquery('database & query');

-- Window functions
SELECT name, salary, RANK() OVER (ORDER BY salary DESC) AS rank FROM employees;

-- CTEs
WITH high_salary AS (
  SELECT * FROM employees WHERE salary > 50000
)
SELECT department, COUNT(*) FROM high_salary GROUP BY department;

Doporučené postupy návrhu databází

Normalizace

1NF: Odstranění opakujících se skupin
2NF: Odstranění částečných závislostí
3NF: Odstranění tranzitivních závislostí
BCNF: Zajištění, že všechny determinanty jsou kandidátními klíči

Strategie indexování

Indexujte sloupce, které jsou často dotazovány
Používejte složené indexy pro dotazy na více sloupců
Vyvažujte režii indexů s rychlostí dotazů
Sledujte a optimalizujte využití indexů

Optimalizace výkonu

Používejte EXPLAIN k analýze dotazů
Optimalizujte pomalé dotazy pomocí indexování
Implementujte connection pooling
Přidejte cachovací vrstvy (Redis, Memcached)
Zvažte sharding pro velké datové sady

Bezpečnostní doporučené postupy

Používejte parametrizované dotazy k prevenci SQL injection
Implementujte autentizaci a řízení přístupu na základě rolí
Šifrujte citlivá data v klidu i při přenosu
Pravidelně zálohujte databáze
Sledujte logy kvůli anomáliím

Zálohování a obnova

Automatizujte zálohování a testujte obnovu
Používejte point-in-time recovery, pokud je to možné
Ukládejte zálohy na více místech

← Zpět na úvod