Ejercicios resueltos de Bases de Datos

import sys registros = []          # (id, nombre) en el orden del fichero (sin ordenar)busquedas = []for linea in sys.stdin.read().splitlines():    p = linea.split()    if not p:        continue    if p[0] == "buscar":        busquedas.append(int(p[1]))    else:        registros.append((int(p[0]), p[1])) indice = sorted((r[0], pos) for pos, r in enumerate(registros))    # (id, posición en el fichero) def plural(n, palabra, varias):    return f"{n} {palabra if n == 1 else varias}" total_sec = total_ind = 0for x in busquedas:    # Secuencial: se leen registros desde el principio hasta encontrarlo    pos = next((i for i, r in enumerate(registros) if r[0] == x), None)    lecturas = pos + 1 if pos is not None else len(registros)    # Índice: búsqueda binaria sobre la lista ordenada    lo, hi, comparaciones, encontrado = 0, len(indice) - 1, 0, None    while lo <= hi:        mid = (lo + hi) // 2        comparaciones += 1        if indice[mid][0] == x:            encontrado = indice[mid][1]            break        if indice[mid][0] < x:            lo = mid + 1        else:            hi = mid - 1    total_sec += lecturas    total_ind += comparaciones + (1 if encontrado is not None else 0)    sec = f"secuencial {plural(lecturas, 'lectura', 'lecturas')}"    ind = f"índice {plural(comparaciones, 'comparación', 'comparaciones')}"    if encontrado is not None:        print(f"buscar {x}: encontrado ({registros[encontrado][1]}) · {sec} · {ind} + 1 lectura")    else:        print(f"buscar {x}: no existe · {sec} · {ind}")print(f"Total secuencial: {total_sec} lecturas · índice: {total_ind} accesos · ahorro {round(100 - 100 * total_ind / total_sec)} %")

import sys columnas, filas, fragmentos, consultas = [], [], [], []for linea in sys.stdin.read().splitlines():    p = linea.split(" ", 1)    if p[0] == "tabla":        columnas = p[1].split(" ")[1].split(",")    elif p[0] == "fila":        valores = p[1].split(",")        filas.append(dict(zip(columnas, valores)))    elif p[0] == "fragmento":                    # fragmento F1 sede=Madrid provincia=Madrid,Toledo        nombre, sede, cond = p[1].split(" ")        campo, valores = cond.split("=")        fragmentos.append((nombre, sede.split("=")[1], campo, valores.split(",")))    elif p[0] == "consulta":        consultas.append(p[1]) def filas_texto(n):    return f"{n} fila" if n == 1 else f"{n} filas" contenido = {f[0]: [r for r in filas if r[f[2]] in f[3]] for f in fragmentos}for nombre, sede, _, _ in fragmentos:    print(f"{nombre} ({sede}): {filas_texto(len(contenido[nombre]))}") # Completitud: cada fila debe estar en algún fragmentocampo0 = fragmentos[0][2]perdidas = [r for r in filas if not any(r in contenido[f[0]] for f in fragmentos)]if perdidas:    print("Completitud: NO, sin fragmento: " + ", ".join(f"id {r['id']} ({r[campo0]})" for r in perdidas))else:    print("Completitud: sí") # Disjunción: ninguna fila en dos fragmentosrepetidas = []for r in filas:    donde = [f[0] for f in fragmentos if r in contenido[f[0]]]    if len(donde) > 1:        repetidas.append(f"id {r['id']} en " + ", ".join(donde[:-1]) + " y " + donde[-1])print("Disjunción: " + ("NO, " + "; ".join(repetidas) if repetidas else "sí")) def cumple(r, campo, op, valor):    if op == "=":        return r[campo] == valor    return float(r[campo]) > float(valor) if op == ">" else float(r[campo]) < float(valor) for c in consultas:    if c == "todos":        campo = op = valor = None    else:        op = next(o for o in "=<>" if o in c)        campo, valor = c.split(op)    elegidos = [f for f in fragmentos                if not (op == "=" and campo == f[2]) or valor in f[3]]   # poda solo en igualdades del campo    sedes = list(dict.fromkeys(f[1] for f in elegidos))            # sin repetir, en orden    ids = sorted((r["id"] for f in elegidos for r in contenido[f[0]] if campo is None or cumple(r, campo, op, valor)), key=int)    texto = f"consulta {c} → sedes {', '.join(sedes) or 'ninguna'} · {filas_texto(len(ids))}"    print(texto + (": " + ", ".join(ids) if ids else ""))

import sysfrom collections import Counter, defaultdict lineas = [l for l in sys.stdin.read().splitlines() if l.strip()]k_objetivo = int(lineas[0].split()[1])cabecera = lineas[1].split(";")                 # nombre;dni;edad;cp;sexo;diagnosticofilas = [dict(zip(cabecera, l.split(";"))) for l in lineas[2:]] print("Identificadores eliminados: nombre, dni")anonimas = []for f in filas:    decada = int(f["edad"]) // 10 * 10    anonimas.append({"edad": f"{decada}-{decada + 9}", "cp": f["cp"][:3] + "**",                     "sexo": f["sexo"], "diagnostico": f["diagnostico"]}) clave = lambda f: (f["edad"], f["cp"], f["sexo"])          # cuasi-identificadorestamanos = Counter(clave(f) for f in anonimas)print(f"k antes de suprimir: {min(tamanos.values())}") publicables = [f for f in anonimas if tamanos[clave(f)] >= k_objetivo]if not publicables:    print("No queda ningún dato publicable")    sys.exit() print("edad;cp;sexo;diagnostico")for f in publicables:    print(f"{f['edad']};{f['cp']};{f['sexo']};{f['diagnostico']}")diagnosticos = defaultdict(set)for f in publicables:    diagnosticos[clave(f)].add(f["diagnostico"])k = min(tamanos[g] for g in diagnosticos)l_div = min(len(d) for d in diagnosticos.values())print(f"Grupos: {len(diagnosticos)} · k = {k} (objetivo {k_objetivo}) · filas suprimidas: {len(anonimas) - len(publicables)} · l-diversidad: {l_div}")if l_div == 1:    print("Atención: en algún grupo todos tienen el mismo diagnóstico, que se puede deducir")

import sys instancias = {}        # entidad → lista de ocurrenciasrelacion = None        # (nombre, entidad1, (min1, max1), entidad2, (min2, max2))pares = []for linea in sys.stdin.read().splitlines():    p = linea.split()    if not p:        continue    if p[0] == "entidad":        instancias[p[1]] = p[2:]    elif p[0] == "relacion":                 # relacion cursa Alumno(1,n) Modulo(0,2)        lados = []        for t in p[2:4]:            nombre, card = t[:-1].split("(")            mn, mx = card.split(",")            lados.append((nombre, (int(mn), None if mx == "n" else int(mx))))        relacion = (p[1], lados[0][0], lados[0][1], lados[1][0], lados[1][1])    else:        pares.append((p[1], p[2]))           # cursa A1 BD nombre, e1, card1, e2, card2 = relacionincumplimientos = 0validos = []for a, b in pares:    if a not in instancias[e1] or b not in instancias[e2]:        print(f"Ocurrencia desconocida: {a} {b}")        incumplimientos += 1    elif (a, b) in validos:        print(f"Par repetido: {a} {b}")        incumplimientos += 1    else:        validos.append((a, b))print(f"Ocurrencias válidas de {nombre}: {len(validos)}") for entidad, (minimo, maximo), lado in ((e1, card1, 0), (e2, card2, 1)):    for i in instancias[entidad]:        k = sum(1 for par in validos if par[lado] == i)        # en cuántas ocurrencias participa        if k < minimo:            print(f"{entidad} {i} participa {k} veces en {nombre} (mínimo {minimo})")            incumplimientos += 1        elif maximo is not None and k > maximo:            print(f"{entidad} {i} participa {k} veces en {nombre} (máximo {maximo})")            incumplimientos += 1 if incumplimientos:    print(f"Restricciones: {incumplimientos} {'incumplimiento' if incumplimientos == 1 else 'incumplimientos'}")else:    print("Restricciones: correctas")

import sys entidades = {}         # nombre → (claves, atributos) en ordenrelaciones = []        # (nombre, e1, card1, e2, card2, atributos)for linea in sys.stdin.read().splitlines():    p = linea.split()    if not p:        continue    if p[0] == "entidad":                    # entidad Cliente *dni nombre email        claves = [a[1:] for a in p[2:] if a.startswith("*")]        attrs = [a.lstrip("*") for a in p[2:]]        entidades[p[1]] = (claves, attrs)    elif p[0] == "relacion":                 # relacion realiza Cliente 1 Pedido N [atributos…]        relaciones.append((p[1], p[2], p[3], p[4], p[5], p[6:])) # Cada tabla: nombre → lista de columnas (nombre, es_clave, tabla_referenciada, única)tablas = {e: [(a, a in claves, None, False) for a in attrs] for e, (claves, attrs) in entidades.items()}nm = 0 def clave_ajena(tabla, clave, relacion, origen, destino):    """Nombre de la columna que recibe la clave de origen en la tabla destino."""    if origen == destino:        return f"{clave}_{relacion}"                     # relación reflexiva    if any(col[0] == clave for col in tablas[tabla]):        return f"{clave}_{origen.lower()}"               # el nombre ya está ocupado    return clave for nombre, e1, c1, e2, c2, attrs in relaciones:    if c1 == "1" and c2 == "1":                          # 1:1 → clave ajena única en la segunda        for k in entidades[e1][0]:            tablas[e2].append((clave_ajena(e2, k, nombre, e1, e2), False, e1, True))        tablas[e2] += [(a, False, None, False) for a in attrs]    elif c1 == "1" or c2 == "1":                         # 1:N → la clave del lado 1 pasa al lado N        uno, muchos = (e1, e2) if c1 == "1" else (e2, e1)        for k in entidades[uno][0]:            tablas[muchos].append((clave_ajena(muchos, k, nombre, uno, muchos), False, uno, False))        tablas[muchos] += [(a, False, None, False) for a in attrs]    else:                                                # N:M → tabla nueva        nm += 1        tablas[nombre] = []        for e in (e1, e2):            for k in entidades[e][0]:                col = f"{k}_{nombre}" if e1 == e2 and e is e2 else clave_ajena(nombre, k, nombre, e, nombre)                tablas[nombre].append((col, True, e, False))        tablas[nombre] += [(a, False, None, False) for a in attrs] for t, cols in tablas.items():    textos = [("*" if pk else "") + col + (f"→{ref}" if ref else "") + (" único" if unico else "")              for col, pk, ref, unico in cols]    print(f"{t}({', '.join(textos)})")print(f"Tablas: {len(tablas)} ({nm} por relaciones N:M)")

import sysfrom itertools import combinations lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()]atributos = lineas[0][lineas[0].index("(") + 1:-1].split(",")     # R(A,B,C,D)dependencias = []for l in lineas[1:]:    izq, der = l.split("->")    dependencias.append(([a.strip() for a in izq.split(",")], [a.strip() for a in der.split(",")])) def ordenar(conjunto):    return [a for a in atributos if a in conjunto] def cierre(x):    resultado = set(x)    cambia = True    while cambia:                                   # hasta que no se pueda deducir nada nuevo        cambia = False        for izq, der in dependencias:            if set(izq) <= resultado and not set(der) <= resultado:                resultado |= set(der)                cambia = True    return resultado todos = set(atributos)claves = []for tam in range(1, len(atributos) + 1):    for combo in combinations(atributos, tam):        if cierre(combo) == todos and not any(set(k) <= set(combo) for k in claves):   # mínimas            claves.append(combo)primos = ordenar(set().union(*map(set, claves)))print("Claves candidatas: " + ", ".join("{" + ",".join(k) + "}" for k in claves))print("Atributos primos: " + (", ".join(primos) or "ninguno")) fallos = set()for izq, der in dependencias:    texto = f"{','.join(izq)} -> {','.join(der)}"    x = ",".join(izq)    if set(der) <= set(izq):        print(f"{texto}: trivial")    elif cierre(izq) == todos:        print(f"{texto}: correcta ({x} es superclave)")    elif set(der) - set(izq) <= set(primos):        print(f"{texto}: incumple FNBC ({x} no es superclave)")        fallos.add("FNBC")    else:        parcial = next((k for k in claves if set(izq) < set(k)), None)        if parcial:            print(f"{texto}: incumple 2FN (dependencia parcial de la clave {{{','.join(parcial)}}})")            fallos.add("2FN")        else:            print(f"{texto}: incumple 3FN (dependencia transitiva)")            fallos.add("3FN") if "2FN" in fallos:    forma = "1FN"elif "3FN" in fallos:    forma = "2FN"elif "FNBC" in fallos:    forma = "3FN"else:    forma = "FNBC"print(f"Forma normal: {forma}")

import sysfrom itertools import combinations lineas = [l for l in sys.stdin.read().splitlines() if l.strip()]columnas = lineas[0].split(",")filas = [[v if v != "" else None for v in l.split(",")] for l in lineas[1:]] n = len(filas)for i, col in enumerate(columnas):    distintos = {f[i] for f in filas if f[i] is not None}    print(f"{col}: {len(distintos)} valores distintos de {n}") con_nulos = [col for i, col in enumerate(columnas) if any(f[i] is None for f in filas)]print("Columnas con nulos: " + (", ".join(con_nulos) or "ninguna")) candidatas = [i for i, col in enumerate(columnas) if col not in con_nulos]   # una clave no admite nulosclaves = []for tam in range(1, 4):    for combo in combinations(candidatas, tam):        if any(set(k) <= set(combo) for k in claves):            continue                                   # no es mínima        valores = {tuple(f[i] for i in combo) for f in filas}        if len(valores) == n:                          # ninguna combinación de valores se repite            claves.append(combo)if claves:    print("Claves candidatas según los datos: " + ", ".join("{" + ",".join(columnas[i] for i in k) + "}" for k in claves))else:    print("Claves candidatas según los datos: ninguna con hasta 3 columnas")print("Aviso: los datos solo descartan claves; que hoy no haya repetidos no garantiza que no los haya mañana")

import sysimport copy tablas = {}            # nombre → (columnas, {id: fila como dict})claves_ajenas = []     # (tabla, columna, tabla_ref, regla)ordenes = []for linea in sys.stdin.read().splitlines():    p = linea.split()    if not p:        continue    if p[0] == "tabla":        tablas[p[1]] = (p[2:], {})    elif p[0] == "fk":                       # fk pedido.cliente_id -> cliente.id ON DELETE CASCADE        t, c = p[1].split(".")        claves_ajenas.append((t, c, p[3].split(".")[0], " ".join(p[6:])))    elif p[0] == "fila":        cols, filas = tablas[p[1]]        fila = dict(zip(cols, [None if v == "NULL" else v for v in p[2:]]))        filas[fila["id"]] = fila    else:        ordenes.append(p) class Rechazo(Exception):    pass def borrar(datos, tabla, ident, borradas, anuladas):    """Borra la fila y aplica las reglas ON DELETE de quienes la referencian (recursivamente)."""    del datos[tabla][1][ident]    borradas.append(f"{tabla}#{ident}")    for hija, columna, ref, regla in claves_ajenas:        if ref != tabla:            continue        usan = [f for f in datos[hija][1].values() if f[columna] == ident]        if not usan:            continue        if regla == "RESTRICT":            n = len(usan)            raise Rechazo(f"no se puede borrar {tabla} {ident}: lo usan {n} {'fila' if n == 1 else 'filas'} de {hija}")        for f in usan:            if regla == "CASCADE":                if f["id"] in datos[hija][1]:                    borrar(datos, hija, f["id"], borradas, anuladas)            else:                                     # SET NULL                f[columna] = None                anuladas.append(f"{hija}#{f['id']}.{columna}") for orden in ordenes:    if orden[0] == "borrar":        tabla, ident = orden[1], orden[2]        prefijo = f"borrar {tabla} {ident} →"        if ident not in tablas[tabla][1]:            print(f"{prefijo} ERROR: no existe {tabla} {ident}")            continue        copia = copy.deepcopy(tablas)                  # transacción: se trabaja sobre una copia        borradas, anuladas = [], []        try:            borrar(copia, tabla, ident, borradas, anuladas)        except Rechazo as e:            print(f"{prefijo} ERROR: {e}")             # rollback: la copia se descarta            continue        tablas = copia                                 # commit        print(f"{prefijo} borradas: {', '.join(borradas)}" + (f"; a NULL: {', '.join(anuladas)}" if anuladas else ""))    elif orden[0] == "insertar":        tabla = orden[1]        cols, filas = tablas[tabla]        fila = dict(zip(cols, [None if v == "NULL" else v for v in orden[2:]]))        prefijo = f"insertar {tabla} {fila['id']} →"        if fila["id"] in filas:            print(f"{prefijo} ERROR: ya existe {tabla} {fila['id']}")            continue        falta = next(((ref, fila[col]) for t, col, ref, _ in claves_ajenas                      if t == tabla and fila[col] is not None and fila[col] not in tablas[ref][1]), None)        if falta:            print(f"{prefijo} ERROR: no existe {falta[0]} {falta[1]}")            continue        filas[fila["id"]] = fila        print(f"{prefijo} correcto")    elif orden[0] == "mostrar":        for nombre, (cols, filas) in tablas.items():            texto = " | ".join(" ".join("NULL" if f[c] is None else f[c] for c in cols) for f in filas.values())            print(f"{nombre}: {texto or '(vacía)'}")

import sys relaciones = {}        # nombre → (columnas, lista de tuplas) class ErrorAlgebra(Exception):    pass def obtener(nombre):    if nombre not in relaciones:        raise ErrorAlgebra(f"no existe {nombre}")    return relaciones[nombre] def columna(nombre, cols, c):    if c not in cols:        raise ErrorAlgebra(f"no existe la columna {c} en {nombre}")    return cols.index(c) def sin_repetidos(tuplas):    return list(dict.fromkeys(tuplas))              # conserva la primera aparición def compara(a, op, b):    try:        a, b = float(a), float(b)                   # como números si los dos lo son    except ValueError:        pass    return {"=": a == b, "<>": a != b, ">": a > b, "<": a < b}[op] def operar(op, args):    if op == "seleccion":        cols, filas = obtener(args[0])        for o in ("<>", "=", ">", "<"):            if o in args[1]:                c, valor = args[1].split(o, 1)                break        i = columna(args[0], cols, c)        return cols, [t for t in filas if compara(t[i], o, valor)]    if op == "proyeccion":        cols, filas = obtener(args[0])        indices = [columna(args[0], cols, c) for c in args[1].split(",")]        return [cols[i] for i in indices], sin_repetidos(tuple(t[i] for i in indices) for t in filas)    if op == "join":        c1, f1 = obtener(args[0])        c2, f2 = obtener(args[1])        a, b = args[2].split("=")        i, j = columna(args[0], c1, a), columna(args[1], c2, b)        cols = c1 + [c if c not in c1 else f"{args[1]}.{c}" for c in c2]        return cols, [t1 + t2 for t1 in f1 for t2 in f2 if t1[i] == t2[j]]    if op in ("union", "diferencia", "interseccion"):        c1, f1 = obtener(args[0])        c2, f2 = obtener(args[1])        if c1 != c2:            raise ErrorAlgebra(f"esquemas incompatibles ({','.join(c1)}) y ({','.join(c2)})")        if op == "union":            return c1, sin_repetidos(f1 + f2)        if op == "diferencia":            return c1, sin_repetidos(t for t in f1 if t not in f2)        return c1, sin_repetidos(t for t in f1 if t in f2)    if op == "renombrar":        cols, filas = obtener(args[0])        viejo, nuevo = args[1].split("=")        i = columna(args[0], cols, viejo)        return cols[:i] + [nuevo] + cols[i + 1:], list(filas)    raise ErrorAlgebra(f"operación desconocida {op}") lineas = sys.stdin.read().splitlines()i = 0while i < len(lineas):    l = lineas[i].strip()    if l.startswith("tabla "):                 # tabla nombre col1,col2 … filas … fin        nombre, cols = l.split()[1], l.split()[2].split(",")        filas = []        i += 1        while lineas[i].strip() != "fin":            filas.append(tuple(lineas[i].strip().split(",")))            i += 1        relaciones[nombre] = (cols, filas)    elif l.startswith("mostrar "):        nombre = l.split()[1]        if nombre not in relaciones:            print(f"ERROR: no existe {nombre}")        else:            cols, filas = relaciones[nombre]            print(f"{nombre}({', '.join(cols)})")            for t in filas:                print("  " + " | ".join(t))            print(f"  {len(filas)} {'tupla' if len(filas) == 1 else 'tuplas'}")    elif l:        destino, expresion = [x.strip() for x in l.split("=", 1)]        op, *args = expresion.split()        try:            relaciones[destino] = operar(op, args)        except ErrorAlgebra as e:            print(f"ERROR en {destino}: {e}")    i += 1

SELECT nombreFROM ClientesWHERE email IS NULL;

SELECT nombre, precioFROM ProductosWHERE (categoria = 'Periféricos' OR categoria = 'Audio') AND precio < 50ORDER BY nombre;

SELECT SUM(cantidad) * 1.0 / COUNT(DISTINCT pedido_id) AS mediaFROM DetallePedido;

SELECT c.nombre, COUNT(p.pedido_id) AS pedidosFROM Clientes cLEFT JOIN Pedidos p ON p.cliente_id = c.cliente_idGROUP BY c.cliente_idORDER BY pedidos DESC, c.nombre;

SELECT c.nombre, COUNT(p.pedido_id) AS entregadosFROM Clientes cLEFT JOIN Pedidos p ON p.cliente_id = c.cliente_id AND p.estado = 'entregado'GROUP BY c.cliente_idORDER BY c.cliente_id;

SELECT nombreFROM Clientes cWHERE c.email IS NOT NULL  AND NOT EXISTS (SELECT 1 FROM Bajas b WHERE b.email = c.email)ORDER BY nombre;

UPDATE ProductosSET stock = 0WHERE categoria = 'Audio';

UPDATE ProductosSET stock = stock - (  SELECT d.cantidad FROM DetallePedido d  WHERE d.pedido_id = 3 AND d.producto_id = Productos.producto_id)WHERE producto_id IN (SELECT producto_id FROM DetallePedido WHERE pedido_id = 3);

CREATE TRIGGER descontar_stockAFTER INSERT ON DetallePedidoBEGIN  UPDATE Productos  SET stock = stock - NEW.cantidad  WHERE producto_id = NEW.producto_id;END; INSERT INTO DetallePedido VALUES (4, 2, 5, 24.99);

SELECT nombre, precio  FROM Productos  WHERE precio < 50  ORDER BY precio;

SELECT nombre, ciudad  FROM Clientes  WHERE email IS NULL;

SELECT nombre  FROM Productos  WHERE LOWER(nombre) LIKE '%portátil%' OR nombre LIKE 'Disco%';

INSERT INTO Productos (producto_id, nombre, categoria, precio, stock, proveedor, fecha_alta)  VALUES (9, 'Alfombrilla XL', 'Periféricos', 14.95, 80, 'Logitech', '2024-07-01');

SELECT categoria, COUNT(*) AS productos, MIN(precio) AS minimo, MAX(precio) AS maximo, SUM(stock) AS stock  FROM Productos  GROUP BY categoria  ORDER BY categoria;

SELECT p.pedido_id, p.fecha, c.nombre, c.ciudad  FROM Pedidos p  JOIN Clientes c ON c.cliente_id = p.cliente_id  ORDER BY p.fecha;

SELECT pedido_id, ROUND(SUM(cantidad * precio_unitario), 2) AS importe  FROM DetallePedido  GROUP BY pedido_id  ORDER BY importe DESC;

SELECT c.nombre  FROM Clientes c  LEFT JOIN Pedidos p ON p.cliente_id = c.cliente_id  WHERE p.pedido_id IS NULL;

SELECT ciudad AS nombre FROM Clientes WHERE ciudad IS NOT NULL  UNION  SELECT proveedor FROM Productos  ORDER BY nombre;

UPDATE Productos  SET precio = ROUND(precio * 1.05, 2)  WHERE proveedor = 'Samsung';

CREATE VIEW StockBajo AS  SELECT nombre, categoria, stock  FROM Productos  WHERE stock < 25;

SELECT p.nombre, p.categoria, p.precio  FROM Productos p  WHERE p.precio > (SELECT AVG(p2.precio) FROM Productos p2 WHERE p2.categoria = p.categoria);

SELECT c.nombre, ROUND(SUM(d.cantidad * d.precio_unitario), 2) AS gasto  FROM Clientes c  JOIN Pedidos p ON p.cliente_id = c.cliente_id  JOIN DetallePedido d ON d.pedido_id = p.pedido_id  GROUP BY c.cliente_id, c.nombre  ORDER BY gasto DESC  LIMIT 1;

SELECT pr.categoria, ROUND(SUM(d.cantidad * d.precio_unitario), 2) AS vendido  FROM DetallePedido d  JOIN Productos pr ON pr.producto_id = d.producto_id  GROUP BY pr.categoria  HAVING SUM(d.cantidad * d.precio_unitario) > 100  ORDER BY vendido DESC;

DELETE FROM DetallePedido  WHERE pedido_id IN (SELECT pedido_id FROM Pedidos                      WHERE estado = 'pendiente'                        AND cliente_id IN (SELECT cliente_id FROM Clientes WHERE ciudad = 'Madrid'));   DELETE FROM Pedidos  WHERE estado = 'pendiente'    AND cliente_id IN (SELECT cliente_id FROM Clientes WHERE ciudad = 'Madrid');

CREATE TABLE HistorialPrecios (producto_id INTEGER, precio_anterior REAL, precio_nuevo REAL);   CREATE TRIGGER auditar_precio  AFTER UPDATE OF precio ON Productos  WHEN OLD.precio <> NEW.precio  BEGIN    INSERT INTO HistorialPrecios VALUES (NEW.producto_id, OLD.precio, NEW.precio);  END;   UPDATE Productos SET precio = precio + 10 WHERE producto_id = 3;

SELECT nombre, emailFROM alumnosWHERE ciudad = 'Madrid' AND email IS NOT NULLORDER BY nombre;

SELECT c.idioma, c.nivel, p.nombre, c.precio_mesFROM cursos cJOIN profesores p ON p.profesor_id = c.profesor_idORDER BY c.idioma, c.nivel;

SELECT c.idioma, c.nivel, COUNT(m.alumno_id) AS matriculadosFROM cursos cLEFT JOIN matriculas m ON m.curso_id = c.curso_idGROUP BY c.curso_idORDER BY c.idioma, c.nivel;

SELECT c.idioma, c.nivel, COUNT(m.alumno_id) AS matriculados, c.plazas,       ROUND(100.0 * COUNT(m.alumno_id) / c.plazas, 1) AS ocupacionFROM cursos cLEFT JOIN matriculas m ON m.curso_id = c.curso_idGROUP BY c.curso_idORDER BY ocupacion DESC, c.idioma, c.nivel;

SELECT c.idioma, COUNT(m.nota) AS evaluados, ROUND(AVG(m.nota), 2) AS nota_mediaFROM matriculas mJOIN cursos c ON c.curso_id = m.curso_idWHERE m.nota IS NOT NULLGROUP BY c.idiomaORDER BY nota_media DESC;

SELECT nombre, total, pagado, total - pagado AS deudaFROM (  SELECT a.nombre,         (SELECT SUM(c.precio_mes) FROM matriculas m JOIN cursos c ON c.curso_id = m.curso_id          WHERE m.alumno_id = a.alumno_id) AS total,         COALESCE((SELECT SUM(p.importe) FROM pagos p WHERE p.alumno_id = a.alumno_id), 0) AS pagado  FROM alumnos a)WHERE total - pagado > 0ORDER BY deuda DESC;

SELECT p.nombre, p.idioma, COUNT(DISTINCT m.alumno_id) AS alumnosFROM profesores pLEFT JOIN cursos c ON c.profesor_id = p.profesor_idLEFT JOIN matriculas m ON m.curso_id = c.curso_idGROUP BY p.profesor_idORDER BY alumnos DESC, p.nombre;

SELECT c.idioma, a.nombre, m.notaFROM matriculas mJOIN cursos c ON c.curso_id = m.curso_idJOIN alumnos a ON a.alumno_id = m.alumno_idWHERE m.nota = (  SELECT MAX(m2.nota)  FROM matriculas m2  JOIN cursos c2 ON c2.curso_id = m2.curso_id  WHERE c2.idioma = c.idioma)ORDER BY c.idioma;

UPDATE cursosSET precio_mes = ROUND(precio_mes * 1.05, 2)WHERE idioma = 'inglés'  AND (SELECT COUNT(*) FROM matriculas m WHERE m.curso_id = cursos.curso_id) > 2;

SELECT nombre,       (strftime('%Y', '2026-10-01') - strftime('%Y', nacimiento))         - (strftime('%m-%d', nacimiento) > '10-01') AS edadFROM pacientesWHERE ciudad = 'Madrid' AND aseguradora IS NULLORDER BY edad DESC;

SELECT c.hora, p.nombre, m.nombre, e.nombreFROM citas cJOIN pacientes p ON p.paciente_id = c.paciente_idJOIN medicos m ON m.medico_id = c.medico_idJOIN especialidades e ON e.especialidad_id = m.especialidad_idWHERE c.fecha = '2026-10-05'ORDER BY c.hora;

SELECT e.nombre, COUNT(c.cita_id) AS citasFROM especialidades eLEFT JOIN medicos m ON m.especialidad_id = e.especialidad_idLEFT JOIN citas c ON c.medico_id = m.medico_id AND c.estado = 'realizada'GROUP BY e.especialidad_idORDER BY citas DESC, e.nombre;

SELECT m.nombre, COUNT(*) AS citas, SUM(c.importe) AS totalFROM citas cJOIN medicos m ON m.medico_id = c.medico_idWHERE c.estado = 'realizada' AND c.fecha BETWEEN '2026-09-01' AND '2026-09-30'GROUP BY m.medico_idHAVING SUM(c.importe) > 100ORDER BY total DESC;

SELECT p.nombreFROM pacientes pWHERE EXISTS (SELECT 1 FROM citas c WHERE c.paciente_id = p.paciente_id)  AND NOT EXISTS (SELECT 1 FROM citas c WHERE c.paciente_id = p.paciente_id AND c.estado = 'cancelada')ORDER BY p.nombre;

SELECT m.nombre, COUNT(*) AS citas,       SUM(c.estado = 'cancelada') AS canceladas,       ROUND(100.0 * SUM(c.estado = 'cancelada') / COUNT(*), 1) AS porcentajeFROM medicos mJOIN citas c ON c.medico_id = m.medico_idGROUP BY m.medico_idHAVING COUNT(*) >= 3ORDER BY porcentaje DESC, m.nombre;

SELECT p.nombre, COUNT(DISTINCT m.especialidad_id) AS especialidadesFROM pacientes pJOIN citas c ON c.paciente_id = p.paciente_id AND c.estado = 'realizada'JOIN medicos m ON m.medico_id = c.medico_idGROUP BY p.paciente_idHAVING COUNT(DISTINCT m.especialidad_id) > 1ORDER BY p.nombre;

WITH ordenadas AS (  SELECT c.*, ROW_NUMBER() OVER (PARTITION BY c.paciente_id ORDER BY c.fecha DESC, c.hora DESC) AS n  FROM citas c  WHERE c.estado = 'realizada')SELECT p.nombre, o.fecha, m.nombreFROM ordenadas oJOIN pacientes p ON p.paciente_id = o.paciente_idJOIN medicos m ON m.medico_id = o.medico_idWHERE o.n = 1ORDER BY p.nombre;

UPDATE citasSET estado = 'no presentado'WHERE estado = 'pendiente' AND fecha < '2026-10-01';

WITH resultados AS (  SELECT local_id AS equipo_id, puntos_local AS favor, puntos_visitante AS contra FROM partidos  UNION ALL  SELECT visitante_id, puntos_visitante, puntos_local FROM partidos)SELECT e.nombre, COUNT(*) AS jugados,       SUM(r.favor > r.contra) AS victorias,       SUM(r.favor < r.contra) AS derrotas,       SUM(r.favor) AS favor, SUM(r.contra) AS contra,       SUM(r.favor) - SUM(r.contra) AS diferenciaFROM resultados rJOIN equipos e ON e.equipo_id = r.equipo_idGROUP BY e.equipo_idORDER BY victorias DESC, diferencia DESC, e.nombre;

WITH ranking AS (  SELECT s.partido_id, j.nombre, s.puntos,         ROW_NUMBER() OVER (PARTITION BY s.partido_id ORDER BY s.puntos DESC, j.nombre) AS n  FROM estadisticas s  JOIN jugadores j ON j.jugador_id = s.jugador_id)SELECT partido_id, nombre, puntos FROM ranking WHERE n = 1 ORDER BY partido_id;

SELECT RANK() OVER (ORDER BY SUM(s.puntos) DESC) AS puesto,       j.nombre, e.nombre, SUM(s.puntos) AS puntosFROM estadisticas sJOIN jugadores j ON j.jugador_id = s.jugador_idJOIN equipos e ON e.equipo_id = j.equipo_idGROUP BY j.jugador_idORDER BY puesto, j.nombre;

SELECT j.nombre, p.jornada, s.puntos,       SUM(s.puntos) OVER (PARTITION BY j.jugador_id ORDER BY p.jornada) AS acumuladoFROM estadisticas sJOIN jugadores j ON j.jugador_id = s.jugador_idJOIN partidos p ON p.partido_id = s.partido_idWHERE j.equipo_id = 1ORDER BY j.nombre, p.jornada;

SELECT j.nombre, p.jornada, s.puntos,       s.puntos - LAG(s.puntos) OVER (PARTITION BY j.jugador_id ORDER BY p.jornada) AS diferenciaFROM estadisticas sJOIN jugadores j ON j.jugador_id = s.jugador_idJOIN partidos p ON p.partido_id = s.partido_idWHERE j.equipo_id = 3ORDER BY j.nombre, p.jornada;

WITH totales AS (  SELECT j.equipo_id, j.nombre, SUM(s.puntos) AS puntos  FROM estadisticas s  JOIN jugadores j ON j.jugador_id = s.jugador_id  GROUP BY j.jugador_id)SELECT e.nombre, t.nombre, t.puntos,       ROUND(100.0 * t.puntos / SUM(t.puntos) OVER (PARTITION BY t.equipo_id), 1) AS porcentajeFROM totales tJOIN equipos e ON e.equipo_id = t.equipo_idORDER BY e.nombre, porcentaje DESC;

WITH medias AS (  SELECT j.nombre, j.posicion, AVG(s.puntos) AS media  FROM estadisticas s  JOIN jugadores j ON j.jugador_id = s.jugador_id  GROUP BY j.jugador_id), comparadas AS (  SELECT nombre, posicion, media, AVG(media) OVER (PARTITION BY posicion) AS media_posicion  FROM medias)SELECT nombre, posicion, ROUND(media, 1), ROUND(media_posicion, 1)FROM comparadasWHERE media > media_posicionORDER BY posicion, media DESC;

CREATE VIEW v_saldos ASSELECT cl.nombre, c.numero, c.tipo, c.saldoFROM cuentas cJOIN clientes cl ON cl.cliente_id = c.cliente_idWHERE c.cerrada IS NULL;

CREATE TRIGGER trg_saldo AFTER INSERT ON movimientosBEGIN  UPDATE cuentas SET saldo = ROUND(saldo + NEW.importe, 2) WHERE cuenta_id = NEW.cuenta_id;END; INSERT INTO movimientos (cuenta_id, fecha, concepto, importe) VALUES  (3, '2026-10-03', 'Gimnasio', -39.90),  (5, '2026-10-03', 'Ingreso', 200);

CREATE TRIGGER trg_ahorro BEFORE INSERT ON movimientosWHEN (SELECT tipo FROM cuentas WHERE cuenta_id = NEW.cuenta_id) = 'ahorro' AND (SELECT saldo FROM cuentas WHERE cuenta_id = NEW.cuenta_id) + NEW.importe < 0BEGIN  SELECT RAISE(IGNORE);END; INSERT INTO movimientos (cuenta_id, fecha, concepto, importe) VALUES (2, '2026-10-04', 'Retirada', -9000);INSERT INTO movimientos (cuenta_id, fecha, concepto, importe) VALUES (5, '2026-10-04', 'Retirada', -500);INSERT INTO movimientos (cuenta_id, fecha, concepto, importe) VALUES (1, '2026-10-04', 'Recibo', -2000);

UPDATE cuentasSET saldo = ROUND(saldo * 1.015, 2)WHERE tipo = 'ahorro' AND cerrada IS NULL AND saldo > 1000;

INSERT INTO movimientos (cuenta_id, fecha, concepto, importe)SELECT cuenta_id, '2026-10-31', 'Comisión de mantenimiento', -2FROM cuentasWHERE tipo = 'corriente' AND cerrada IS NULL AND saldo < 1500;

DELETE FROM movimientosWHERE cuenta_id IN (SELECT cuenta_id FROM cuentas WHERE cerrada < '2021-10-01');

INSERT INTO resumen (cuenta_id, mes, ingresos, gastos)SELECT cuenta_id, '2026-09',       ROUND(SUM(CASE WHEN importe > 0 THEN importe ELSE 0 END), 2),       ROUND(SUM(CASE WHEN importe < 0 THEN -importe ELSE 0 END), 2)FROM movimientosWHERE fecha LIKE '2026-09-%'GROUP BY cuenta_idON CONFLICT (cuenta_id, mes) DO UPDATE SET ingresos = excluded.ingresos, gastos = excluded.gastos;

BEGIN;UPDATE cuentas SET saldo = saldo - 150 WHERE numero = 'C-001';UPDATE cuentas SET saldo = saldo + 150 WHERE numero = 'A-002';INSERT INTO movimientos (cuenta_id, fecha, concepto, importe)  SELECT cuenta_id, '2026-10-05', 'Traspaso enviado', -150 FROM cuentas WHERE numero = 'C-001';INSERT INTO movimientos (cuenta_id, fecha, concepto, importe)  SELECT cuenta_id, '2026-10-05', 'Traspaso recibido', 150 FROM cuentas WHERE numero = 'A-002';COMMIT;