Clave, unicidad y grano

import collections
import csv


def leer(nombre):
    with open(nombre, encoding="utf-8", newline="") as f:
        return list(csv.DictReader(f))


estudiantes = leer("academico_estudiantes.csv")

print("academico_estudiantes.csv:", len(estudiantes), "filas")
print()
print(f"{'columna':<10} {'distintos':>10} {'unica':>7}")
print("-" * 30)
for columna in estudiantes[0]:
    distintos = len({x[columna] for x in estudiantes})
    print(f"{columna:<10} {distintos:>10} "
          f"{'SI' if distintos == len(estudiantes) else 'no':>7}")

print()
print("id sirve como clave primaria: 50 valores distintos en 50 filas.")
print("legajo NO, y eso es una sorpresa: se supone que es el identificador")
print("de la facultad.")

repetidos = collections.Counter(x["legajo"] for x in estudiantes)
duplicados = [k for k, v in repetidos.items() if v > 1]
print()
print("el legajo repetido:", duplicados)
for fila in estudiantes:
    if fila["legajo"] in duplicados:
        print("  ", fila)

print()
print("Son dos personas distintas con el mismo legajo. Cual de las dos es")
print("'la buena' no lo dice el archivo: es una decision, y por eso la")
print("leccion 5.5 va a pedir una regla de desempate escrita.")

print()
print("La diferencia entre las dos columnas:")
print("  id     -> clave SUBROGADA: la inventa el sistema y no significa nada")
print("  legajo -> clave NATURAL: viene del mundo real y puede fallar")
print()
print("Una clave natural siempre puede repetirse, quedar vacia o cambiar.")
print("Una subrogada nunca, y a cambio no sirve para cruzar con otro sistema.")

vacios = [x for x in estudiantes if not x["legajo"].strip()]
print()
print("legajos vacios en este archivo:", len(vacios))
print("Que hoy no haya ninguno no es una garantia: es el estado de hoy.")

import collections
import csv


def leer(nombre):
    with open(nombre, encoding="utf-8", newline="") as f:
        return list(csv.DictReader(f))


estudiantes = leer("academico_estudiantes.csv")
cursos = leer("academico_cursos.csv")
inscripciones = leer("academico_inscripciones.csv")

print(f"{'tabla':<24} {'filas':>6}  una fila es...")
print("-" * 62)
print(f"{'academico_estudiantes':<24} {len(estudiantes):>6}  un estudiante")
print(f"{'academico_cursos':<24} {len(cursos):>6}  un curso")
print(f"{'academico_inscripciones':<24} {len(inscripciones):>6}  "
      f"un estudiante EN un curso")

print()
print("Ese 'EN' es todo el concepto. El grano de inscripciones no es el")
print("estudiante ni el curso: es el PAR. Y por eso su clave primaria")
print("tiene que ser compuesta.")

print()
por_estudiante = collections.Counter(x["estudiante_id"] for x in inscripciones)
print("cuantas inscripciones tiene cada estudiante:")
reparto = collections.Counter(por_estudiante.values())
for cuantas, cuantos in sorted(reparto.items()):
    print(f"   {cuantos:>3} estudiantes con {cuantas} inscripcion(es)")
print("   total de estudiantes que aparecen:", len(por_estudiante), "de 50")

print()
print("La pregunta que hace el grano: '¿cuantos estudiantes hay?'")
print("  sobre academico_estudiantes ->", len(estudiantes))
print("  contando filas de inscripciones ->", len(inscripciones), "MAL")
print("  contando estudiante_id distintos ->", len(por_estudiante))
print()
print("Las tres son respuestas a preguntas distintas, y la del medio no")
print("responde ninguna: cuenta inscripciones y las llama estudiantes.")

print()
print("Y al reves, sumar sobre la tabla equivocada infla el resultado:")
# ET100 tiene los creditos vacios: se saltea y se dice cuantos son.
creditos = {c["id"]: int(c["creditos"])
            for c in cursos if c["creditos"].strip().isdigit()}
sin_creditos = [c["codigo"] for c in cursos
                if not c["creditos"].strip().isdigit()]
total_catalogo = sum(creditos.values())
total_cursado = sum(creditos.get(x["curso_id"], 0) for x in inscripciones)
print("   cursos sin creditos declarados             :", sin_creditos)
print("   creditos del catalogo (grano = curso)      :", total_catalogo)
print("   creditos cursados (grano = inscripcion)    :", total_cursado)
print("   El segundo cuenta cada curso una vez por alumno inscripto.")
print("   Ninguno esta mal: contestan cosas distintas.")

print()
print("Antes de sumar o contar cualquier cosa, la pregunta es siempre la")
print("misma: en esta tabla, ¿que representa una fila?")

import collections
import csv


def leer(nombre):
    with open(nombre, encoding="utf-8", newline="") as f:
        return list(csv.DictReader(f))


estudiantes = leer("academico_estudiantes.csv")
cursos = leer("academico_cursos.csv")
inscripciones = leer("academico_inscripciones.csv")

print("academico_inscripciones.csv:", len(inscripciones), "filas")
for columna in inscripciones[0]:
    print(f"   {columna:<14} {len({x[columna] for x in inscripciones}):>3} distintos")
print()
print("Ninguna columna sola alcanza como clave: hay 43 estudiantes y 9")
print("cursos en 110 filas. La clave es el PAR (estudiante_id, curso_id),")
print("que es lo mismo que decir que el grano es 'un alumno en un curso'.")

pares = collections.Counter((x["estudiante_id"], x["curso_id"])
                            for x in inscripciones)
repetidos = {k: v for k, v in pares.items() if v > 1}
print()
print("pares distintos:", len(pares), "en", len(inscripciones), "filas")
print("pares repetidos:", repetidos)
for fila in inscripciones:
    if (fila["estudiante_id"], fila["curso_id"]) in repetidos:
        print("  ", fila)

print()
print("La clave compuesta TAMPOCO se cumple: el estudiante 35 figura dos")
print("veces en el curso 5, con notas distintas. En una base de datos esto")
print("seria un UNIQUE violado; en un CSV, nada lo impide.")
print("Consecuencia practica: un merge por ese par va a duplicar filas.")

# Clave foranea: cada id de inscripciones tiene que existir en su tabla.
ids_estudiante = {x["id"] for x in estudiantes}
ids_curso = {x["id"] for x in cursos}

huerfanas_e = [x for x in inscripciones if x["estudiante_id"] not in ids_estudiante]
huerfanas_c = [x for x in inscripciones if x["curso_id"] not in ids_curso]

print()
print("CLAVE FORANEA: ¿cada referencia apunta a algo que existe?")
print("   inscripciones con estudiante_id inexistente:", len(huerfanas_e))
for fila in huerfanas_e:
    print("     ", fila, "<- no hay estudiante 999")
print("   inscripciones con curso_id inexistente:", len(huerfanas_c))
for fila in huerfanas_c:
    print("     ", fila, "<- no hay curso 77")

print()
sin_inscripcion = sorted(ids_estudiante - {x["estudiante_id"] for x in inscripciones},
                         key=int)
print("Y el caso simetrico, que NO es un error:")
print("   estudiantes sin ninguna inscripcion:", len(sin_inscripcion))
print("   ids:", sin_inscripcion)
print("   Una fila sin hijos es normal (un alumno que no se anoto).")
print("   Una fila sin padre es una violacion (una inscripcion a la nada).")

# Tablas de juguete, chiquitas a proposito: la idea se ve contando a mano.
# Los numeros sobre los archivos reales son el ejercicio EJ-2.1.


def cruzar(izquierda, derecha, clave_i, clave_d):
    """Todas las combinaciones cuya clave coincide (un inner join)."""
    salida = []
    for fila_i in izquierda:
        for fila_d in derecha:
            if fila_i[clave_i] == fila_d[clave_d]:
                salida.append({**fila_i, **fila_d})
    return salida


print("CASO 1:1 - cada clave aparece una vez de los dos lados")
personas = [{"id": 1, "nombre": "Ana"}, {"id": 2, "nombre": "Beto"}]
dnis = [{"id": 1, "dni": "30111222"}, {"id": 2, "dni": "31222333"}]
r = cruzar(personas, dnis, "id", "id")
print(f"   {len(personas)} x {len(dnis)} -> {len(r)} filas."
      " El resultado tiene el mismo grano que las entradas.")

print()
print("CASO 1:N - cada clave, una vez a la izquierda y varias a la derecha")
cursos = [{"curso": "BD101"}, {"curso": "PR201"}]
notas = [{"curso": "BD101", "nota": 8}, {"curso": "BD101", "nota": 6},
         {"curso": "BD101", "nota": 9}, {"curso": "PR201", "nota": 7}]
r = cruzar(cursos, notas, "curso", "curso")
print(f"   {len(cursos)} x {len(notas)} -> {len(r)} filas."
      " El grano pasa a ser el del lado N.")
print("   Es el caso normal, y el que hay que reconocer: despues de cruzar,")
print("   'contar filas' ya no cuenta cursos.")

print()
print("CASO N:M - la clave se repite de LOS DOS lados")
izq = [{"k": "x", "a": 1}, {"k": "x", "a": 2}]
der = [{"k": "x", "b": 10}, {"k": "x", "b": 20}, {"k": "x", "b": 30}]
r = cruzar(izq, der, "k", "k")
print(f"   {len(izq)} x {len(der)} -> {len(r)} filas = 2 x 3.")
print("   Multiplica. Casi nunca es lo que se queria, y casi siempre es")
print("   un duplicado no detectado de alguno de los dos lados.")

print()
print("EL CASO QUE MUERDE: una sola clave repetida")
alumnos = [{"legajo": "E007", "nombre": "Walter"},
           {"legajo": "E007", "nombre": "Belen"},
           {"legajo": "E008", "nombre": "Ciro"}]
inscr = [{"legajo": "E007", "curso": "BD101"},
         {"legajo": "E008", "curso": "BD101"}]
r = cruzar(inscr, alumnos, "legajo", "legajo")
print(f"   {len(inscr)} inscripciones x {len(alumnos)} alumnos -> "
      f"{len(r)} filas")
for fila in r:
    print("     ", fila)
print("   La inscripcion de E007 se DUPLICO, porque el legajo apunta a dos")
print("   personas. Nadie avisa: el resultado tiene una fila de mas y")
print("   parece perfectamente valido.")

print()
print("La regla, y es toda la leccion 6.3 por adelantado:")
print("  1:1 -> la cantidad de filas se mantiene")
print("  1:N -> queda el grano del lado N")
print("  N:M -> multiplica, y casi siempre es un error")
print()
print("Antes de cruzar, la pregunta es: ¿la clave es UNICA de cada lado?")
print("Si la respuesta es 'creo que si', hay que contarlo.")