
Buscar claves foráneas candidatas entre pares declarados
Source:R/coleccion.R
relaciones_coleccion.RdCorre detectar_relaciones() sobre los pares de tablas que se declaren, y
devuelve las relaciones candidatas junto con la cobertura de los pares que no
se pudieron comparar.
Usage
relaciones_coleccion(
coleccion,
pares,
muestra = 10000,
umbral_cobertura = 0.9,
orden = NULL,
tope_cache_mb = 512,
columnas_candidatas = NULL,
podar = FALSE,
tope_memoria_mb = 512
)Arguments
- coleccion
Objeto creado por
coleccion().- pares
Data frame con columnas
tabla_1ytabla_2. Cero filas es una declaración válida de «ningún par».- muestra
Filas traídas por tabla para comparar, y el mismo tope con que se calcula cada cobertura: se reenvía a
detectar_relaciones(), así que la evidencia publicada y la cobertura salen de las mismas filas, también conmuestra > 1e5. Sin reenviarlo regiría el tope por omisión de esa función, y la fila se contradiría a sí misma:n_valores_comunescontado sobre la lectura entera junto a una cobertura calculada sobre un submuestreo que ningún campo declara.- umbral_cobertura
Cobertura mínima para informar una relación.
- orden
Columnas para
ORDER BY: un vector de texto que se aplica a todas las tablas, o una lista nombrada por identificador de tabla. Sin él la lectura no es repetible y el objeto lo declara. Ordena la lectura y no la recorta: una tabla sincolumnas_candidatasse lee con todas sus columnas, y a una con candidatas se le suman las de orden sólo para ordenar.- tope_cache_mb
Presupuesto de memoria para la caché de lecturas, en megabytes. Al agotarse se sigue leyendo sin cachear y
metalo declara.- columnas_candidatas
Lista nombrada por identificador de tabla. Cada vector declara las columnas que pueden participar; una tabla no nombrada conserva todas sus columnas. Un nombre se busca con la grafía exacta y, si no está, sin distinguir mayúsculas —como
ordeny comoorden_muestradeperfilar_dbi()—; uno que no existe dalupa_error_argumento_dbi, la clase de todo argumento mal formado de esta función.- podar
Si se aplican las podas que cambiarían lo informado —tipos incompatibles y cardinalidades imposibles—, tal como en
detectar_relaciones().FALSEpor omisión; la poda cierta por rangos disjuntos del universo se aplica siempre porque no cambia ninguna fila.- tope_memoria_mb
Presupuesto de memoria para resultados de relaciones, en megabytes. Al agotarse, las combinaciones pendientes se declaran en
cobertura_podasy los pares pendientes encobertura_pares.
Value
Objeto relaciones_coleccion con relaciones, cobertura_pares,
cobertura_podas y meta. En relaciones, las cuatro columnas de conteo
de huérfanos van al final.
Details
Los pares se declaran, igual que la frontera. Con mil tablas hay casi un
millón de pares dirigidos, así que explorar todos no es una opción cara sino
una opción imposible. estimar_costo_coleccion() permite verlo antes.
Cada tabla se lee una sola vez. Los pares repetidos se descartan, los
pares de una tabla consigo misma se rechazan, y las lecturas se guardan en
una caché con presupuesto de memoria declarado: dos pares que comparten una
tabla no la leen dos veces. meta$lecturas deja el SQL exacto, la vía
usada, las filas leídas y el momento de cada lectura.
El orden no se supone. Sin orden, una lectura acotada devuelve un
subconjunto arbitrario y el resultado declara meta$estable = FALSE. Declarar
columnas de orden hace la lectura repetible.
Una columna que la sesión no puede escribir no se lleva la tabla. Con
odbc bajo el locale C -un Rscript de cron- un nombre no ASCII no se
puede mandar, y un nombre con bytes que no son UTF-8 válido y no declaran su
codificación -un CSV latin1 leído sin fileEncoding- no se manda con ningún
controlador. Una candidata así sale de la lectura y sus combinaciones quedan
en cobertura_podas con motivo columna_no_escribible y el remedio en
detalle; las demás se comparan. Una columna de orden así deja la lectura
de esa tabla sin ORDER BY —no se puede ordenar como se declaró—, y
meta$lecturas y meta$estable lo dicen. Los nombres publicados son los de
DBI::dbListFields(), los mismos que publica perfilar_coleccion(), aunque
el controlador devuelva los de la lectura en otra codificación.
Una columna que la credencial no puede leer, o que llega enmascarada, no
se compara y no se lleva la tabla. Las columnas de cada tabla y lo que la
credencial puede leer de ellas salen del catálogo del motor, de la misma
función que usa perfilar_dbi(): en PostgreSQL pg_attribute con
has_column_privilege() —dbListFields() de RPostgres no lista las
columnas sin privilegio—, y en SQL Server sys.columns con
HAS_PERMS_BY_NAME() y sys.masked_columns (enmascaramiento dinámico, salvo
que la credencial tenga UNMASK). Sin candidatas declaradas la lectura nombra
las demás columnas en vez de SELECT *, que con un permiso por columna se
rechaza entero, y la columna no se nombra en ninguna consulta. Sus
combinaciones quedan en cobertura_podas con motivo columna_sin_permiso o
columna_enmascarada: una columna enmascarada lee la máscara —xxxx—, y dos
así parecerían relacionadas sin compartir un solo valor. Una columna de
orden así deja la lectura sin ORDER BY, como la que no se puede escribir.
Si el catálogo no contesta —un sinónimo, una tabla de otra base—, la tabla se
lee como siempre y meta$lecturas$motivo lo declara: dos columnas
enmascaradas se compararían como dato.
Los valores se leen como los lee perfilar_dbi(). RPostgres entrega 0
en toda celda money, y MIN/MAX de una columna money también: la
lectura de cada tabla y la consulta de rangos de la poda la leen convertida
en el motor —CAST(x AS NUMERIC)—, con la misma expresión que
perfilar_dbi() publica en meta$lectura_convertida. Saber el tipo cuesta
una consulta de cero filas por tabla, sólo en las conexiones donde la lectura
convierte algo. Y el texto que el controlador entrega en latin1 con la marca
UTF-8 —odbc con FreeTDS bajo un locale que no es UTF-8, sobre una columna
varchar— se lee como latin1, así que se compara con el de una nvarchar;
la lectura lo declara en meta$lecturas$motivo, con el remedio, porque un
carácter fuera de latin1 llega como ? (ver «Fallo parcial» en
perfilar_dbi()). Con muestra = Inf no se escribe LIMIT: la tabla se
lee entera por la vía sin tope. Dentro de una transacción del usuario, la
lectura sigue la regla de perfilar_dbi(): en PostgreSQL cada sentencia va
dentro de un punto de guardado y la transacción no queda abortada.
Cada par se compara sobre una muestra de filas de cada tabla, y el resultado declara ese alcance: una relación candidata sobre una muestra no es una clave foránea comprobada, es un indicio que hay que confirmar contra el diccionario de datos.
Las columnas de ancho fijo (char(n) y equivalentes del controlador) se
leen sin el relleno final que forma parte de su representación en el motor.
Así, una clave char y su contraparte varchar se comparan por el valor
lógico que el motor iguala, no por los espacios que entrega DBI.
En SQL Server la misma regla alcanza a los pares de texto varchar contra
varchar, porque su cotejamiento ignora los espacios finales. En PostgreSQL
no se recortan todas las columnas de texto: se normaliza el lado bpchar y
la contraparte varchar que el motor compara con él, pero un text conserva
su espacio final porque PostgreSQL lo distingue. Así la relación publicada
sigue la igualdad del motor, no una igualdad de cadenas recortadas.
Si una lectura conjunta falla en una fila, la colección aísla por descarte
las columnas culpables y deja sus nombres en cobertura_podas con motivo
columna_lectura_fallida; las columnas sanas conservan sus relaciones. Si
se declaró orden, el aislamiento repite las sondas sin ORDER BY sólo
cuando la propia columna de orden es la culpable, y meta$estable se calcula
desde las lecturas que realmente llevaron ese orden.
Con la tabla de referencia truncada la cobertura es una cota inferior. Un
valor de tabla_2 que no está entre las filas leídas de tabla_1 puede
estar en las demás, así que la cobertura sólo puede subir al leer más. Una
combinación de columnas que con la referencia truncada no alcanza
umbral_cobertura no se descarta en silencio, aunque otra del mismo par
lo alcance: un indicador de dos valores llega a cobertura 1 trivialmente, y
no puede borrar la clave foránea que quedó en 0,5 por la lectura. El par
queda en cobertura_pares como «sin conclusión» —una fila por par, no una
por combinación—, con cuántas combinaciones no alcanzaron el umbral, las
cinco de mayor cobertura medida con su cota, cuántas lo alcanzaron —que están
en relaciones— y cómo resolverlo. meta$pares_sin_conclusion los cuenta
—también están en pares_comparados, porque se compararon—.
Los motivos de cobertura_pares citan en claro lo que el usuario declaró y
lo que el resto de la salida ya publica: los nombres de las tablas, de sus
esquemas y de sus columnas, y las de orden y columnas_candidatas; el
resto del mensaje del motor sigue la regla de perfilar_dbi().
El alcance se declara por par y en la fila. Cada relación publica
filas_leidas_1/filas_leidas_2 —cuántas se compararon—, y además
filas_totales_1/filas_totales_2 y muestreado_1/muestreado_2: cuando la
lectura fue completa, el total de la tabla es exacto; cuando quedó truncada,
el total va NA y muestreado vale TRUE, porque lo único que se sabe es
que hay más filas que el tope. Publicar el tope como si fuera el total sería
decir que se leyó todo. Para saberlo se pide una fila más que el tope, que
cuesta mucho menos que un COUNT(*) por tabla y contesta exacto; esa fila de
sobra no viaja al resultado.
Los atributos de detectar_relaciones() no viajan en relaciones:
sobrevivirían sólo los del primer par publicado —rbind() conserva los
del primer argumento—, con etiquetas tabla1/tabla2 que no nombran a
ningún par, y con dos pares dirían muestreado = FALSE aunque el segundo
hubiera leído 10.000 filas de 20.000. Lo que dirían vive en las columnas, una
por par, y el conteo de pares en meta, que cuenta todos.
Las columnas candidatas se podan antes de materializar cada comparación. Las
podas quedan declaradas en cobertura_podas, con su motivo y conteo.
La poda cierta por rangos usa MIN y MAX sobre el universo completo de
cada tabla, no sobre las filas de la muestra. Si el motor no puede entregar
ese rango, la comparación sigue sin aplicar esa poda.
Un entero ancho que llega como doble no se compara. Por encima de 2^53 un
doble no distingue dos enteros consecutivos, y dbConnect(duckdb::duckdb())
entrega BIGINT como doble por omisión: dos identificadores distintos se
fundirían y el objeto afirmaría una relación que el motor no tiene. Una
columna leída como doble con algún valor de al menos 2^53 en valor absoluto
deja sus pares en sin_comparar, con motivo entero_como_doble en
cobertura_podas y el remedio en el detalle: conectar pidiendo integer64
—duckdb(bigint = "integer64"), o bigint = "integer64" en RSQLite—.
El campo detalle de una poda por rangos disjuntos no publica extremos que
identifiquen: si el mínimo o el máximo de un lado llega al piso de la
protección —seis caracteres o más—, ese rango sale como [valor protegido].
El mínimo de una columna de documentos es el documento de una persona real, y
el par mínimo–máximo acota además a todos los valores intermedios.
Cuántas filas quedan huérfanas, no cuáles. Cada relación publica los
cuatro conteos de detectar_relaciones() —n_filas_huerfanas_tabla1,
n_filas_huerfanas_tabla2, n_valores_huerfanos_tabla1 y
n_valores_huerfanos_tabla2—, sobre las filas leídas, igual que la
cobertura: con una lectura truncada cuentan sólo las filas leídas, y si la
truncada es la tabla de referencia cuentan de más, porque un valor que no
está entre sus filas leídas puede estar en las demás. Un ausente no es
huérfano. Las filas no se nombran: sus posiciones serían las de esta
lectura, que no sirven para buscarlas en el motor. Y los valores huérfanos
no se publican:
son celdas de una columna que suele ser un identificador, y esta función no
sabe si es un dato personal —por eso ya tapa los extremos en detalle—.
Para ver cuáles son, leer las dos tablas y llamar a detectar_relaciones(),
que nombra las filas, o pedirlo al motor con un NOT EXISTS. Calcular los
conteos no agrega ninguna consulta.
Examples
if (requireNamespace("RSQLite", quietly = TRUE) &&
requireNamespace("DBI", quietly = TRUE)) {
con <- DBI::dbConnect(RSQLite::SQLite(), ":memory:")
DBI::dbWriteTable(con, "personas", data.frame(id = 1:20, nombre = letters[1:20]))
DBI::dbWriteTable(con, "visitas", data.frame(persona_id = c(1:15, 1:5)))
col <- coleccion(con, c("personas", "visitas"), nombre = "padron")
relaciones_coleccion(
col, pares = data.frame(tabla_1 = "personas", tabla_2 = "visitas"),
columnas_candidatas = list(personas = "id", visitas = "persona_id"),
orden = list(personas = "id", visitas = "persona_id")
)
DBI::dbDisconnect(con)
}