formatos_fecha_mixtos, formato_fecha_ambiguo
y anio_de_dos_digitos) traen en su
trazabilidad las filas con el problema; antes decían
no_aplica. La traza se arma sobre la columna entera,
también cuando la tabla de formatos, la evidencia y
n_afectados son de una muestra, y puede nombrar filas
escritas en formatos que la muestra no llegó a ver.
n_afectados sigue contando formatos, así que el
total de la traza cuenta filas. Esa segunda lectura de la
columna se hace sólo cuando alguno de los tres hallazgos sale, una vez
por columna. anio_de_dos_digitos traza toda fila cuya
escritura sólo admite lecturas con el año de dos cifras;
formato_fecha_ambiguo, toda fila escrita en una lectura que
la columna entera no puede resolver; formatos_fecha_mixtos,
todas las filas con fecha, primero las de las escrituras que no son la
más frecuente, con el reparto de
casi_duplicados_vocabulario
(n_filas_formas_variantes,
n_filas_formas_dominantes); con empate en el primer lugar
no hay dominante y todas cuentan como variantes.posible_ausencia_estructural y
regla_silencia_ausencia traen en su
trazabilidad las filas que cuentan: las ausentes que caen
donde la regla dice que la columna no corresponde, y las que la
declaración del universo dejó de contar.lupa_trazabilidad_incoherente revisa
también esos cinco: avisa si al construir el perfil un hallazgo de
formato no trae filas o un informativo que cuenta filas no las nombra.
Un perfil guardado por una versión anterior se publica sin aviso.relacion_funcional_columnas (severidad
sospechoso, unidad fila): uno por cada fila de
perfil$dependencias que no es exacta, y uno por sentido,
con columna = "determinante,dependiente",
n_afectados igual a sus violaciones y, en la
trazabilidad, las filas que la rompen (las de la tabla si
la dependencia se recalculó sobre ella; las de la muestra, con
alcance = "muestra_dependencias", si no). Con empate en la
moda de un grupo, rompen las filas del valor que aparece después.
detectar_dependencias() y perfil$dependencias
no cambian, y el plan no propone una acción: la relación es observada,
no una regla del dominio.comparar_perfiles(): apagar
analizar_dependencias o recortar la búsqueda publica esos
hallazgos como no_evaluado, y
umbral_dependencia y
umbral_casi_clave_dependencia se declaran en
configuracion_umbrales. Comparar un perfil de una versión
anterior con uno nuevo de los mismos datos publica
aparecido por cada dependencia casi exacta, en cada
sentido.detectar_relaciones() dice cuántas filas quedan
huérfanas y cuáles. Cada par comparado publica
n_filas_huerfanas_tabla1,
n_filas_huerfanas_tabla2,
n_valores_huerfanos_tabla1 y
n_valores_huerfanos_tabla2 —lo que la cobertura deja
afuera; un valor ausente no es huérfano—, y las columnas-lista
huerfanas_tabla1 y huerfanas_tabla2 nombran
las filas con la forma de la trazabilidad de un hallazgo
(indices_fila, total, truncado).
Las filas se nombran en el lado casi cubierto (cobertura entre
umbral_cobertura y 1), hasta
max_filas_huerfanas (1000 por omisión); por debajo del
umbral se cuentan y no se nombran. Los valores huérfanos no se publican:
con los índices están a una línea para quien tiene la tabla.relaciones_coleccion() publica los mismos cuatro
conteos, sobre las filas leídas. No nombra las filas, que serían
posiciones de la lectura, ni agrega consultas.tope_memoria_mb: con
un tope finito, el mismo presupuesto compara menos pares que antes, y
los que quedan sin comparar salen declarados como siempre. Quien leía
una columna del resultado abreviando su nombre
(rel$n_valores por n_valores_comunes) recibe
ahora NULL, porque hay más de una que empieza así.citation("lupa") lleva el DOI que CRAN le asignó al
paquete, 10.32614/CRAN.package.lupa, cuando el paquete se
instaló desde CRAN, como la cita que R arma sola para un paquete sin
archivo de cita propio. Los dos README lo dicen junto al DOI de
Zenodo.citation("lupa") y CITATION.cff) lleva
el mismo.perfilar() dice que la muestra se toma por
posición: en una tabla de más filas que muestra, lo que se
mide sobre ella depende del orden de las filas, y la misma tabla leída
de una base sin ORDER BY puede dar dos perfiles
distintos.perfilar() es entre seis y ocho veces más rápido sobre
columnas de texto con números. Sobre 200.000 filas, en Linux, pasa de
321 a 38 segundos con diez columnas de decimales con coma, de 418 a 67
con diez de importes con moneda y de 164 a 27 con una mezcla de listas,
códigos e importes; perfilar datos_operativos pasa de 0,128
a 0,119 segundos por llamada. Son medianas de tres corridas alternadas
contra la 0.1.1, que rehace
benchmark/medir_texto_numerico.R. Las respuestas no
cambian. Lo que cambió:
celdas_multivaluadas) mira la columna entera en cada paso:
preguntaba celda por celda si era un número escrito con coma decimal o
con miles y partía cada celda por separado;ñ y ü—
recorre sólo las celdas con algún carácter no ASCII; las entidades HTML
se buscan sólo donde hay un &, y los controles e
invisibles sólo en las celdas que traen alguno. Bastaba un símbolo de
moneda en la columna para que cada celda pasara por su propia pregunta,
cada una con un costo fijo que en Windows es de unos 47
microsegundos;n_distintos y
la moda— agrega de una vez los valores nuevos de cada bloque, en vez de
copiar el vector y medir el estado entero por cada uno; si el estado
pasaría el tope de memoria, corta en el mismo valor que antes;aplicar() es más rápido sobre columnas grandes con
pocas celdas que cambiar. Quitar controles invisibles y normalizar
espacios Unicode recorren sólo las celdas que pueden traerlos, y la
cuenta de lo que una acción pierde arma grupos sólo con los valores de
las celdas que cambiaron. Sobre una columna de dos millones de filas con
401 celdas que tocar, en Linux, reparar la codificación y quitar los
controles pasa de 38 a 10 segundos. Es el costo de las mismas acciones:
con el plan por omisión, aplicar() puede tardar más en
total que con la 0.1.1, porque ahora aplica reparaciones de codificación
que la 0.1.1 dejaba sin marcar.perfilar_dbi() publicaba con estado
no_disponible —«La consulta terminó sin un valor para la
métrica»— la moda de una columna de texto cuando esa moda es la cadena
vacía "", aunque el valor y su frecuencia salían en
resumen_tabla$columnas y perfilar() decía
moda = "": leía la cadena vacía como el NULL
de SQL. Ahora sale calculado (o estimado sobre
una muestra del motor).clave_con_ausentes y de
clave_no_unica nombra la clave declarada como la muestra la
consola (ciudad\xa0) cuando su nombre no es UTF-8 válido:
pegaba el byte crudo junto al texto del paquete y la frase quedaba
marcada UTF-8 sin serlo.detectar_duplicados_aproximados(), dos textos
iguales —tal cual o tras la normalización— publican distancia 0.
stringdist puede devolver ruido de coma flotante en lugar
del cero (3.3e-17 en macOS sobre arm64, y lo mismo en Linux con un R
compilado con multiplicación fusionada), y la evidencia del par decía
distancia 0.0000000000000000333.read.csv() sin
fileEncoding sobre un CSV en latin-1 o Windows-1252: el
espacio duro como separador de miles, un grado, un byte suelto— hacía
abortar perfilar() entero en una sesión UTF-8 con «input
string N is invalid UTF-8» cuando la columna tenía números o fechas
escritos como texto; analizar() abortaba igual, y
perfilar_dbi() y perfilar_coleccion() perdían
la muestra con un aviso. Ahora el perfil describe el resto de la
columna, la celda queda contada en n_codificacion_invalida
con su hallazgo, y la evidencia de tipo_declarado_distinto
dice que la conversión no lee esa celda en vez de afirmar que no se
pierde ningún valor. Tampoco abortan ya perfilar() con una
cadena así en cadenas_ausencia, ni
perfilar_dbi() cuando la moda de una columna es una de
ellas.meta$orden_columnas, y bajo
LC_ALL=C contaba esas celdas como valores que no se
pudieron convertir y descartaba el par.print() de hallazgos() y de
cobertura() ya no aborta en una sesión UTF-8 cuando un
nombre de columna trae, sin marca, bytes que no son UTF-8 válido —lo que
deja data.table::fread() sobre un CSV en latin-1 con
encabezados acentuados—. El nombre viaja dentro de sus columnas-lista y
print.data.frame() no podía formatearlo: escribir
cobertura(p) en la consola abortaba con «invalid multibyte
string». Las dos tablas llevan ahora la clase tabla_lupa
delante de data.frame, que las imprime como el resto de las
salidas del paquete, con el byte escapado (ciudad\240).
Ningún valor cambia, y as.data.frame() devuelve la tabla
sin la clase. La llevan también los campos de donde salen
—p$hallazgos y p$cobertura_diagnosticos, los
de perfil_muestra en perfilar_dbi()— y el
atributo cobertura_diagnosticos del plan, adonde manda su
impresión: imprimirlos directo abortaba igual. Lo mismo con un
subconjunto de proponer_modelo() sin las columnas de la
propuesta. Venía de la 0.1.1. Bajo un locale que no puede representar un
carácter, esas tablas escriben su punto de código
(a<U+00F1>o), como ya lo hacía print()
del perfil.perfilar() y analizar() abortaban la tabla
entera sobre una tabla con columnas de año, mes y día cuya primera fila
no formaba una fecha —un mes 0, un 30 de febrero, un
NA—, porque la búsqueda de fechas partidas dejaba que R
adivinara el formato por el primer elemento; perfilar_dbi()
perdía la muestra por lo mismo. Ahora lo que no es una fecha cuenta como
no válido y el resto de la búsqueda sigue.comparar_perfiles() publica no_evaluado, y
no resuelto, cuando un hallazgo de la tabla —como
fecha_partida_columnas— desaparece porque el perfil nuevo
declaró recortada esa búsqueda en
cobertura_diagnosticos.comparar_perfiles(): un grupo de columnas iguales
comparado con una entrega sin filas salía resuelto con
severidad ok. La cobertura del perfil vacío declina
columnas_duplicadas sin nombrar columna, y eso ahora quiere
decir «en ninguna columna»: sale no_evaluado, como el
hallazgo de una columna cuyo diagnóstico se declinó. Y con
sentinelas_numericos = numeric(0) en uno de los perfiles,
la fila configuracion_sentinelas_numericos publicaba la
lista vacía como ""; ahora dice ninguna, como
las demás políticas que son listas.perfilar_dbi(), perfilar_coleccion() y
relaciones_coleccion(): si el catálogo de permisos de SQL
Server o PostgreSQL no contesta —un sinónimo, una tabla de otra base, un
catálogo que la credencial no lee—, la lectura sigue siendo la de
siempre, pero ahora se declara: una fila degradado en
resumen_tabla$cobertura (y
resumen_tabla$meta$permisos_sin_consultar), una fila de
alcance permisos_columnas en
cobertura_coleccion y el motivo de la lectura en
meta$lecturas. Una columna enmascarada de esa tabla se mide
como si la máscara fuera el valor, y antes no se decía. Con
columnas_candidatas, relaciones_coleccion()
consultaba además el catálogo dos veces por tabla; ahora la validación y
la lectura comparten lo consultado.relaciones_coleccion() se detiene con
lupa_error_transaccion_dbi cuando el motor deshace la
transacción del usuario mientras se consultan las columnas y los
permisos de una tabla, como ya hacían perfilar_dbi() y
perfilar_coleccion(). Antes seguía leyendo con
SELECT *, fuera de la transacción, y podía relacionar dos
columnas enmascaradas.perfilar() abortaba la tabla entera, con «subíndice
fuera de los límites», cuando una columna tenía listas escritas con dos
delimitadores y las de uno tenían una cantidad de valores que las del
otro no tenían ("12, 15, 18" con "16; 17").
Ahora publica celdas_multivaluadas con los dos
delimitadores y cuántas celdas tienen cada cantidad de valores.posible_identificador, tipo_declarado_distinto
(con la propuesta de convertirlo a número) y patron_raro
por sus valores de una cifra; el mismo identificador sin huecos recibía
sólo el primero. Dentro del perfil, la pregunta «¿es una numeración?»
tiene ahora una sola respuesta, la misma que deja a una numeración fuera
de los límites de Tukey: con ella sale
posible_identificador, no se propone la conversión a número
y los valores de una cifra no son un patrón raro. Una numeración
guardada como integer64 se reconoce igual que guardada como
doble.aplicar() registra como ejecutada, con
n_cambiadas = 0 y sin error, una acción de
texto que no cambia nada porque una acción anterior del mismo plan ya
resolvió el problema que la motivó, como recortar_espacios
después de que convertir_ausencias_textuales vació sus
celdas. El resumen impreso no la cuenta entre las fallidas. Antes
quedaba fallida aunque los datos quedaran limpios. Si el
problema sigue en los datos, o nunca estuvo en los que recibe
aplicar(), la acción sigue fallida.normalizar_espacios_invisibles corre antes que
recortar_espacios, y un espacio Unicode al borde —el duro
(U+00A0), el fino (U+202F) y los demás separadores de Unicode, además de
la tabulación vertical y el avance de página— cuenta en
n_espacios_borde y lo quita recortar_espacios,
igual que en los validadores. Antes el recorte corría primero y el
espacio duro del borde se volvía un espacio común que nadie quitaba, o
el plan ni ofrecía el recorte: después de aplicarlo, el perfil volvía a
publicar espacios_sobrantes. El espacio duro que es la
mitad de una letra mal convertida se conserva. La sugerencia del
hallazgo ya no dice que alcanza con trimws(), que no quita
esos espacios.n_codificacion_normalizada ya no cuenta una celda que
queda ASCII después de la acción, como a con un espacio de
ancho cero que se quita: ya no tiene codificación que cambiar.planificar_limpieza(): una conversión de tipo
(convertir_tipo, convertir_numero_regional,
convertir_fecha_confirmada) sobre una columna con
aplicabilidad o declarada en
columnas_opcionales anuncia en n_afectadas los
valores presentes de la columna, que son los que aplicar()
cambia. Antes contaba como presentes las celdas vacías fuera del
universo: sobre 70 filas aplicables con 10 faltantes y 30 vacías fuera,
prometía 90 cambios donde aplicar() hacía 60. Tampoco
contaba los presentes de las filas donde la regla no se pudo decidir.
Sin universo declarado, el plan no cambia.planificar_limpieza() y analizar() con
proteger_datos_personales = TRUE ya no abortan con
«subíndice fuera de los límites» cuando una columna protegida tiene una
regla de aplicabilidad. El barrido que tapa las fechas de
los parámetros borraba un parámetro NULL
(cadenas_ausencia sin declarar) y corría los que venían
detrás. Sin la regla no abortaba, pero el plan protegido perdía ese
parámetro sin avisar; ahora cada acción trae los mismos parámetros que
sin protección.1.234,56 €, 1.234,56€,
1.234,56 $) se reconoce igual que con el símbolo delante:
cuenta en n_numeros_texto, publica
numero_texto_moneda, recibe numero_como_texto
y el plan lo convierte. Lo mismo vale para U$S35 pegado y
para el espacio duro o el fino entre el símbolo y el número.
€ 10 y 20 € son la misma moneda.$ 35 $,
USD 35 EUR, $ 35 USD) no es un número:
USD 35 EUR se convertía en 35 y se perdía el
EUR.perfilar_por(): sobre una columna que en la tabla
entera es una numeración densa, cada grupo cuenta los faltantes
disfrazados con la guarda de la columna entera, como
perfilar(). Un 999 dentro de
1:2000 ya no se suma al hallazgo faltantes del
grupo: un grupo de 50 filas con 4 NA y dos 999
publicaba «4 ausentes reales y 2 disfrazados (0.120 del total)» y
cruzaba el umbral. Tampoco entra en faltantes_disfrazados
ni en la proporción. Lo protegido se declara en
cobertura_diagnosticos (centinelas_numericos),
con el motivo y si contado habría cruzado el umbral.convertir_sentinelas_numericos convierte exactamente
las celdas que el perfil contó en
n_faltantes_disfrazados_numericos. En la 0.1.1 el plan leía
la lista de la evidencia del hallazgo: con más marcas en la columna de
las que la evidencia muestra, con una marca declarada que contiene
; o con proteger_datos_personales = TRUE, la
lista volvía al catálogo entero y aplicar() podía convertir
también el 999 legítimo de una numeración. Ahora el
hallazgo faltantes_disfrazados publica en su
trazabilidad el campo sentinelas_contados,
tomado de las mismas celdas que el conteo, y el plan arma la lista con
él. Donde el perfil no lo trae (un perfil guardado por una versión
anterior, o un hallazgo cuya evidencia tapó la protección de datos
personales, donde el campo queda NA),
aplicar() acota la lista corriendo el mismo detector sobre
los datos que recibe; si el perfil contó dentro de un universo de
aplicabilidad y la acción ya no trae esa regla, termina
fallida y dice por qué.cadenas_ausencia: con
cadenas_ausencia = "999", "999" es de
convertir_ausencias_textuales y sólo "999.0"
es de esta acción.perfilar() cuenta lo mismo en una numeración guardada
como integer, difftime o units:
en las dos últimas la guarda de la numeración no corría y el
999 de 1:1000 salía como faltante disfrazado.
Y convertir_sentinelas_numericos acepta duraciones y
medidas con unidad (antes terminaba fallida) y conserva la
clase y la unidad de la columna.comparar_equivalencia() y
comparar_perfiles() comparan la moda y el centinela
conjeturado de una columna numérica por su valor y no por cómo los
imprimió la sesión. La misma tabla perfilada con
options(OutDec = ",") y con punto salía
materialmente_distinto en moda
(2245,63 contra 2245.63) al lado de
identico en media. Una columna de texto se
sigue comparando como texto, y un cambio verdadero de la moda se sigue
informando.comparar_perfiles() ya no informa como modificada la
política de centinelas numéricos cuando uno de los dos perfiles no la
registra, como pasa con un perfil guardado por una versión anterior: sin
registro no hay evidencia de un cambio. Una política que de verdad
cambió (sentinelas_numericos = numeric() contra la de
omisión) se sigue informando.<tabla> ya
no se confunde, en comparar_perfiles(), con los hallazgos
que son de la tabla entera: su fila salía con
columna = NA.relaciones_coleccion() consulta el esquema de cada
tabla una vez; lo consultaba dos.max_geometrias) cuenta sobre los valores que se intentaron
convertir: decía «1 de 2 valores presentes» cuando había tres presentes
y se habían intentado dos.perfilar_por() toma una sola vez, con el código de
perfilar(), las tres decisiones que dependen de la columna
entera —el centinela numérico que la columna conjetura, la numeración
densa que impide tomar por ausencia un código como 999, y
el identificador que excluye a una columna de la ley de Benford—, y las
aplica también a las columnas de texto y factor que se leen
como números. Antes, un grupo de una numeración escrita como texto
publicaba faltantes_disfrazados por un 999 que
la tabla entera no acusa, o un posible_centinela_numerico
distinto del de la columna, sin fila en la cobertura; y un grupo
publicaba desviacion_benford sobre una columna que
perfilar() excluye por identificador. Lo que un grupo deja
de publicar por estas decisiones queda declarado en
cobertura_diagnosticos (centinelas_numericos,
ley_benford). Todo lo demás —los valores extremos,
posible_identificador, las ausencias escritas con texto— lo
sigue decidiendo cada grupo con sus filas.perfilar_por() sobre integer64: una
numeración cuya moda sobresale (cincuenta 999 en
1:2000) publica esos 999 en cada grupo, como
perfilar() y como la misma columna en double;
antes los grupos los declaraban en la cobertura.perfilar() sobre integer64: un centinela
de la lista declarada (por omisión -9999,
-999, 999) se publica como
faltantes_disfrazados, igual que en double, y
ya no además como posible_centinela_numerico;
centinela_valor, centinela_repeticiones y
densidad_sin_centinela quedan NA, como en
double.c("1.5TB", "500GB", "250MB", "2TB") y
c("850K", "1,5M", "2M", "300K") publicaban
n_numeros_texto = 1 —sólo el valor con separador decimal— y
el plan proponía convertir_numero_regional activada, que
dejaba 1.5, 500, 250 y 2. El perfil contaba con una regla (un sufijo es
una unidad sólo si termina en minúscula) y la conversión leía con otra
(cualquier tramo de letras). Ahora es una sola: lo que acompaña a un
número es una unidad (% o una abreviatura que termina en
minúscula) o una moneda, y si no, el valor no se convierte.
12 KG, 12A, 1.5TB y
850K no cuentan en n_numeros_texto ni en
proporcion_numeros_texto, y una columna que mezcla esos
valores con números no se convierte:
c("1,5", "2,5", "3", "12 KG") dejaba 12 donde decía
12 KG. Siguen escritos como números, y junto a otros no
apagan numero_como_texto para la columna: el hallazgo
nombra 1,5 y 2,5, su evidencia cuenta aparte
los valores con un sufijo o un código que no se convierte, y la
conversión queda bloqueada mientras haya alguno.validar_iso4217().
LEY 18331 se publicaba con
numero_texto_moneda = "LEY" y se convertía a 18331. Como
con el sufijo, ABC 13 junto a USD 12 no se
convierte ni apaga numero_como_texto para el importe.USD 12\nkg —un código ISO 4217, un número y una unidad
separados por un salto de línea— se lee como USD 12 kg,
igual que $ 35\nkg: la moneda publicada era el valor entero
y monedas_mixtas contaba una moneda falsa por cada valor
así.identificador
(101a, 102a),
convertir_numero_regional queda lista sin
activar: aplicar() dejaba 101, 102 y la letra del código se
perdía sin que nadie lo pidiera.convertir_tipo
leen los números escritos como texto con la misma función y la misma
convención decimal.
c(".5", ".5", ".5", "1.234,56", "1.234,56", "1.234,56", "1.234,56", "7", "12,5")
se infería doble con compatibilidad 1 mientras el resumen
dejaba cuatro de los nueve valores afuera;
c("1e3", "2,5", "3.5e2", "4") contaba cuatro números y
resumía tres; y convertir_tipo convertía
12.500 en 12,5 en una columna de coma decimal cuyo resumen
publicaba 12500..5,
,5) se lee igual que 0.5 y 0,5 y
aporta la misma evidencia de convención:
c(",5", ",25", "1.500", "2,75") leía 1.500
como 1,5 y su gemela con el cero escrito como 1500.c("1.2E-05", "3.4E-07", "5.6E-03", "2.2E-04") y
c("1e5", "2e5", "3e5", "4e5") se inferían
identificador, sin resumen, y 1E+05 se infería
doble. Un exponente que desborda el doble
(1e400) no es un número.doble,
que es el que cubre todos los valores.
c("10", "12", "9", "15", "9,5") se infería
entero con compatibilidad 0,8 y el hallazgo decía
«convertir dejaría 1 de 5 valores en NA» sobre una columna que el plan
convertía sin ningún NA. Lo mismo con un número en notación
científica entre enteros (1e5, 1E+05).tipo_declarado_distinto dice «la
conversión no pierde ningún valor» sólo cuando el plan propone una
conversión lista. La decía sobre un entero que no entra en
integer (3000000000), sobre una columna con
una celda de espacios y sobre una columna con notación científica cuya
conversión regional queda bloqueada, al lado de un plan que no
convertía.convertir_tipo: el perfil ya la cuenta como ausencia y la
conversión la deja en NA, como hace
convertir_numero_regional.% ya no dice que
los valores «quedan como proporción en [0, 1]»: 150% queda
en 1,5.convertir_mayusculas,
convertir_minusculas, convertir_titulo,
convertir_segun_diccionario y
convertir_ausencias_textuales, que no pasaban por la
protección: con reparar_codificacion desmarcada,
MÜNCHEN en minúsculas quedaba mãœnchen, ya
sin arreglo. Y para decodificar_entidades_html: decodificar
é junto a una palabra rota
(é cÅ“ur) dejaba la celda sin reparación posible;
ahora la acción, sola, no toca esa celda, y después de la reparación
sí.°) ya no pierden su
último byte con eliminar_controles_invisibles. La
protección reconoce un byte de continuación también como el carácter que
Windows-1252 pone en su lugar (€ por 0x80).
Era uno de los dos casos que la 0.1.1 declaraba sin cubrir. de una página web delante, detrás
o entre palabras rotas— ya no impiden reparar la celda entera. Con un
espacio duro delante, «Şanlıurfa» mal leída quedaba con la
Ş rota, el registro decía reparado y el perfil
siguiente ya no la señalaba; ahora sale entera, como con un espacio
común.Ã antes de un espacio duro o de un signo que la volvería
minúscula («IRMû + espacio duro
Å o Ä más un
guion blando, detrás de una minúscula («ankaŭ»), se reconocen, se
protegen de las acciones de invisibles y se reparan. Sigue sin cubrir el
otro caso que la 0.1.1 declaraba: «Š» leída como Å más un
espacio duro (y «Ġ», «Ơ»), porque «Å» + espacio duro + una palabra es
también noruego o sueco bien escrito.reparar_codificacion. Ahora la celda queda como está y
sigue señalada, y el plan no ofrece la acción por ella. La 0.1.1 decía
que esos controles se siguen quitando: se quitan salvo en ese caso.reparar_codificacion saliera sin marcar, y el plan por
omisión no reparaba ninguna celda, aunque las otras se repararan
enteras. Ahora, si la columna tiene celdas que se reparan enteras, la
acción sale marcada con aplicar_parciales = FALSE: repara
ésas, deja las parciales como están, n_afectadas cuenta
sólo las enteras y la justificación dice cuántas parciales quedan. Se
piden poniendo aplicar_parciales = TRUE en
parametros. Una columna que sólo tiene parciales no cambia:
la acción queda lista sin marcar, y marcarla aplica las
parciales. Quien marcaba la acción a mano en una columna con las dos
necesita ahora aplicar_parciales = TRUE para aplicar
también las parciales.latin1 y la misma celda en UTF-8
cuentan como un solo valor también cuando traen uno de los cinco bytes
que Windows-1252 no define (0x81, 0x8D, 0x8F, 0x90, 0x9D).
n_distintos, las filas y las columnas duplicadas y
n_no_reversibles las contaban como dos —en una columna con
las dos marcas, o entre una columna latin1 y su copia en
UTF-8—, y daban la celda latin1 por igual al texto de
cuatro letras <81>, que es otro dato. Ahora leen el
texto como lo leen las acciones de texto.perfilar() informa, y
eliminar_controles_invisibles quita, los operadores
invisibles de la matemática (U+2061 a U+2064), los controles de formato
en desuso (U+206A a U+206F), los rellenos del hangul (U+115F, U+1160,
U+3164 y U+FFA0) y la etiqueta de idioma U+E0001: ningún contador los
veía y ninguna acción los tocaba. Las etiquetas U+E0020 a U+E007F, que
arman las banderas de Inglaterra, Escocia y Gales, cuentan entre los
controles invisibles y se conservan; el hallazgo lo dice.controles_invisibles de una celda cuyo
control ninguna acción quita —porque sin él la celda se leería como una
letra mal convertida— ya no recomienda eliminarlo: dice que el plan no
trae una acción para eso.aplicar() corre decodificar_entidades_html
antes que convertir_minusculas,
convertir_titulo y convertir_mayusculas de su
columna, aunque un orden editado la ponga detrás:
josé pasaba a JosÉ y se
decodificaba con la E mayúscula, y & quedaba en
&Amp;. Con el orden del plan ya era así.fallida por celdas protegidas.
espacios_sobrantes deja de contar el espacio del borde que
es lo que permite reconocer una letra rota (Ì seguido de
un espacio): recortarlo dejaba la celda rota y sin señalar; se informa
después de reparar.perfilar() cuenta en n_codificacion_rota y
en el hallazgo codificacion_rota el texto mal convertido
que el motor no puede reparar ("Œ ", una letra seguida de
U+0081). Antes quedaba sólo en n_codificacion_no_se_pudo,
suelto o repetido, y una columna sin ninguna celda reparable no tenía
hallazgo: rep("Œ ", 10) publicaba
n_codificacion_no_se_pudo = 10,
n_codificacion_rota = 0 y ninguno. Repetir las filas de una
columna multiplica los conteos y no cambia los estados ni los
hallazgos.codificacion_rota cita valores
distintos —repetía el mismo hasta cinco veces cuando el valor se repetía
en la columna— y no dice «carácter de reemplazo» de un valor que no lo
trae.reparar_codificacion lista y sin marcar, como
dice la ayuda; salía recuperar_codificacion_en_origen,
informativa, y la reparación parcial no se podía aplicar. La
justificación de recuperar_codificacion_en_origen distingue
los bytes perdidos (U+FFFD) del texto que el motor reconoce mal
convertido y no puede reparar.perfilar_dbi(): con una columna que el motor no deja
leer, las columnas a su derecha se juzgaban con el tipo de la omitida.
Un DECIMAL(18,2) después de un BLOB ilegible
salía con tipo_declarado = "texto" en el perfil de la
muestra, y bajo universo = "muestra_motor" con
bloque_muestra = "solo_agregados" el desvío de una columna
sana salía no_disponible. Los atributos de cada columna
viajan ahora juntos y la columna rota no cambia el perfil de las
demás.perfilar_dbi(metricas = "desvio"), sin
"validos", ya no aborta con «missing value where TRUE/FALSE
needed» cuando el motor devuelve una magnitud infinita: la métrica queda
no_disponible con su motivo.1e308) o muy chicos salía
Inf o 0 con estado calculado.
Ahora se calcula escalado, como ya se hacía en PostgreSQL, SQL Server,
MySQL y MariaDB, y si el motor igual no devuelve un desvío finito no se
publica como calculado.perfilar_dbi()
responde con el resumen SQL por columna, la segunda corrida respeta lo
que se pidió: pisaba max_consultas, dialecto,
los topes de la muestra y los avisos, y la cobertura publicaba dos veces
columnas_opcionales. Si esa segunda corrida también falla,
su mensaje queda en la cobertura.perfilar_dbi(universo = "muestra_motor"): cuando la
materialización queda recortada por
max_bytes_materializacion, o no se puede leer por una
columna que el motor rechaza y se perfilan las demás,
resumen_tabla$columnas$n es la cantidad de filas perfiladas
y no el total de la tabla, que quedaba al lado de los válidos de unas
pocas filas (n = 5 con n_validos = 2). En una
corrida sin recortes n sigue siendo el total de la tabla.
print() de ese resultado ya no aborta con «Multiple
quantities for pluralization».meta$muestreo$fraccion_solicitada conserva la fracción
pedida; publicaba la del reintento (0,25 o 1 donde se había pedido
0,5).politica_costo = "por_cardinalidad", la corrida
declara el mismo máximo de consultas (n_consultas_max) que
plan_perfilado_dbi(); declaraba dos de más.capacidad_no_aceptada, y una columna
ilegible conserva sus filas en resumen_tabla$sql aunque no
quede ninguna métrica por ejecutar.normalizar_espacios_invisibles y
reemplazar_separadores, aplicadas con
reparar_codificacion desmarcada sobre una columna que
mezcla una celda rota con una limpia terminada en  o
à y un espacio tipográfico, ya no tocan la celda limpia:
quedaba  más un espacio común, que el perfil siguiente
leía como una letra rota, y la acción cambiaba una fila más de las que
el plan contaba. Con el plan por omisión no ocurría.columnas_duplicadas publica un hallazgo por
grupo de columnas con el mismo contenido, no uno por
par: columna es la primera del grupo en el orden de los
datos, la evidencia las nombra a todas
(A = B = C; comparadas sobre 5 filas) y
n_afectados las cuenta a todas, como
filas_duplicadas con sus filas. Con dos columnas el
hallazgo es el de siempre. Si un nombre no se puede leer suelto —vacío,
repetido, con espacios al borde o con =, ;,
, o comillas—, la evidencia cita todos los del grupo y el
repetido lleva su posición
("X" (columna 1) = "X" (columna 2)). Dos columnas son
iguales en lo que el perfil lee como contenido: dos factores sin orden
con los mismos niveles en otro orden son la misma columna, y un entero y
un doble no. Sin filas no se compara: no hay hallazgo, y
general$columnas_duplicadas, que tiene una fila por columna
repetida junto a la primera de su grupo, queda vacía.
planificar_limpieza() propone una decisión por grupo
—marcarlo, o eliminar las repetidas y conservar la primera— y
comparar_perfiles() compara los grupos por las igualdades
que afirman: si C deja de ser igual a A = B, publica un
resuelto y no dos; si un grupo se separa sólo porque una columna cambió
de tipo declarado, publica no_evaluado, porque el
diagnóstico no volvió a compararlas; y un perfil guardado con la forma
por pares se compara sin deriva falsa. Con 1.000 columnas iguales eran
499.500 hallazgos: planificar_limpieza(),
comparar_perfiles() y analizar() no terminaban
en 5 minutos y ahora tardan 2, 3 y 22 s, y print() del
perfil pasa de 37 s a 0,6 s.benchmark/ que publican cifras dejan su
CSV en benchmark/datos/ con fecha, entorno y huella del
código; el de Raha agrega el SHA-256 de cada insumo, y el del tope de
largo mide Jaro-Winkler con el mismo p que el paquete (el
margen publicado para max_largo_valor = 10000 era mayor que
el real).reportar(), rehecha con
scripts/capturar-informe-html.R. «El vacío por diseño» y
«Marcos y modelos de calidad» empiezan por el ejemplo y dejan la
explicación para después.CONTRIBUTING.md reúne las reglas de redacción
de la documentación.bit64 el perfil de una columna
integer64 se detiene con un error, no deja 5 medidas en
NA; y un documento sin su dígito verificador necesita 7
cifras, no 6. La tabla de motores del README nombra también PostgreSQL
9.3.data-raw/comparar-guias.R comprueba
antes de construirlo que cada una tenga los mismos trozos, el mismo
código y las mismas cifras en línea que su pareja en castellano.data.frame(), la detección de fechas no prueba los formatos
que no pueden casar con ningún valor, y analizar()
clasifica una sola vez los datos personales de la tabla que mide. Con la
protección pedida, el barrido que decide qué campos guardan nombres de
columna no intenta partir un valor sin coma, y la fila de una columna
del perfil se arma sin pasar por [.data.frame. El pliegue
con que la protección compara los valores protegidos con el texto
publicado ya no arma su tabla de tres mil caracteres en cada llamada: un
texto ASCII sólo baja la caja, y uno corto usa la parte del mapa que
trae. Sobre la tabla de ejemplo de 13 filas, perfilar()
tarda 0,11 s y analizar() 0,21 s en una sesión ya iniciada,
y 0,19 s y 0,34 s en la primera llamada de una sesión nueva. Con la
protección pedida, perfilar() tarda 0,23 s y 0,37 s, y
analizar() 0,60 s y 0,78 s. Las cifras son de
benchmark/medir_costo_fijo.R y quedan en
benchmark/datos/medir-costo-fijo.csv.perfilar() sobre tablas anchas con muchas columnas
iguales o de códigos de texto es varias veces más rápido. La búsqueda de
casi duplicados del vocabulario no calcula la mitad de la matriz de
distancias que no lee, y columnas_duplicadas publica un
hallazgo por grupo (ver «Perfilado»). Las columnas iguales se buscan
agrupándolas por una huella y comparando cada una con un representante,
no par por par. Con 500 filas y 1.000 columnas iguales, de 379 a 387 s
pasa a 28 a 30 s (los 2 CSV fechados de
benchmark/medir_topes_valores_ancho.R en
benchmark/datos/).perfilar() repara una sola vez cada valor mal
codificado: lo reparaban, por separado, el diagnóstico de la
codificación y el armado de los hallazgos. En una columna de 100.000
valores distintos con mojibake tarda una cuarta parte menos.integer64 necesitan
además bit64, desde la 4.0.5. Con bit64 anterior a 4.6.0,
match() de R iguala entre sí todos los valores negativos:
lupa empareja esos valores por su texto, con su propio
match() y su %in%, y da el mismo perfil que
con bit64 nuevo. Sin bit64 se niega con la condición
lupa_error_integer64 en lugar de publicar distintos, modas
y medianas equivocados. Las pruebas de integer64 corren
todas con bit64 4.0.5 en R 4.2.0, y una prueba falla si alguna función
de base que compara por debajo (merge(),
factor(), setdiff(), order()…)
recibe del paquete una columna integer64.planificar_limpieza() no convierte un número escrito
como texto que el perfil no lee: un teléfono como
099.123.456 entre importes con coma decimal, que el perfil
deja fuera del resumen, hacía que el plan propusiera la conversión y
aplicar() escribiera 99123456. Ahora la conversión queda
bloqueada, como con cualquier valor que no responde al
formato, hasta que se decida qué hacer con él. Con columnas iguales en
las que algún nombre se repite en la tabla, el plan no propone acción
—proponía dos bloqueada sin saber sobre cuál columna
actuar— y el hallazgo queda en
hallazgos_sin_accion_por_columna_ambigua, con el
remedio.inferir_tipo() y perfilar() leen como
número un importe con los miles agrupados (1.234,56,
1,234.56, 12.500.000) con la convención de la
columna: quedaba texto y sin resumen, aunque la fila
publicaba la convención, y la misma columna sin los puntos de miles se
resumía. Si la columna aporta las dos convenciones, cada valor se lee
con la que trae. Sin evidencia de convención —una columna de
1.234.567— sigue como texto, y un primer grupo de miles que
empieza con cero (099.123.456, la forma de un teléfono) no
se lee como número en ninguna. El resumen lee sólo lo que la inferencia
cuenta como número, también fuera de su muestra: lo demás —un teléfono,
0x1A, 5.— queda afuera y lo declara
n_valores_excluidos_resumen. Un importe con moneda o unidad
(USD 1,234.56, 12 kg) sigue siendo un número
escrito como texto: numero_como_texto lo señala y
planificar_limpieza() lo convierte.tipo_declarado_distinto ya no dice que
la conversión «no pierde ningún valor» cuando pierde algo: nombra el
cero inicial de un código (007), la precisión, la
convención sin decidir o las fechas de lectura ambigua, las mismas
razones por las que el plan no convierte.
fecha_nacimiento_fuera_rango y
fecha_fallecimiento_fuera_rango cuentan las filas fuera de
rango, que publicaban como NA, y su traza las nombra.detectar_formatos_fecha() reconoce la t y
la z minúsculas de RFC 3339 y cuenta la fecha civil
distinta en UTC de un POSIXlt como la de su
POSIXct (daba 0).validar_ci_uy() completa con ceros la cédula guardada
como número (1236 es 00001236, y daba
FALSE) y rechaza el cuerpo 0000000, el relleno
de muchas planillas. validar_url() rechaza la contrabarra y
los invisibles de formato (U+200B, U+FEFF, U+200D, marcas de dirección):
un escape de su clase de caracteres dejaba pasar
https://ejemplo.com\@otro.com.comision + neto = bruto
con 30 filas rotas por centavos salía ok con 0 filas sobre
importes de 1e8, y contaba 21 de 30 sobre importes de 1e6. Por encima de
ese límite un decimal guardado no se distingue del redondeo de un texto
de 15 cifras: la tolerancia relativa manda y la evidencia dice cuánto
tolera. Con más de la mitad de las filas rotas por un cuanto la
identidad no se publica como sana: se descarta, se cuenta en
meta$aritmetica_columnas$identidades_descartadas_cuanto y
deja una fila en cobertura_diagnosticos con la relación y
el motivo. En una suma, la tolerancia se mide también sobre los
sumandos: a = 1e9 + x, b = -1e9 + y,
c = x + y acusaba 16 de 300 filas sanas. La evidencia
declara la cota. Una columna que varía menos que la tolerancia relativa
de su magnitud —los sumandos de 1e11 + x y
-1e11 + y— se evalúa con la cota del cuanto si sus tres
columnas guardan decimales fijos; si no,
cobertura_diagnosticos dice qué relación reconocía la
tolerancia y por qué no se publicó (antes se descartaba sin rastro desde
1e11). Una suma con un total calculado en R cuyos sumandos se cancelan
(0.30 - 0.29 no es el doble de 0.01) conserva
sus centavos: sobre importes de 1e6 a 1e10 sus filas corridas un centavo
salían ok.iva = round(neto * 0.22, 2) con 30 filas
corridas uno o treinta centavos salía ok con 0 filas desde
netos de 1e9, y sobre netos de 1e7 un producto sano acusaba 8 filas. Con
la tolerancia por omisión, si la tolerancia relativa supera la mitad del
cuanto de la columna redondeada, esa mitad, inclusiva, es la tolerancia
de todas las filas, y en k cada cifra de más tiene que
explicar al menos una fila más: una constante larga no se traga las
filas rotas de los importes grandes, y un tipo de cambio largo no se
trunca para acusar los importes grandes sanos; una fila rota suelta no
paga una cifra —en un empate, la más larga gana sólo si las filas que
agrega son de las de mayor magnitud—, y entre dos del mismo largo gana
la que deja más filas justo en el empate del redondeo
(0.0725 y no 0.0724 en
round(cant * 0.0725, 2)). La evidencia publica también la
mediana. La columna redondeada se lee como respuesta:
pesos = round(dolares * 39.8734, 2) se publica
pesos ~= dolares * 39.8734, y
resp ~= base * 1.22 no se lee al revés con
0.8196...; si las dos lecturas caben y la tolerancia de una
es el doble o más que la de la otra, se comparan con la fina —una fila
que sólo cae adentro con la gruesa no cuenta, y las cifras de la
constante se cuentan en la fina—. Con centavos llega a importes de 1e12,
como la identidad. Un neto y un iva redondeados por separado cuentan
como discrepantes las filas donde el iva no es el redondeo del neto
guardado. La que la tolerancia relativa reconoce y ninguna resolución
explica se descarta, se cuenta en
meta$aritmetica_columnas$proporcionalidades_descartadas_cuanto
y deja una fila en cobertura_diagnosticos; si la resolución
de alguna de las dos columnas es compatible con la relación, se publica
con la tolerancia relativa.datasets y las del paquete no
aparece ninguna relación nueva.x e y en cero en 180 de 200
filas y sin relación en las otras 20 se publicaba
x ~= y * 0.095 sospechoso, con las 20 filas
que podían decir algo todas en contra; lo mismo con 180 filas en un
mismo par de valores. Ahora tiene que alcanzar el criterio en las filas
con base distinta de cero, donde el par más repetido pesa a lo sumo una
de cada diez; una relación real con muchos ceros, como un iva sobre
netos en cero, se sigue publicando, y una con más de una fila de cada
diez rota entre las que no son cero no se publica. La que alcanza el
criterio sin ese soporte se cuenta en
meta$aritmetica_columnas$proporcionalidades_descartadas_soporte,
también cuando una identidad entre las mismas columnas la vuelve
redundante.y = round(x / 7, 2) se publica
y ~= x / 7 y no y ~= x * 0.143, que acusaba
dos filas sanas, y y = round(x / 3, 2) con una sola fila
grande, y ~= x / 3 y no 0.3334, que acusaba la
grande sana o callaba la rota. La recíproca cuesta las cifras de su
forma corta. Con las tolerancias de las dos lecturas parecidas,
y = round(x / 1.105) en enteros se lee
y ~= x / 1.105 y no x ~= y * 1.105, que
acusaba las filas sanas cuyo residuo cae entre las dos tolerancias (lo
mismo con 1,09, 1,18 y 1,22), y y = round(0.9 * x) en
enteros, y ~= x * 0.9: las filas que R redondea al par
quedan en el medio cuanto y no se acusan. Una constante truncada que
deja afuera filas sanas por un pelo ya no gana el empate a la entera:
y = round(x / 1.609344) se lee con 0.62137 y
no con 0.6214, que acusaba dos sanas y callaba la rota, y
round(x / 0.9144, 2) con 0.9144. Con una
tolerancia el doble de la otra, una fila corrida un cuanto ya no pasa
por empate del redondeo: y = x / 10 con tres filas corridas
cinco centavos las acusa. En magnitudes angostas los datos pueden no
distinguir una constante larga de una recíproca corta
(0.012345 de 1/81, 0.393701 de
1/2.54): gana la corta y puede acusar una fila sana.n_no_reversibles publicaba 0 al lado de un perfil
que contaba los valores que la conversión dejaría en NA (un
teléfono entre importes, 0x1A, una columna
raw), y su motivo cerraba con «se conserva como acción
destructiva no recomendada» también sobre una acción
bloqueada o no destructiva. Ahora termina con el estado:
bloqueada, o lista sin activar hasta configurarla.aplicar() ya no aborta el plan entero cuando una acción
de nombres no corresponde a los datos (un perfil con dos x
y datos con una): la registra fallida con su motivo y sigue
con las demás, como toda acción lista que falla; y el plan,
con los datos, la bloquea antes. Una columna de nombre vacío que falta
en los datos bloquea su grupo de columnas iguales. El lector de las
columnas de un hallazgo usa la trazabilidad antes que el texto: una
relación entre a y b ya no se confunde con una
columna llamada a,b; un hallazgo de una columna sin nombre
ya no se llama «de la tabla», y uno de varias columnas con una sin
nombre va a la lista de columnas no identificables. Una acción cuyos
parámetros no tienen la forma que espera —un vector, NULL—
queda fallida con ese motivo, no con un error de R.columnas_duplicadas cuando una columna del grupo no
está en el perfil, quedan bloqueada con el motivo: con un
perfil de otra versión de la tabla salían recomendadas y
aplicar() las registraba fallida.neto,iva,total, una de orden en
inicio,fin— como de «columna ambigua» con el motivo «el
nombre de columna se repite en la tabla», que era falso, también para
las relaciones ok. Uno así va a
hallazgos_sin_accion con su razón, nombrando sus columnas;
un ok no entra a ninguna lista sin acción; uno de la tabla
ya no habla de «esta columna»; y una columna que no está en el perfil lo
dice en vez de decir que se repite.detectar_claves() con muchas copias de un identificador
ya no arma las combinaciones que contienen una clave simple: con 100
copias tardaba 36 s y con 1.000 combn() no entraba en
memoria; ahora 0,2 s y 6 s, con la misma salida.detectar_dependencias() toma la muestra de una fila por
tramo de la tabla, en una posición que sale de un hash determinista del
tramo, y no a paso fijo: el paso fijo se alineaba con un panel mensual y
tomaba sólo dos meses de cada doce. Sigue siendo la misma en cada
corrida, sin azar.desviacion_benford dice si la desviación la producen
los faltantes disfrazados que no se declararon, con la prueba sin ellos:
200 valores 999 entre 4.000 importes daban p = 1e-45, y sin
ellos p = 0,22.sentinelas_numericos declarado,
valor_concentrado deja afuera lo declarado, como el
resumen: publicaba como moda el -99 que el resumen
excluía.detectar_dependencias() no publica un par cuyo
determinante no acierta más filas que la moda del dependiente (con un
estado al 99,66 % salían cinco dependencias que no decían
nada), y lo que encuentra en la muestra lo recalcula sobre la tabla
completa: una muestra alineada con la estructura de los datos publicaba
0,996 de cumplimiento donde la tabla da 0,899.
detectar_relaciones() calcula las coberturas sobre las
columnas completas (con una muestra alineada publicaba 1 donde era 0,5)
y muestra ya no recorta.
clasificar_variables() cuenta
n_niveles_observados sobre la columna entera también sin
perfil, y meta$aritmetica_columnas se publica también
cuando la única identidad candidata se descarta.aplicar() con conservar_primera_duplicada
podía borrar filas legítimas (23.673 de 60.100 en una tabla con 200
repetidas), y EntidadDuplicada, referencial()
y las acciones de duplicados contaban grupos equivocados. Una matriz o
una tabla anidada como columna se aplana para esa identidad, como en el
perfil.medir() ya no se cae con una columna lista —lo que un
motor devuelve para una columna binaria— cuando una métrica no puede
producir medidas: la métrica queda no_medible. Una tabla
anidada, una matriz de listas o un entorno en una celda tampoco la hacen
caer, y perfilar() ya no publica más filas completas que
filas con una matriz de listas.NoNulo compara valores_nulos con la misma
normalización que perfilar(): sin los blancos de los bordes
y sin distinguir mayúsculas. Una celda de solo blancos o un tabulador
cuentan como nulos para los dos.agregar() de instanciaEntidad a
entidad conserva la instancia en el nombre
(agregada:ratio:ClaveDuplicada@t.a.b): dos claves
compuestas de la misma tabla ya no se funden en una sola fila con un
resultado mezclado. De instanciaAtributo a
atributo, dos instancias de una métrica sobre la misma
columna llevan la instancia en el nombre solo en ese caso. Más arriba,
el nombre conserva la instancia que traen todas las partes, y
agregar() se niega a promediar dos instancias de una misma
tabla o columna, que la harían pesar doble, y dice cómo seguir.medir() arma su tabla de medidas de una sola vez, sin
una tabla intermedia por métrica: sobre una tabla de 80.764 filas y 153
columnas de texto con 100 métricas, bajó de 133 s a 56 s y su pico de
memoria de 4,9 GB a 3,5 GB, que es del orden de la tabla de medidas que
devuelve (8 millones de filas).perfilar_dbi() con
universo = "tabla_completa", el desvío de las columnas de
SQL Server y de double precision de PostgreSQL se calcula
en lotes, centrado en la media que ya trajeron los básicos, y no en una
consulta por columna. Sobre una tabla de un millón de filas y 27
columnas numéricas, el desvío pasó de 27 consultas a 2 y de 1,42
millones de lecturas lógicas a 105 mil en SQL Server, con las mismas
cifras. En un motor que lee del disco, cada consulta de desvío recorría
la tabla entera.[1e-150, 1e150] se calcula sobre sus valores divididos por
una potencia de dos y centrados en su propia media, en los cinco motores
y en perfilar(). Cerca del máximo del doble (±1,8e308), SQL
Server, MySQL y MariaDB dejaban el desvío en NA sin avisar
y perfilar() publicaba Inf; con valores del
orden de 1e-160 todos perdían cifras (error de hasta 7e-4),
con 1e-200 perfilar() publicaba
0, y en PostgreSQL 16, por encima de 1e150, el
desvío pasaba por un numeric de 15 cifras (error de 4e-5).
Ahora queda a menos de 1e-14 de la cifra exacta, o
no_disponible con su falla y el aviso. Las columnas de
magnitud común conservan la consulta y la cifra.1e65 y 1e150 perdía cifras (error de hasta
9e-5): el centro se escribía como un decimal de más de 65 cifras. Y
cuando la suma desbordaba, MySQL publicaba la media en 0 y
MariaDB en NA, sin avisar; ahora la media también se
calcula escalada.RMySQL, un perfil ya no suelta decenas de avisos
del controlador (Decimal MySQL column imported as numeric):
lupa pide en el SQL el tipo que lee, con las mismas cifras. Un
error while fetching rows del controlador cuenta como falla
de la consulta y no como un resultado vacío.DECIMAL con valores de 2^53 o
más ya no publica mínimo, máximo, media, mediana ni desvío con cifras
falsas (12345678901234567168 por
12345678901234567890): quedan no_disponible
con su motivo, como en PostgreSQL y SQL Server. Con
metricas explícitas, ese motivo decía «no se pidió».400:63f9…), la misma representación que usa la muestra, en
minúsculas en todos los motores; la corroboración ya no la marca
no_corroborada, y en el perfil de la muestra la columna
figura como blob. Con
universo = "muestra_motor", una columna
char(n) de SQL Server ya no publica la moda con los
espacios de relleno.filas_obtenidas = 0 y el aviso dice cero filas, no
NA. Con TABLESAMPLE o RANDOM(),
meta$orden_muestra declara que orden_muestra
no gobierna la selección.n_distintos no se midió —no se pidió, o su consulta
se cortó por tiempo—: ningún valor se repite.universo = "muestra_motor", un
max_consultas chico ya no hace abortar el perfil. Con
valores de 1 a 12, según el motor, la corrida terminaba en error: el
presupuesto se agotaba al leer el esquema, o al contar la tabla que
TABLESAMPLE necesita para escribir su porcentaje. Ahora
degrada y lo declara en meta$consultas$agotado, con las
métricas que no entraron como no calculadas, la cobertura y el
aviso.text o bytea sin largo
declarado se estimaban unos 125 KB por fila, y con
max_bytes_muestra = 100000 sobre filas de 3,7 KB llegaba
una. Ahora se lee una fila, se mide lo que ocupa y se sigue en bloques
sin pasar el tope —en ese caso, unas 25 filas—, y
meta$muestreo$filas_por_bytes_fuente lo declara.universo = "muestra_motor", el desvío se pide
centrado en la media de las mismas filas y en la misma consulta: una
relación derivada sobre la muestra calcula esa media con una ventana
(AVG(x) OVER ()). Sin centrar, en SQL Server unos montos de
un millón daban el desvío con un error de 2,3e-3, y en PostgreSQL 16
valores casi constantes, de 5e-3; en MySQL y MariaDB pasaba también con
metricas = "desvio" en tabla_completa. Esa
misma evaluación de la muestra da las filas obtenidas, decide el
reintento y entra en los agregados: con TABLESAMPLE SYSTEM,
algunas corridas dejaban la media y el desvío no disponibles mientras
declaraban 300 filas obtenidas.incluir_valores = FALSE), y también
cuando el rango es tan chico que sus cuadrados caerían en subnormales.
Antes MariaDB llegaba a publicar 1.7976931348623157e+308
como desvío y MySQL una media de 0. Con un solo valor válido, el desvío
es no_aplica y no dispara un repliegue.bloque_filas, el desvío y la media de valores
extremos ya no salen Inf, 0 ni NA
como calculados: el estado se reescala por una potencia de dos cuando
llega un bloque que la escala vigente no cubre. La moda de una columna
binaria también sale en esa vía, como largo y MD5, y una columna
image de SQL Server publica su moda.stringdist, el diagnóstico de
proximidad del vocabulario deja una sola fila de cobertura por columna,
la que dice que falta el paquete. Antes agregaba otra que hablaba de un
presupuesto agotado («se comparó entre sí a las 0 primeras») y
recomendaba subir max_trabajo_vocabulario, que no arreglaba
nada.bloque_filas y un controlador sin lectura
incremental demostrada —DuckDB, o uno que no está en la matriz—, el
perfil sigue sin caer en dbGetQuery(), pero ahora lo avisa
(lupa_aviso_muestra_motor): antes todas las métricas
quedaban no_disponible y el motivo solo estaba en la
cobertura.universo = "muestra_motor", estado y
error_esperado se deciden por métrica y con la misma regla
en las dos vías, como dice la ayuda. Antes, con
bloque_muestra = "solo_agregados", los distintos y la
mediana de la muestra salían error_esperado = "no_aplica",
lo que se publica cuando no hubo muestreo; y con
"con_muestra" todas las métricas salían
no_estimable —también la media y los conteos— y los
estadísticos observado_muestra en vez de
estimado. Los valores no cambian.n_filas() de una colección devuelve el vector con el
nombre de cada tabla.benchmark/medir_referencias.R; los 10.000 de antes eran más
rápidos que lo medido (unas 5.200 con 50 columnas), así que la espera
anunciada se quedaba corta. meta$costo_tabla_ancha$fuente
nombra los 2 guiones que la sostienen: ese y
benchmark/medir_topes_valores_ancho.R, con columnas iguales
de códigos de texto.estrategia en
detectar_duplicados_aproximados() dice exactamente cuándo
"auto" pasa a LSH (más de 10.000 filas,
muestra = Inf y max_pares de 50.000.000 o
más), y el aviso de LSH ya no llama «piso» a una referencia de la
comparación aislada.bloque_filas, las columnas binarias se leen como
largo y MD5, igual que en la muestra: con RMySQL el controlador ya no
las trunca (un aviso por fila, y largos y distintos falsos), y en
PostgreSQL, SQL Server y MariaDB los distintos y los largos dejan de
quedar no disponibles.BIGINT, UBIGINT,
HUGEINT y UHUGEINT, y con RMySQL— ya no sale
con cifras falsas (1234567890123456768 por
1234567890123456789): se pide como texto exacto, también
con bloque_filas. En DuckDB, un UHUGEINT de
esa magnitud ya no publica mínimo, máximo, media ni mediana falsos, y la
mediana de un HUGEINT cerca de su tope, cuya consulta de
básicos desborda en el motor, queda no disponible en vez de publicarse
como un doble.bloque_filas, una columna de un solo valor o vacía
ya no publica NA como calculado: el desvío queda
no_aplica y las métricas de una columna vacía,
sin_valores. Y con RMariaDB un bigint unsigned
mayor que 2^63, que el controlador entrega dado vuelta a negativo, ya no
se publica como calculado: queda no disponible con su motivo.100000000 o 0 como calculada.12345678901234567168 por
12345678901234567890): se le pide al motor como texto
exacto en PostgreSQL, SQL Server, MySQL, MariaDB y DuckDB. Con
incluir_valores = FALSE, el motivo de precisión de esas
columnas ya no se reemplaza por uno de privacidad.NaN en la columna ya no deja el
mínimo, el máximo, la media y el desvío sin calcular: se miden sobre los
finitos, como en perfilar(). Con el presupuesto agotado,
n queda no_disponible con su motivo y no
NA como calculado.match() sobre fechas era cientos
de veces más lento, y una columna Date hacía tardar minutos
el perfil: 100.000 fechas pasaron de 171 s a 1,3 s en R 4.5.2.
Date, POSIXct, difftime, los
factores e integer64 se comparan por una clave sin clase,
con el mismo resultado.max_largo_valor_vocabulario (10.000 caracteres o bytes)
quedan fuera solo de las operaciones textuales caras —normalización,
patrones, reconocedores de datos personales, casi duplicados—, y la
cobertura lo declara con texto_largo_no_evaluado y una fila
por diagnóstico afectado, para que comparar_perfiles() diga
no_evaluado y no resuelto. Los conteos, la
inferencia de tipo, los blancos, los centinelas y las dependencias
siguen leyendo el valor entero. Sobre 700 filas de cuatro columnas de 14
KB, el perfil pasó de 23 s a 5 s.trazabilidad$columnas, y la cobertura en una columna
columnas. Una clave con un nombre así se pide con un
vector.cobertura_analisis() acepta el resultado de
perfilar_dbi(): analiza la muestra y dice que la cobertura
es de la muestra; con bloque_muestra = "solo_agregados",
usa el resumen de la tabla.universo = "muestra_motor", los topes de bytes y de
celdas (max_bytes_materializacion,
max_bytes_muestra, max_celdas_muestra) mandan
antes de leer. Cada dbFetch() se pide con un tamaño máximo
de fila conocido de antemano: los textos de más de
max_largo_valor_vocabulario y las columnas binarias
(bytea, varbinary, image,
blob) se piden como largo y resumen MD5, con los distintos,
los duplicados, los faltantes y los largos exactos. Si el presupuesto se
agota, se conserva lo que entró. Antes, una columna binaria o de textos
largos podía traer varios GB a R antes de mirar el tope.BERNOULLI en PostgreSQL o una fracción mayor por bloques,
sin ordenar la tabla entera; el aviso sale solo si la muestra final
sigue corta o la recortó un tope.resumen_tabla$meta$consultas$fallas y en la cobertura como
degradado, con un aviso de clase
lupa_aviso_muestra_motor que nombra ese camino completo
(antes decía meta$consultas$fallas, que sobre el resultado
da NULL); las consultas internas del paquete (capacidades,
catálogo, configuración) no avisan. La muestra del motor publica también
sus tiempos, sus bytes y el tope que mandó.perfilar_dbi() avisa
(lupa_aviso_costo_dbi) antes de recorrer con agregados una
tabla que el catálogo estima en 100 millones de filas o más, y sugiere
universo = "muestra_motor".PERCENTILE_CONT,
que ese motor devuelve con 10 decimales y un tope en 1e8: con
perfilar_dbi() por omisión, una columna de montos del orden
de 1e12 publicaba 1e8, una de valores del orden de 1e-12 publicaba 0 y
un doble común perdía desde el décimo decimal, todo como
calculado. La prueba de capacidad del percentil exige ahora
que vuelvan todas las cifras, y MariaDB calcula la mediana por columna
(tabla completa) o con la CTE de ventanas (muestra), como MySQL. Vale
también con estrategia_mediana = "aproximada_motor" y con
RMySQL contra un servidor MariaDB.universo = "muestra_motor" y
bloque_muestra = "solo_agregados", la mediana sale en
MySQL, en un float8 de PostgreSQL y en una columna con
valores extremos de cualquier motor: la calcula la CTE de ventanas sobre
la misma muestra, como con con_muestra. La consulta de
prueba de esa CTE usaba una construcción que MySQL rechaza.metricas sin la cuenta de valores válidos, la
mediana de la tabla completa cuenta esos valores en una consulta propia
y sale igual que con todas las métricas. Con
dialecto = "portable", que no tiene salto de filas, sale de
la CTE de ventanas si el motor la acepta.perfilar_dbi() afirma un valor
ausente: un estado calculado, estimado u
observado_muestra con el valor en NA pasa a
decir por qué falta. Es sin_valores si la columna está
vacía (en la muestra, no_disponible con
muestra_inestable:sin_valores_validos), y
no_aplica para una métrica numérica sobre una columna que
no lo es, para el desvío de menos de 2 valores y para la moda de una
columna sin repetidos (en la muestra, no_disponible, porque
la tabla puede tener moda).decimal con 36 cifras
de precisión o más ya no pierde decimales: AVG(valor * 1.0)
recortaba la escala a 6, y en un decimal(38,7) la mediana
de 0,0000001 y 0,0000003 salía 0. Con compatibilidad menor que 110, sin
PERCENTILE_CONT, ese era el camino de todo
decimal. Ahora el motor suma las una o dos centrales en el
tipo de la columna, y R divide esa suma por cuántas son: la mediana es
el doble más cercano de la exacta. Convertirlas a doble en el servidor
la dejaba a un ulp, y promediar en R el doble de cada central tampoco es
exacto (la de 0,10 y 0,20 daba 0,15000000000000002). Lo mismo en MySQL y
MariaDB, donde AVG(valor * 1.0) necesita una cifra de
escala más que la columna y en la escala máxima del motor (30 y 38) se
recortaba: la mediana de 1e-30 y 2e-30 salía 2e-30.dialecto = "portable", y en la
muestra con la subconsulta escalar, la mediana de una cantidad par de
float8 coincide con median(): difería en 1 ulp
en 427 de 3.000 pares. Usa el mismo promedio que la vía de dos
consultas.perfilar(), una errata de texto
(Montevideo/Montevido) ya no queda callada
porque la misma columna tenga una familia de códigos numerados con
frecuencias desparejas. La familia sigue declarando que el diagnóstico
no aplica a las formas con números; los grupos sin números se juzgan con
el mismo límite y contra el mismo vocabulario entero de la columna:
salen igual que si la familia no se encadenara.ALFA y Alfa). Con una de esas clases
delante, el filtro de marcas de formato leía otro par: en una columna de
horas publicaba como casi duplicados pares
a.m./p.m. que tiene que descartar y perdía el
hallazgo real; la fila de cobertura «N grupos de formas cercanas no se
formaron…» desaparecía, y el diagnóstico de variantes equifrecuentes
nombraba formas que no son pareja. Sin esas clases, o con la clase
después de la pareja, la salida es la misma.perfilar(), una pareja cercana cuyas formas
normalizadas empatan en frecuencia ya no queda sin declarar porque uno
de sus lados junte grafías que se normalizan igual
(Montevideo y MONTEVIDEO, 25 cada una, contra
Montevido, 50). Se publicaba sólo el grupo de esas grafías,
y la pareja no aparecía en la fila de cobertura «N grupos de formas
cercanas no se formaron…» ni, con
variantes_equifrecuentes_vocabulario = TRUE, como hallazgo.
Ahora se declara igual que sin esas grafías, y el grupo equifrecuente
las lista todas con su frecuencia; su asimetría es la de las formas
normalizadas (MONTEVIDEO 10 y Montevideo 40
contra Montevido 50 da 1, no 5).perfilar(), una pareja que
casi_duplicados_vocabulario ya publica no se cuenta además
en la fila de cobertura «N grupos de formas cercanas no se formaron…»,
ni sale otra vez como variantes_equifrecuentes_vocabulario
con el detector encendido. Con los valores por omisión pasaba en el
borde: Montevideo (50) contra Montevido (25)
tiene asimetría 2, que llega al piso de
min_asimetria_vocabulario y no pasa el tope de
max_asimetria_equifrecuente_vocabulario, y la salida
publicaba la pareja y decía a la vez que no se había formado. Lo mismo
con las variantes de igual frecuencia de un grupo publicado
(Zona B … Zona O alrededor de
Zona A). Lo que el piso de asimetría deja afuera se sigue
contando. Y la cantidad de pares que esa fila declara («Se identificaron
M pares cercanos…») es la de los grupos que cuenta: sumaba también los
de los grupos ya publicados y los de las cadenas que el tope de
asimetría o el límite del vocabulario dejan afuera.perfilar(), cada par cercano del vocabulario se
declara una sola vez también cuando el grupo de formas cercanas toca,
por otra de sus formas, un grupo que
casi_duplicados_vocabulario publica. Con
Montevideo (100), Montevido (50) y
Montividoo (50) se publicaba [Montevideo / Montevido] y la
fila de cobertura decía a la vez «1 grupo de formas cercanas no se
formó… Se identificaron 2 pares», contando esa misma pareja; con
variantes_equifrecuentes_vocabulario = TRUE la pareja salía
otra vez dentro de [Montevideo / Montevido / Montividoo]. Ahora la fila
cuenta 1 par y el grupo equifrecuente es [Montevido / Montividoo]: la
forma que comparten se nombra en los dos grupos y cada uno declara sus
pares. Un par que quedaba sin declarar porque la pareja publicada
llevaba la asimetría del grupo por encima de
max_asimetria_equifrecuente_vocabulario ahora se cuenta, y
dos grupos que sólo se tocaban por una pareja publicada salen separados.
Los grupos de casi_duplicados_vocabulario no cambian.proximidad_vocabulario, los
pares cercanos que forman cadenas cuya asimetría de punta a punta supera
max_asimetria_equifrecuente_vocabulario se declaran aparte:
con Montevideo (25), Montevido (20) y
Montividoo (10), a 1,25 y 2 de a pares y a 2,5 de punta a
punta, la fila dice «…2 pares cercanos, con asimetría <= 2.0 entre
ellos, forman cadenas cuya asimetría de punta a punta supera 2.0 y no se
agrupan». Antes no se declaraban en ningún lado. El tope por grupo no
cambia.{1, 2, 2^63 - 1} en
BIGINT es 2, y quedaba no_disponible); con una
par, si las dos centrales quedan entre -2^52 y 2^52, lo que en la tabla
completa cuesta una consulta más. En DuckDB, la de un
HUGEINT cerca de su tope con una cantidad par ya no sale
del promedio de dos dobles redondeados (2,5 por 2). La misma regla
siguen perfilar() sobre integer64 o sobre
enteros escritos como texto, perfil_muestra y la muestra
del motor, que tienen las centrales a la vista: la corroboración ya no
acusa una divergencia entre el resumen SQL, que publicaba la mediana, y
la muestra, que la negaba por la columna.DECIMAL ya no se trunca a
la escala de la columna: la de 1,00 y 1,01 en DECIMAL(10,2)
salía 1,00.PERCENTILE_CONT (-1 por -0,5).bloque_filas en SQLite, una columna
INTEGER cuyos primeros bloques entran en 32 bits y otros no
ya no cuenta mal n_distintos, la moda ni la mediana
({1, 2, 3e9, 3e9} daba 4 distintos, ninguna moda y mediana
0,5).decimal(38, s) ya no sale mal cuando la media termina en la
mitad de la última unidad: {1, 2, 3, 4} en
decimal(38,0) daba 1,8257 por 1,2910.bloque_filas, y por la muestra del motor, el desvío
de un decimal que el doble no representa ya no sale de esos dobles: un
numeric(18,2) de 5e14 con desvío 3 daba 3,1115 por 3,1047,
y con la muestra leída en R
(bloque_muestra = "con_muestra") se publicaba movido en una
parte en 300. Por la tabla completa y por bloques, el motor suma en el
tipo de la columna, y devuelve como texto, la columna y los cuadrados de
sus diferencias con la media escrita en su escala, y R saca el desvío
exacto: es el doble más cercano. Con la muestra leída en R sale del
texto de cada valor, que la muestra ya traía. Por la muestra del motor
con bloque_muestra = "solo_agregados" sale de las mismas
sumas, pedidas en la sentencia de los agregados. Un decimal de escala 0
con valores por debajo de 2^53 se publica en todas las vías: ahí los
dobles son los valores, y la escala la dicen los catálogos de
PostgreSQL, MySQL, MariaDB, DuckDB y SQL Server, que ahora publica la
precisión y la escala de un decimal (decimal(18,0) y no
decimal).bloque_filas y con la muestra leída en R, la media
y la mediana de un decimal que el controlador entrega como doble son el
doble más cercano de las del decimal, y no las de esos dobles: la de
0,0001 y 0,0002 daba 0,00015000000000000001, a un ulp en 14 de 112
medias y 9 de 112 medianas de SQL Server y en 4 y 2 de 46 de PostgreSQL,
MySQL, MariaDB y DuckDB, y con valores de hasta 1e12 con seis decimales
que se cancelan, una media por bloques de numeric(20,6) en
PostgreSQL quedaba a 1.447 ulps. Por bloques el motor suma la columna en
su tipo, en una consulta para todas las columnas decimales, y devuelve
como texto las dos centrales cuando caen en dobles distintos (una
consulta ordenada por columna; money de SQL Server siempre,
porque odbc no lo lee al doble más cercano). La muestra leída en R ya
traía cada decimal como texto.999999999999999.99,
-999999999999999.98, 0.01, 0.02,
0.03 y -0.04 daban 0,00333 por 0,005; y el
desvío de los cinco motores con decimales, y la media con escala 30,
quedaban a un ulp. El motor suma la columna y sus cuadrados en su tipo y
los devuelve como texto, en la misma consulta que los demás agregados, y
R divide y saca la raíz con aritmética entera. Por bloques, el desvío de
un decimal sale de una consulta de sumas, sin consultas de más: el de
500000000000006.60 y sus vecinos quedaba a un ulp, y el de
1.10, 2.20 y 3.30, también. Con
incluir_valores = FALSE, el SQL publicado lleva la media
tapada.tamano_lote_planos columnas —por la tabla completa y la
muestra del motor, los de los agregados; por bloques, los suyos, con las
expresiones que acepta cada motor— y cada expresión se elige para que no
desborde ni redondee con las cifras del tipo y las filas. Con una sola
consulta para toda la tabla, 600 columnas numeric(18,2)
pasaban el límite de 1.664 expresiones de PostgreSQL y por bloques no
quedaba ninguna media; en DuckDB el cuadrado de un
DECIMAL(15,0) desbordaba en 64 bits y todas las columnas de
la tabla quedaban con la media y el desvío del motor; y un
decimal(38,30) de SQL Server con valores de -1e8 a 1e8 no
tenía cuadrado exacto y quedaba el STDEV del motor, a uno o
dos ulps. Un lote que el motor rechaza se parte hasta aislar la columna,
y el plan cuenta los lotes y, como máximo, los reintentos. Las sumas
salen ahora con cualquier metricas (con
c("basicos", "desvio") o sólo "desvio" la
tabla completa publicaba la del motor: en PostgreSQL 9.3, 1,63 por
0,1425), con incluir_valores = FALSE, con un
max_consultas igual al total del plan, con valores de 2^53
o más —cuya media y desvío quedaban no_disponible— y bajo
la muestra del motor con bloque_muestra = "solo_agregados",
en la misma sentencia que los demás agregados (la media de un
DECIMAL(18,2) cambiaba con el orden de las filas). En
DuckDB la media y el desvío del motor de esas columnas se piden sobre el
doble: x * 1.0 de un DECIMAL(38,30) de 9e7
desbordaba y tumbaba la consulta de los agregados, con las sumas
adentro. Por bloques, NaN e Infinity de
PostgreSQL quedan fuera de las sumas, como en la tabla completa. Si las
sumas no llegan, la media y el desvío del motor por la tabla completa
quedan sólo si su error cabe en una parte en mil millones; si no,
no_disponible, con el motivo de por qué no llegaron: el
motor rechazó la consulta con las sumas, con su mensaje, o no hubo
presupuesto. Si llegan sin valores, el estado sale de la cuenta: una
columna toda NULL queda sin_valores y el
desvío de una sola fila, no_aplica. La escala de un decimal
de una tabla temporal la leen el catálogo de tempdb en SQL
Server y SHOW COLUMNS en MySQL y MariaDB: sin ella, el
desvío quedaba a un ulp o no_disponible.validos en metricas, el mínimo, el
máximo, la media y el desvío de un doble o un entero no sabían cuántos
valores vieron: una columna toda NULL daba la media
no_disponible con «La consulta terminó sin un valor para la
métrica» y el desvío no_aplica, y el desvío de una sola
fila no_disponible, donde la ayuda promete
sin_valores y no_aplica. La cuenta de los no
nulos va ahora en la misma consulta de los agregados, sin consulta
nueva, y decide como la de las sumas exactas de un decimal. Por el
spool, una tabla sin filas publicaba n_validos,
n_faltantes y n_distintos en cero como
observado_muestra; ahora, como una muestra vacía de una
tabla con filas, no_disponible con
muestra_vacia:<método>.validos en
metricas, una columna de PostgreSQL con
(NaN, NULL) publicaba el desvío no_aplica
mientras el mínimo, el máximo y la media decían
sin_valores, y un numeric sólo
NaN decía «La columna no contiene valores no nulos», que es
falso. Ahora la columna que mostró NaN o infinitos la
decide la vía de los valores finitos, con su motivo, y si la magnitud no
se pudo establecer queda declarada con ese motivo.real de PostgreSQL con NaN o
infinitos ya no deja una sentencia girando: la expresión exacta de los
valores finitos se multiplicaba al fundirse las subconsultas, y el
planificador tardaba minutos aun sobre tres filas, sin atender a
statement_timeout.universo = "muestra_motor" y
bloque_muestra = "solo_agregados", cada sentencia sortea su
muestra, y lo que decidía los agregados de una columna podía salir de
otra. La sonda de magnitud era una consulta propia: si le tocaba una
muestra vacía, el desvío se publicaba no_aplica con un lote
de cien valores. En SQL Server, con metricas = "desvio",
cada columna de coma flotante forzaba un repliegue que sorteaba otra
muestra: publicaba el desvío de filas que la corrida no publica, o
no_disponible. Ahora la magnitud viaja en el lote de
agregados, la misma sentencia que el desvío, y
plan_perfilado_dbi() ya no la cuenta aparte. Bajo la
muestra no hay repliegue escalado de la media ni del desvío: una columna
con valores de más de 1e150 o de menos de 1e-150 en valor absoluto queda
no_disponible con su motivo, en lugar de publicar el valor
de otra muestra.metricas = "desvio", una tabla
sin filas por la muestra del motor publicaba el desvío
no_aplica («requiere al menos dos valores»): al pedirse el
desvío solo, la consulta perdía el total del lote. Ahora queda
no_disponible con
muestra_vacia:<método>, como en los demás motores, y
meta$filas_obtenidas_muestra dice 0.incluir_valores = FALSE, el SQL publicado del
desvío centrado de un entero o un doble lleva la media tapada: publicaba
la media como literal
(STDDEV_SAMP((b - 731946280004.333) * 1.0)), en los siete
motores.plan_perfilado_dbi() cuenta lo que la corrida emite
también sin validos: los agregados llevan el
COUNT(*) del total, que se pedía aparte y el plan no
contaba (13 contra 14 consultas con
metricas = c("basicos", "desvio") en PostgreSQL), y las
sondas de magnitud se cuentan con la regla de la corrida, que no las
pide para un entero chico con sólo desvio (dos de más por
tabla).plan_perfilado_dbi() cuenta la consulta de prueba de la
CTE de ventanas, y su control negativo, que la muestra del motor corre
cuando una columna decimal, o un float8 de PostgreSQL, deja
la mediana consolidada: dos consultas que el plan no anticipaba.plan_perfilado_dbi() anuncia lo que
perfilar_dbi() manda al motor en cada vía, contado
sentencia por sentencia en los siete motores. Por
bloque_filas contaba sólo el recorrido —1 consulta donde se
mandaban de 8 a 24— y ahora cuenta la preparación, las consultas de
prueba de la fuente, la segunda pasada del localizador, la moda exacta,
la media de los decimales y la muestra, con la mediana por centrales y
el desvío centrado de un decimal en total_maximo, porque
los piden los datos. Por la muestra del motor sin bloque de filas
contaba consultas del desvío que no se emiten, y no la lectura de
comprobación de la muestra; con el bloque de filas contaba los agregados
SQL, que el spool no corre. En PostgreSQL y SQL Server la estimación de
filas del catálogo del aviso de costo, y en PostgreSQL
SHOW extra_float_digits, se mandaban sin contarse.
max_consultas y meta$consultas$emitidas
cuentan lo mismo que el plan, y por bloques lo que el total anuncia
tiene su lugar reservado: con
max_consultas = attr(plan, "total") la media de un decimal
y perfil_muestra ya no quedan afuera; con
total_maximo no queda afuera nada. Con un
max_consultas más chico que el plan pueden entrar menos
métricas que antes: esas consultas ya llegaban al motor, sin
contarse.planificar_limpieza() sobre un perfil guardado por una
versión anterior, con un hallazgo por par de columnas iguales, ya no
compara cada hallazgo con todas las columnas: con 1.000 columnas iguales
(499.500 hallazgos), de 87 s a 4 s, con el mismo plan.perfil_muestra, en ninguna
vía, y la corroboración no lo cuenta como divergencia: queda en
perfil_muestra$meta$desvio_decimal_doble y en las no
comparadas con la causa decimal_doble. Pasaba por la vía
por omisión en los seis motores con decimales, y
perfilar_coleccion() subía la tabla a
alcance = "divergencias". Un desvío que el motor calcula
mal sigue siendo divergencia.universo = "muestra_motor", una muestra pedida
mayor que la tabla ya no se juzga corta: lo efectivo es lo pedido
acotado por el total que trae la primera consulta. Con
bloque_muestra = "solo_agregados" se reintentaba y se
avisaba una degradación falsa en SQLite, MySQL, MariaDB y PostgreSQL
9.3; en DuckDB el reintento escribía
TABLESAMPLE BERNOULLI (100), que el motor rechaza (ahí un
número sin unidad es una cantidad de filas), y todas las métricas de la
tabla quedaban no_disponible. BERNOULLI se
escribe en DuckDB con PERCENT.incluir_valores = FALSE, el mensaje de un error del
motor (una conversión fallida, un desborde) ya no cita la celda en
motivo, meta$consultas$fallas, la muestra ni
los bloques: pasa por el mismo piso que con la protección pedida.
PostgreSQL, SQL Server y DuckDB lo publicaban entero.perfilar(), de perfil_muestra,
de bloque_filas y de la muestra del motor es el doble más
cercano de la media exacta. Se acumulaba en doble, centrada en la media
del primer bloque, y se equivocaba sin aviso cuando los valores se
cancelan: c(-2^51, 1, 2, 2^51) daba 0,6875 por 0,75; quince
mil valores de 2^51, quince mil de -2^51 y 1:3, una media
de signo cambiado; y en perfil_muestra la corroboración lo
contaba como divergencia contra el AVG del motor. También
sin cancelación: rnorm(2e6) quedaba a 19 ulps, y cuarenta
enteros chicos por bloque_filas = 7, a ocho. Cada bloque se
suma ahora sin redondeo, sin depender del long double de
sum(), con el mismo costo.perfilar(), de
perfil_muestra, de bloque_filas y de la
muestra del motor es el doble más cercano del desvío exacto (con
n - 1). Se acumulaba con Welford en doble y quedaba a uno,
dos o tres ulps: ((1:25) %% 7 - 3) * 0.3 a uno en memoria
(como sd()), y por bloque_filas = 7 a dos.
Ahora la suma de los cuadrados es exacta o tiene una cota demostrada, y
el redondeo se decide comparando contra los puntos medios con aritmética
exacta, sin depender del long double de sum();
el resumen de una columna común de 2 millones de filas no tarda más. La
media también es la más cercana en una columna con valores de más de
2^900 junto a otros diminutos (con 2^1000, -2^1000 y valores de 2^-1000
salía 0). Y la rama de texto de un entero que pasa de 2^53 saca los
centinelas declarados como integer64 —no entraban en los
extremos exactos, los conteos ni la mediana— y lee "-0"
como el cero. Un centinela así escrito se reconoce por sus cifras
también donde R lee ese texto a un ulp del valor (macOS sobre arm64,
cuyo long double es un doble):
"1152921504606846976" con 2^60 declarado
quedaba en el resumen y la media salía 2,9e17.PERCENTILE_CONT, que interpola en doble y
la dejaba a un ulp. En DuckDB la suma se lee por su texto (el
controlador convierte un decimal de más de 18 cifras a un doble que no
es el más cercano), y en SQL Server el money se suma como
decimal(38,4), que no desborda. Cuesta una consulta por
columna decimal, que plan_perfilado_dbi() cuenta.CAST(... AS VARCHAR) es
VARCHAR(30), y la lectura de toda la muestra abortaba) y
money con sus cuatro decimales: 0,0001 se leía 0, y el
mínimo, la media y el desvío de una columna de 0,0001 a 0,0004 salían
0.HUGEINT o
UHUGEINT cerca de su tope desborda, la consulta de mínimo,
máximo y conteos se repite sin el promedio: esas métricas se juzgan como
en cualquier columna que pasa de 2^53, y la media queda
no_disponible con su propio motivo. Antes caían todas con
el error del motor por motivo, que citaba el valor de la celda aun con
incluir_valores = FALSE.{2^53 - 2, 2^53 - 1} daba 1 por
0,7071).requisitos_motor() declara PostgreSQL «9.3 y 16», las
dos versiones que se miden.sentinelas_numericos cuenta
como ausencia también en las dependencias funcionales de
perfilar() y en las asociaciones de
analizar(): la fila que lo tiene no se evalúa en el par,
como con un NA, y n_evaluados y
n_pares lo dicen. Con un -999 declarado en una
columna de palabras, el perfil perdía x -> y, porque el
centinela era un tercer valor; con un -999 en una columna
numérica, la media salía sin él y analizar() no publicaba
una asociación de 0,92. detectar_dependencias() y
detectar_asociaciones() reciben el mismo argumento. La
lista por omisión sigue sin sacar nada de ningún cálculo."-999", "-999.0",
"-9.99e2" o, con coma decimal, "-999,0" son el
mismo -999. El resumen, el detector de faltantes
disfrazados y la conversión de planificar_limpieza() usan
esa misma regla. Antes el resumen reconocía por sus cifras sólo la forma
entera, y el detector y el plan comparaban el doble leído: en macOS
sobre arm64, donde R lee "1152921504606846976" como 2^60 −
128, 2^60 declarado y escrito con .0 quedaba
en la media, el perfil no lo contaba como disfrazado y
aplicar() registraba la conversión fallida. Un
texto con más cifras de las que distingue un doble es el centinela sólo
si lo escribe exacto: en Linux, "1152921504606846976.4"
caía en el doble de 2^60 y se sacaba como si lo fuera.perfilar_dbi() y plan_perfilado_dbi() leen
las señas de la conexión una vez por corrida. Las consultaban al armar
cada sentencia, 184 veces sobre una tabla de tres columnas, y en duckdb
1.1 cada lectura manda pragma_version() al motor: 176
sentencias que el plan no anunciaba y max_consultas no
contaba. La ayuda declara fuera de la cuenta las que un controlador
manda para contestar DBI::dbGetInfo() o
DBI::dbIsValid(), una o dos por corrida.cobertura_analisis() y marco_agesic()
recomiendan para cada factor de AGESIC la vía que el paquete implementa.
Para «No-contradicción» decían «Requiere un backend o referencial
especializado que no integra esta versión.», aunque
EntidadContradictoria está implementada. La indicación
(como_resolverlo) sale ahora de las métricas que
catalogo_agesic() marca implementadas o por agregación: una
receta por métrica, con la cadena entera (especializar(),
instanciar(), medir()), el contrato en la
llamada que lo recibe y cada propiedad con el nombre que el código
acepta. Varias venían mal desde 0.1.0: mandaban a instanciar una métrica
sin especializarla, a escribir método, «expresión»,
Comprension o dominio, a declarar
vigencia() en las métricas de oportunidad por atributo, que
no la aceptan, o a crear referencial(completo = TRUE) sin
alcance, que aborta. El texto y la prueba que recorre cada
receta hasta una medición salen de los mismos pasos.Ã más U+0081), un guion blando («í», U+00AD) o un espacio
duro («à», U+00A0); y un C1 suelto puede ser un carácter de Windows-1252
(U+0080 por €). perfilar() publicaba
controles_invisibles además de
codificacion_rota por un solo defecto. Si en el plan se
desmarcaba reparar_codificacion,
eliminar_controles_invisibles y
normalizar_espacios_invisibles borraban ese byte y dejaban
«MarÃa» o «ÃREA», ya sin arreglo y sin hallazgo. Con las dos acciones
marcadas, aplicar() registraba fallida la
eliminación, que no tenía nada que hacer. Ahora las posiciones
protegidas salen de la misma reparación, y
recortar_espacios, reemplazar_separadores y
decodificar_entidades_html también las respetan. Si el
motor no puede reparar una celda, sus letras rotas tampoco las toca
ninguna acción, y la celda sigue señalada. Quedan dos casos sin cubrir.
Una comilla tipográfica, un guion o un emoji rotos que tienen pegado
delante un símbolo que impide la reparación (un espacio duro, un
°) todavía pierden su último byte con
eliminar_controles_invisibles; la celda sigue señalada. Y
una letra rota que el motor no reconoce como tal —«Š» leída como
Å más un espacio duro— no tiene protección ni hallazgo,
como antes. Un control que la reparación deja como está, como un U+0081
suelto o un guion blando junto a una letra rota, se sigue detectando y
quitando. El perfil cuenta un invisible sólo donde la acción puede
quitarlo, así que el plan ya no ofrece por esa causa una acción que
después termina fallida.aplicar() corre reparar_codificacion antes
que las demás acciones de su columna, aunque el orden
editado la ponga después. Con el orden por omisión ya era así. Si se la
reordenaba detrás de convertir_mayusculas, la conversión
operaba sobre el mojibake: «María» mal leída quedaba «MARíA», con la
letra reparada en minúscula.aplicar() y los detectores de
perfilar() leen bien las celdas declaradas
latin1 que tienen un byte de 0x80 a 0x9F. R traduce
latin1 como Windows-1252, que no define 0x81, 0x8D, 0x8F,
0x90 ni 0x9D: recortar_espacios fallaba con «input string
is invalid UTF-8» y la columna quedaba sin recortar, y otros detectores
avisaban o leían esos bytes como el texto <81>. Es lo
que deja un CSV de Windows-1252 leído con
encoding = "latin1", o uno en UTF-8 leído así: «ÁREA»
(C3 81) ahora se repara. Una celda que una acción cambia
queda en UTF-8, como documenta aplicar(). Y la marca no
decide nada: una columna declarada latin1 y la misma
columna en UTF-8 dan las mismas cuentas en el perfil, las mismas
acciones en el plan y los mismos valores al aplicarlo, con la reparación
marcada o desmarcada. Sólo cambia
n_codificacion_normalizada, que cuenta las celdas
latin1 que una acción dejó en UTF-8.planificar_limpieza() arma
convertir_sentinelas_numericos con los centinelas que el
perfil contó en esa columna, y no con el catálogo entero.
perfilar() decide por columna cuáles cuentan —un
999 dentro de una numeración de 1 a 2000 no es un
centinela; diez -9, sí—, pero la acción llevaba la lista
completa: al marcarla, aplicar() convertía también el
999 legítimo, y el registro decía 11 celdas donde el plan
anunciaba 10. Ahora la lista se lee de la evidencia del hallazgo, más lo
que se declaró en sentinelas_numericos. Si la evidencia no
alcanza a nombrar todo lo contado —una columna de texto con muchas
marcas de ausencia distintas—, si una marca declarada en
cadenas_ausencia contiene ; o si el perfil se
hizo con proteger_datos_personales = TRUE, la lista sigue
siendo el catálogo entero, como antes.Primera versión publicada.
perfilar() describe cada columna de un
data.frame: el tipo implícito, los faltantes reales y los
disfrazados (códigos y centinelas), los patrones de formato, los
formatos de fecha mixtos, los valores extremos, las filas duplicadas,
las dependencias funcionales y las claves. Lo que no puede medir lo
declara, con su motivo, en vez de dejarlo en cero.perfilar_dbi() hace el perfil dentro del motor, por
DBI, con una consulta por lote y no una por columna, muestras del motor
y presupuestos de trabajo declarados. Está probado contra PostgreSQL (16
y 9.3), SQL Server 2022, MySQL 8.4, MariaDB 11.8, SQLite y DuckDB.
perfilar_coleccion() y relaciones_coleccion()
perfilan varias tablas y proponen las relaciones entre ellas, y
estimar_costo() anticipa lo que va a costar una
corrida.analizar() hace el recorrido completo: el perfil, las
distribuciones, las asociaciones, el análisis temporal, la clasificación
de las variables y una propuesta de modelo de medición.detectar_duplicados_aproximados(),
detectar_claves(), detectar_relaciones(),
detectar_dependencias(),
detectar_formatos_fecha(),
descubrir_patrones(), inferir_tipo() y
distribucion_valores().marco_calidad()), y los de ISO/IEC 25012, CEPAL y AGESIC
listos para usar.metrica(), metricas_nucleo()), modelos de
medición (modelo(), especializar(),
instanciar()), mediciones (medir()),
agregación tipada (agregar()) y perfiles de evaluación
(perfil_evaluacion(), evaluar()).acumular_historico(),
guardar_historico()), la comparación de dos perfiles
(comparar_perfiles()) y la detección de deriva
(detectar_deriva_calidad()).planificar_limpieza() propone un plan editable de
acciones, cada una con su justificación y la severidad de lo que la
motivó. aplicar() lo ejecuta sobre una copia y deja el
registro de lo que cambió, y guiar_limpieza() muestra
ejemplos para decidir. lupa nunca modifica los datos que
recibe.reportar() escribe un informe HTML autocontenido, sin
depender de software externo para generarlo.perfilar() bajó de 0,63 s a 0,16 s (0,26 s con la
protección pedida) y analizar() de 1,36 s a 0,33 s.integer64 necesitan
además bit64 4.6.0 o posterior: con versiones anteriores,
match() de R iguala entre sí todos los valores negativos, y
lupa se niega con la condición
lupa_error_integer64 en lugar de publicar distintos, modas
y medianas equivocados.proteger_datos_personales = TRUE: publicar o no los valores
de una base es decisión de quien la usa.