SQL vs NoSQL: Bases de datos relacionales vs orientadas a documentos y casos de uso

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Este artículo presenta un análisis exhaustivo de bases de datos SQL y NoSQL, enfocándose en las bases de datos relacionales (MySQL, PostgreSQL) y orientadas a documentos (MongoDB), junto con sus casos de uso prácticos.

En resumen

Las bases de datos SQL son relacionales con esquema fijo, mientras que las NoSQL ofrecen flexibilidad con esquema dinámico. La elección depende de la estructura de datos, escalabilidad y requisitos de la aplicación.

Descripción técnica

SQL (Structured Query Language) y NoSQL (Not Only SQL) representan dos enfoques fundamentalmente diferentes para almacenar datos.

Bases de datos SQL (Relacionales)

• Esquema: Predefinido y riguroso
• Estructura: Tablas con filas y columnas
• ACID: Atomicity, Consistency, Isolation, Durability
• Ejemplos: MySQL, PostgreSQL, Oracle, SQL Server
• Consultas: SQL con JOINS, agregaciones, subconsultas

Bases de datos NoSQL (Orientadas a documentos)

• Esquema: Flexible y dinámico
• Estructura: Documentos JSON/BSON
• BASE: Basically Available, Soft state, Eventually consistent
• Ejemplos: MongoDB, CouchDB, DynamoDB
• Consultas: Lenguaje de consulta, Aggregation Pipelines

Diferencias clave:

• Modelo de datos: Relacional vs orientado a documentos
• Escalabilidad: Vertical vs horizontal
• Consistencia: Fuerte vs eventual
• Flexibilidad: Esquema fijo vs dinámico

Puntos clave de referencia

• SQL: Bases de datos relacionales con esquema fijo y propiedades ACID
• NoSQL: Bases de datos orientadas a documentos con esquema flexible
• MySQL/PostgreSQL: Bases de datos relacionales populares
• MongoDB: Base de datos NoSQL orientada a documentos ampliamente utilizada
• Casos de uso: SQL para datos estructurados, NoSQL para datos flexibles
• Escalabilidad: SQL vertical, NoSQL horizontal
• Consistencia: SQL fuerte, NoSQL eventual
• Relevancia profesional: Importante para el diseño y selección de bases de datos

Componentes principales

1. Bases de datos SQL: Tablas, esquemas, JOINS, ACID
2. Bases de datos NoSQL: Documentos, colecciones, esquemas flexibles
3. Modelo de datos: Relacional vs orientado a documentos
4. Lenguajes de consulta: SQL vs lenguaje de consulta NoSQL
5. Escalabilidad: Vertical vs horizontal
6. Modelos de consistencia: ACID vs BASE
7. Casos de uso: Datos estructurados vs flexibles
8. Rendimiento: Optimización de lectura/escritura

Ejemplos prácticos

1. Ejemplo de base de datos SQL (MySQL/PostgreSQL)

-- Definición del schema
CREATE TABLE kunden (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    geburtsdatum DATE,
    adresse_id INT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (adresse_id) REFERENCES adressen(id)
);

CREATE TABLE adressen (
    id INT PRIMARY KEY AUTO_INCREMENT,
    strasse VARCHAR(255) NOT NULL,
    stadt VARCHAR(100) NOT NULL,
    plz VARCHAR(10) NOT NULL,
    land VARCHAR(50) DEFAULT 'Deutschland'
);

CREATE TABLE bestellungen (
    id INT PRIMARY KEY AUTO_INCREMENT,
    kunden_id INT NOT NULL,
    bestelldatum DATE NOT NULL,
    gesamtbetrag DECIMAL(10,2) NOT NULL,
    status ENUM('pending', 'processing', 'shipped', 'delivered') DEFAULT 'pending',
    FOREIGN KEY (kunden_id) REFERENCES kunden(id) ON DELETE CASCADE
);

-- Manipulación de datos
INSERT INTO kunden (name, email, geburtsdatum, adresse_id) 
VALUES ('Max Mustermann', 'max@example.com', '1990-05-15', 1);

INSERT INTO adressen (strasse, stadt, plz) 
VALUES ('Hauptstraße 1', 'Berlin', '10115');

-- Consulta compleja con JOINS
SELECT 
    k.name,
    k.email,
    k.geburtsdatum,
    a.strasse,
    a.stadt,
    COUNT(b.id) as anzahl_bestellungen,
    SUM(b.gesamtbetrag) as umsatz
FROM kunden k
LEFT JOIN adressen a ON k.adresse_id = a.id
LEFT JOIN bestellungen b ON k.id = b.kunden_id
WHERE k.geburtsdatum BETWEEN '1980-01-01' AND '1995-12-31'
    AND a.stadt = 'Berlin'
GROUP BY k.id, k.name, k.email, k.geburtsdatum, a.strasse, a.stadt
HAVING COUNT(b.id) > 0
ORDER BY umsatz DESC
LIMIT 10;

-- Transacción con propiedades ACID
BEGIN TRANSACTION;

UPDATE bestellungen 
SET status = 'shipped', 
    bestelldatum = CURRENT_DATE 
WHERE id = 123 AND status = 'pending';

INSERT INTO versand (bestellung_id, tracking_nummer, versanddatum)
VALUES (123, 'DE123456789', CURRENT_DATE);

COMMIT;

2. Ejemplo de base de datos NoSQL (MongoDB)

// MongoDB JavaScript Shell

// Colección y documentos (no se requiere esquema)
db.kunden.insertOne({
    name: "Max Mustermann",
    email: "max@example.com",
    geburtsdatum: new Date("1990-05-15"),
    adresse: {
        strasse: "Hauptstraße 1",
        stadt: "Berlin",
        plz: "10115",
        land: "Deutschland"
    },
    interessen: ["programmieren", "lesen", "reisen"],
    premium: true,
    created: new Date()
});

// Estructura flexible - campos diferentes posibles
db.kunden.insertMany([
    {
        name: "Alice Schmidt",
        email: "alice@example.com",
        alter: 28,
        adresse: {
            strasse: "Musterstraße 5",
            stadt: "Hamburg",
            plz: "20095"
        },
        interessen: ["design", "fotografia"],
        social_media: {
            twitter: "@alice_design",
            instagram: "alice.photos"
        }
    },
    {
        name: "Bob Weber",
        email: "bob@example.com",
        alter: 35,
        adresse: {
            strasse: "Bahnhofstraße 10",
            stadt: "München",
            plz: "80331",
            land: "Deutschland"
        },
        firma: {
            name: "TechCorp",
            position: "Senior Developer",
            seit: new Date("2018-03-01")
        },
        interessen: ["programmierung", "klettern", "kochen"]
    }
]);

// Pedidos como colección separada
db.bestellungen.insertOne({
    kunden_id: ObjectId("..."), // Referencia a clientes
    positionen: [
        {
            produkt: "Laptop",
            anzahl: 1,
            preis: 999.99
        },
        {
            produkt: "Maus",
            anzahl: 2,
            preis: 29.99
        }
    ],
    gesamtbetrag: 1059.97,
    status: "pending",
    bestelldatum: new Date(),
    zahlung: {
        methode: "credit_card",
        status: "paid",
        transaktions_id: "txn_123456789"
    }
});

// Pipeline de agregación compleja
db.kunden.aggregate([
    {
        $match: {
            "adresse.stadt": "Berlin",
            premium: true
        }
    },
    {
        $lookup: {
            from: "bestellungen",
            localField: "_id",
            foreignField: "kunden_id",
            as: "bestellungen"
        }
    },
    {
        $addFields: {
            anzahl_bestellungen: { $size: "$bestellungen" },
            umsatz: {
                $sum: "$bestellungen.gesamtbetrag"
            }
        }
    },
    {
        $project: {
            name: 1,
            email: 1,
            "adresse.stadt": 1,
            interessen: 1,
            anzahl_bestellungen: 1,
            umsatz: 1,
            avg_bestellwert: {
                $divide: ["$umsatz", "$anzahl_bestellungen"]
            }
        }
    },
    {
        $sort: {
            umsatz: -1
        }
    },
    {
        $limit: 10
    }
]);

// Consultas flexibles con campos dinámicos
db.kunden.find({
    $or: [
        { "interessen": "programmieren" },
        { "firma.name": { $exists: true } },
        { alter: { $gte: 30, $lte: 40 } }
    ],
    "adresse.land": "Deutschland"
}).sort({ "name": 1 });

// Búsqueda de texto con índice
db.kunden.createIndex({ name: "text", "interessen": "text" });

db.kunden.find({
    $text: { $search: "programmieren reisen" }
});

3. Comparación de casos de uso: plataforma de comercio electrónico

-- Enfoque SQL para datos estructurados
-- Productos con atributos fijos
CREATE TABLE produkte (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(255) NOT NULL,
    beschreibung TEXT,
    preis DECIMAL(10,2) NOT NULL,
    kategorie_id INT,
    lagerbestand INT DEFAULT 0,
    gewicht DECIMAL(5,2),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (kategorie_id) REFERENCES kategorien(id)
);

-- Categorías con jerarquía
CREATE TABLE kategorien (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    parent_id INT,
    ebene INT NOT NULL,
    FOREIGN KEY (parent_id) REFERENCES kategorien(id)
);

-- Pedidos con garantía ACID
CREATE TABLE bestellungen (
    id INT PRIMARY KEY AUTO_INCREMENT,
    kunden_id INT NOT NULL,
    status ENUM('pending', 'paid', 'shipped', 'delivered', 'cancelled') DEFAULT 'pending',
    gesamtbetrag DECIMAL(10,2) NOT NULL,
    bestelldatum TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (kunden_id) REFERENCES kunden(id)
);

BEGIN TRANSACTION;
-- Procesamiento de pedidos atómico
INSERT INTO bestellungen (kunden_id, gesamtbetrag, status)
VALUES (123, 299.99, 'paid');

UPDATE produkte 
SET lagerbestand = lagerbestand - 1 
WHERE id = 456;

INSERT INTO bestellpositionen (bestellung_id, produkt_id, menge, preis)
VALUES (LAST_INSERT_ID(), 456, 1, 299.99);

COMMIT;

// Enfoque NoSQL para datos flexibles
// Productos con atributos variables
db.produkte.insertOne({
    name: "Smartphone XYZ",
    beschreibung: "Modernes Smartphone mit vielen Features",
    preis: 599.99,
    kategorie: "Elektronik",
    lagerbestand: 150,
    eigenschaften: {
        marke: "TechBrand",
        modell: "XYZ Pro",
        farbe: ["schwarz", "weiß", "blau"],
        speicher: ["64GB", "128GB", "256GB"],
        anzeige: {
            groesse: "6.1 Zoll",
            aufloesung: "1080x2340",
            technologie: "OLED"
        },
        kamera: {
            hauptkamera: "48MP",
            frontkamera: "12MP",
            features: ["Nachtmodus", "Portrait", "4K Video"]
        },
        konnektivitaet: ["5G", "WiFi 6", "Bluetooth 5.0", "NFC"]
    },
    bewertungen: [
        {
            sterne: 5,
            kommentar: "Tolles Gerät!",
            datum: new Date("2024-01-15")
        },
        {
            sterne: 4,
            kommentar: "Gutes Preis-Leistungs-Verhältnis",
            datum: new Date("2024-01-20")
        }
    ],
    tags: ["smartphone", "5g", "kamera", "premium"]
});

// Pedidos flexibles con diferentes métodos de pago
db.bestellungen.insertOne({
    kunden_id: ObjectId("..."),
    status: "paid",
    gesamtbetrag: 599.99,
    positionen: [
        {
            produkt_id: ObjectId("..."),
            produkt_name: "Smartphone XYZ",
            variante: {
                farbe: "schwarz",
                speicher: "128GB"
            },
            menge: 1,
            einzelpreis: 599.99,
            gesamtpreis: 599.99
        }
    ],
    zahlung: {
        methode: "credit_card",
        karte: {
            typ: "visa",
            letzte_zahlen: "1234",
            ablaufdatum: "12/25"
        },
        status: "paid",
        transaktions_id: "txn_abc123",
        zahlungsdatum: new Date()
    },
    versand: {
        methode: "standard",
        adresse: {
            name: "Max Mustermann",
            strasse: "Hauptstraße 1",
            stadt: "Berlin",
            plz: "10115",
            land: "Deutschland"
        },
        tracking: {
            nummer: "DE123456789",
            status: "shipped",
        }
    },
    created: new Date()
});

4. Comparación de rendimiento

# Python Comparación de rendimiento

import time
import sqlite3
import pymongo
from pymongo import MongoClient

# Test de rendimiento SQL
def sql_performance_test():
    conn = sqlite3.connect(':memory:')
    cursor = conn.cursor()
    
    # Crear tablas
    cursor.execute('''
        CREATE TABLE users (
            id INTEGER PRIMARY KEY,
            name TEXT,
            email TEXT,
            age INTEGER
        )
    ''')
    
    # Insertar datos
    start = time.time()
    for i in range(10000):
        cursor.execute(
            'INSERT INTO users (name, email, age) VALUES (?, ?, ?)',
            (f'User {i}', f'user{i}@example.com', 20 + i % 50)
        )
    sql_insert_time = time.time() - start
    
    # Consultas
    start = time.time()
    cursor.execute('SELECT * FROM users WHERE age BETWEEN 30 AND 40')
    results = cursor.fetchall()
    sql_query_time = time.time() - start
    
    conn.close()
    
    return sql_insert_time, sql_query_time, len(results)

# Test de rendimiento NoSQL
def nosql_performance_test():
    client = MongoClient('localhost', 27017)
    db = client['test_db']
    users = db['users']
    
    # Insertar datos
    start = time.time()
    documents = []
    for i in range(10000):
        documents.append({
            'name': f'User {i}',
            'email': f'user{i}@example.com',
            'age': 20 + i % 50
        })
    
    users.insert_many(documents)
    nosql_insert_time = time.time() - start
    
    # Consultas
    start = time.time()
    results = users.find({'age': {'$gte': 30, '$lte': 40}})
    count = len(list(results))
    nosql_query_time = time.time() - start
    
    client.close()
    
    return nosql_insert_time, nosql_query_time, count

# Ejecutar comparación de rendimiento
print("Performance-Vergleich:")
sql_insert, sql_query, sql_count = sql_performance_test()
nosql_insert, nosql_query, nosql_count = nosql_performance_test()

print(f"SQL - Insert: {sql_insert:.4f}s, Query: {sql_query:.4f}s, Results: {sql_count}")
print(f"NoSQL - Insert: {nosql_insert:.4f}s, Query: {nosql_query:.4f}s, Results: {nosql_count}")

IRC-Security.de

Cybersecurity Artikel und Tutorials

Orientación para la decisión: SQL vs NoSQL

Cuándo usar SQL

Datos estructurados:

• Datos financieros y contabilidad
• Información de clientes con atributos fijos
• Pedidos con campos predefinidos
• Inventario con propiedades estandarizadas

Requisitos ACID:

• Transacciones bancarias
• Sistemas de contabilidad
• Procesamiento de pedidos en comercio electrónico
• Sistemas de reservas

Consultas complejas:

• Reportes con JOINS
• Agregaciones entre múltiples tablas
• Análisis de datos con filtros elaborados

Cuándo usar NoSQL

Estructuras de datos flexibles:

• Sistemas de gestión de contenidos
• Posts en redes sociales
• Datos de sensores IoT
• Perfiles de usuario con atributos variables

Escalabilidad horizontal:

• Aplicaciones Big Data
• Redes sociales
• Análisis en tiempo real
• Microservicios

Prototipado rápido:

• Startups con requisitos cambiantes
• MVPs
• Desarrollo ágil

Ventajas y desventajas

Bases de datos SQL

Ventajas:

• Propiedades ACID: garantías fuertes de consistencia
• Estándar: SQL como estándar establecido
• Herramientas: muchas herramientas y frameworks disponibles
• Integridad de datos: constraints e integridad referencial

Desventajas:

• Rigidez del esquema: cambios laboriosos
• Escalabilidad: principalmente escalado vertical
• Rendimiento: con volúmenes de datos muy grandes
• Flexibilidad: limitada para datos no estructurados

Bases de datos NoSQL

Ventajas:

• Esquema flexible: Adaptación sencilla a nuevos requisitos
• Escalabilidad horizontal: Distribución fácil entre múltiples servidores
• Rendimiento: Optimizado para grandes volúmenes de datos
• Amigable para desarrolladores: Estructuras de datos similares a JSON

Desventajas:

• Consistencia: Eventual Consistency en lugar de ACID
• Estandarización: Ausencia de un estándar único
• Herramientas: Menos maduras y especializadas
• Complejidad: Transacciones y JOINS más complejos

Estrategias de migración

Migración de SQL a NoSQL

// Mapeo de esquema para migración
const migrationMapping = {
    users: {
        sql_table: 'users',
        nosql_collection: 'users',
        fields: {
            id: '_id',
            name: 'name',
            email: 'email',
            created_at: 'created'
        },
        // Reglas de transformación
        transform: (row) => ({
            _id: row.id.toString(),
            name: row.name,
            email: row.email,
            created: new Date(row.created_at),
            profile: {
                age: row.age || null,
                preferences: []
            }
        })
    }
};

// Script de migración
async function migrateToNoSQL(sqlConnection, mongoConnection) {
    for (const [collectionName, mapping] of Object.entries(migrationMapping)) {
        const sqlData = await sqlConnection.query(`SELECT * FROM ${mapping.sql_table}`);
        
        for (const row of sqlData) {
            const transformedData = mapping.transform(row);
            await mongoConnection.collection(mapping.nosql_collection).insertOne(transformedData);
        }
    }
}

Preguntas frecuentes en exámenes

1. ¿Cuál es la diferencia principal entre SQL y NoSQL? SQL: esquema fijo, ACID, datos relacionales. NoSQL: esquema flexible, BASE, datos orientados a documentos.

2. ¿Cuándo elegirías NoSQL en lugar de SQL? Con estructuras de datos flexibles, requisitos de escalabilidad horizontal y Big Data.

3. ¡Explica ACID vs BASE! ACID: Atomicity, Consistency, Isolation, Durability (consistencia fuerte). BASE: Basically Available, Soft state, Eventually consistent.

4. ¿Cuáles son las desventajas de las bases de datos NoSQL? Estándares menos establecidos, garantías de consistencia más débiles, herramientas menos maduras.

Fuentes principales

1. https://www.mongodb.com/compare/sql-nosql/
2. https://www.postgresql.org/about/
3. https://dev.mysql.com/doc/refman/8.0/en/

FAQ: SQL vs NoSQL

Lecturas recomendadas: Bases de datos

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert