

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Funciones de hiperloglog
<a name="hyperloglog-functions"></a>

Las funciones HyperLogLog (HLL) de SQL proporcionan una forma de estimar de manera eficiente el número de elementos únicos (cardinalidad) en un conjunto de datos grande, incluso cuando el conjunto real de elementos únicos no está almacenado. 

Las principales ventajas de utilizar las funciones HLL son:
+ **Eficiencia de la memoria**: los bocetos HLL requieren mucha menos memoria que almacenar el conjunto completo de elementos únicos, lo que los hace adecuados para conjuntos de datos de gran tamaño.
+ **Computación distribuida**: los bocetos HLL se pueden combinar en múltiples fuentes de datos o nodos de procesamiento, lo que permite una estimación eficiente y distribuida del recuento único.
+ **Resultados aproximados**: el HLL proporciona una estimación aproximada del recuento único, con una compensación ajustable entre la precisión y el uso de memoria (mediante el parámetro de precisión).

Estas funciones son especialmente útiles en situaciones en las que es necesario estimar el número de elementos únicos, como en aplicaciones de análisis, almacenamiento de datos y procesamiento de transmisiones en tiempo real.

AWS Clean Rooms admite las siguientes funciones HLL.

**Topics**
+ [función HLL\$1SKETCH\$1AGG](HLL_SKETCH_AGG.md)
+ [Función HLL\$1SKETCH\$1ESTIMATE](HLL_SKETCH_ESTIMATE.md)
+ [Función HLL\$1UNION](HLL_UNION.md)
+ [Función HLL\$1UNION\$1AGG](HLL_UNION_AGG.md)

# función HLL\$1SKETCH\$1AGG
<a name="HLL_SKETCH_AGG"></a>

La función de agregado HLL\$1SKETCH\$1AGG crea un boceto HLL a partir de los valores de la columna especificada. Devuelve un tipo de datos HLLSKETCH que encapsula los valores de la expresión de entrada. 

La función de agregado HLL\$1SKETCH\$1AGG funciona con cualquier tipo de datos e ignora los valores NULL. 

Cuando no hay filas en una tabla o todas las filas son NULL, el boceto resultante no tiene pares índice-valor como `{"version":1,"logm":15,"sparse":{"indices":[],"values":[]}}`.

## Sintaxis
<a name="HLL_SKETCH_AGG-synopsis"></a>

```
HLL_SKETCH_AGG (aggregate_expression[, lgConfigK ] )
```

## Argumento
<a name="HLL_SKETCH_AGG-argument"></a>

 *expresión\$1de\$1agregación*   
Cualquier expresión de tipo INT, BIGINT, STRING o BINARY con la que se realizará un recuento único. Se ignoran todos `NULL` los valores.

*lgConfigk*  
Una constante INT opcional entre 4 y 21, ambos incluidos, con el valor predeterminado 12. El log-base-2 de K, donde K es el número de cubos o ranuras del boceto.

## Tipo de retorno
<a name="HLL_SKETCH_AGG-return-type"></a>

La función HLL\$1SKETCH\$1AGG devuelve un búfer BINARIO no nulo que contiene el HyperLogLog boceto calculado debido a que consume y agrega todos los valores de entrada del grupo de agregación.

## Ejemplos
<a name="HLL_SKETCH_AGG-examples"></a>

En los ejemplos siguientes se utiliza el algoritmo HyperLogLog (HLL) para estimar el recuento distinto de valores de la columna. `col` La `hll_sketch_agg(col, 12)` función agrega los valores de la columna de columnas y crea un boceto HLL con una precisión de 12. A continuación, la `hll_sketch_estimate()` función se utiliza para estimar el recuento distinto de valores en función del boceto HLL generado. El resultado final de la consulta es 3, que representa el recuento distinto estimado de valores de la `col` columna. En este caso, los valores distintos son 1, 2 y 3. 

```
SELECT hll_sketch_estimate(hll_sketch_agg(col, 12))
    FROM VALUES (1), (1), (2), (2), (3) tab(col);
  3
```

El siguiente ejemplo también utiliza el algoritmo HLL para estimar el recuento distinto de valores de la `col` columna, pero no especifica un valor de precisión para el boceto HLL. En este caso, utiliza la precisión por defecto de 14. La `hll_sketch_agg(col)` función toma los valores de la `col` columna y crea un boceto HyperLogLog (HLL), que es una estructura de datos compacta que se puede utilizar para estimar el recuento distinto de elementos. La `hll_sketch_estimate(hll_sketch_agg(col))` función toma el boceto HLL creado en el paso anterior y calcula una estimación del recuento distinto de valores de la `col` columna. El resultado final de la consulta es 3, que representa el recuento distinto estimado de valores de la `col` columna. En este caso, los valores distintos son 1, 2 y 3. 

```
SELECT hll_sketch_estimate(hll_sketch_agg(col))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```

# Función HLL\$1SKETCH\$1ESTIMATE
<a name="HLL_SKETCH_ESTIMATE"></a>

La función HLL\$1SKETCH\$1ESTIMATE toma un boceto HLL y estima el número de elementos únicos representados por el boceto. Utiliza el algoritmo HyperLogLog (HLL) para contar una aproximación probabilística del número de valores únicos de una columna determinada, consumiendo una representación binaria conocida como búfer de croquis generada previamente por la función HLL\$1SKETCH\$1AGG y devolviendo el resultado como un entero grande. 

El algoritmo de boceto HLL proporciona una forma eficaz de estimar el número de elementos únicos, incluso en el caso de conjuntos de datos grandes, sin tener que almacenar todo el conjunto de valores únicos.

`hll_union_agg`Las funciones `hll_union` y también pueden combinar bocetos consumiendo y fusionando estos búferes como entradas.

## Sintaxis
<a name="HLL_SKETCH_ESTIMATE-synopsis"></a>

```
HLL_SKETCH_ESTIMATE (hllsketch_expression)
```

## Argumento
<a name="HLL_SKETCH_ESTIMATE-argument"></a>

 *hllsketch\$1expression*   
`BINARY`Expresión que contiene un boceto generado por HLL\$1SKETCH\$1AGG

## Tipo de retorno
<a name="HLL_SKETCH_ESTIMATE-return-type"></a>

La función HLL\$1SKETCH\$1ESTIMATE devuelve un valor de BIGINT que es el recuento distinto aproximado representado por el boceto de entrada.

## Ejemplos
<a name="HLL_SKETCH_ESTIMATE-examples"></a>

Los ejemplos siguientes utilizan el algoritmo de boceto HyperLogLog (HLL) para estimar la cardinalidad (recuento único) de los valores de la columna. `col` La `hll_sketch_agg(col, 12)` función toma la `col` columna y crea un boceto HLL con una precisión de 12 bits. El boceto HLL es una estructura de datos aproximada que puede estimar de manera eficiente el número de elementos únicos de un conjunto. La `hll_sketch_estimate()` función toma el boceto HLL creado por el boceto `hll_sketch_agg` y estima la cardinalidad (recuento único) de los valores representados por el boceto. `FROM VALUES (1), (1), (2), (2), (3) tab(col);`Genera un conjunto de datos de prueba con 5 filas, donde la `col` columna contiene los valores 1, 1, 2, 2 y 3. El resultado de esta consulta es el recuento único estimado de los valores de la `col` columna, que es 3.

```
SELECT hll_sketch_estimate(hll_sketch_agg(col, 12))
    FROM VALUES (1), (1), (2), (2), (3) tab(col);
  3
```

La diferencia entre el ejemplo siguiente y el anterior es que el parámetro de precisión (12 bits) no se especifica en la llamada a la `hll_sketch_agg` función. En este caso, se utiliza la precisión predeterminada de 14 bits, lo que puede proporcionar una estimación más precisa del recuento único en comparación con el ejemplo anterior, que utilizaba 12 bits de precisión.

```
SELECT hll_sketch_estimate(hll_sketch_agg(col))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```

# Función HLL\$1UNION
<a name="HLL_UNION"></a>

La función HLL\$1UNION combina dos bocetos HLL en un boceto único y unificado. Utiliza el algoritmo HyperLogLog (HLL) para combinar dos bocetos en un solo boceto. Las consultas pueden usar los búferes resultantes para calcular recuentos únicos aproximados como enteros largos con la función. `hll_sketch_estimate`

## Sintaxis
<a name="HLL_UNION-syntax"></a>

```
HLL_UNION (( expr1, expr2 [, allowDifferentLgConfigK ] ))
```

## Argumento
<a name="HLL_UNION-argument"></a>

 *eXPRN*   
`BINARY`Expresión que contiene un boceto generado por HLL\$1SKETCH\$1AGG.

*allowDifferentLgConfiguración*  
Una expresión BOOLEANA opcional que controla si se permite la fusión de dos bocetos con valores de lgConfigK diferentes. El valor predeterminado es `false`.

## Tipo de retorno
<a name="HLL_UNION-return-type"></a>

La función HLL\$1UNION devuelve un búfer BINARIO que contiene el HyperLogLog boceto calculado como resultado de la combinación de las expresiones de entrada. Cuando el `allowDifferentLgConfigK` parámetro es`true`, el boceto resultante utiliza el menor de los dos valores proporcionados. `lgConfigK`

## Ejemplos
<a name="HLL_UNION-examples"></a>

Los siguientes ejemplos utilizan el algoritmo de boceto HyperLogLog (HLL) para estimar el recuento único de valores en dos columnas `col1` y `col2` en un conjunto de datos.

 La `hll_sketch_agg(col1)` función crea un boceto HLL para los valores únicos de la columna. `col1` 

La `hll_sketch_agg(col2)` función crea un boceto HLL para los valores únicos de la columna col2. 

La `hll_union(...)` función combina los dos bocetos HLL creados en los pasos 1 y 2 en un solo boceto HLL unificado.

La `hll_sketch_estimate(...)` función toma el boceto HLL combinado y estima el recuento único de valores entre ambas y. `col1` `col2`

La `FROM VALUES` cláusula genera un conjunto de datos de prueba con 5 filas, donde `col1` contiene los valores 1, 1, 2, 2 y 3, y `col2` contiene los valores 4, 4, 5, 5 y 6. 

El resultado de esta consulta es el recuento único estimado de valores entre ambos `col1` y`col2`, que es 6. El algoritmo de boceto HLL proporciona una forma eficaz de estimar el número de elementos únicos, incluso en el caso de conjuntos de datos grandes, sin tener que almacenar todo el conjunto de valores únicos. En este ejemplo, la `hll_union` función se utiliza para combinar los bocetos HLL de las dos columnas, lo que permite estimar el recuento único en todo el conjunto de datos, en lugar de hacerlo solo para cada columna individualmente.

```
SELECT hll_sketch_estimate(
  hll_union(
    hll_sketch_agg(col1),
    hll_sketch_agg(col2)))
  FROM VALUES
    (1, 4),
    (1, 4),
    (2, 5),
    (2, 5),
    (3, 6) AS tab(col1, col2);
  6
```

La diferencia entre el ejemplo siguiente y el anterior es que el parámetro de precisión (12 bits) no se especifica en la llamada a la `hll_sketch_agg` función. En este caso, se utiliza la precisión predeterminada de 14 bits, lo que puede proporcionar una estimación más precisa del recuento único en comparación con el ejemplo anterior, que utilizaba 12 bits de precisión.

```
SELECT hll_sketch_estimate(
  hll_union(
    hll_sketch_agg(col1, 14),
    hll_sketch_agg(col2, 14)))
  FROM VALUES
    (1, 4),
    (1, 4),
    (2, 5),
    (2, 5),
    (3, 6) AS tab(col1, col2);
```

# Función HLL\$1UNION\$1AGG
<a name="HLL_UNION_AGG"></a>

La función HLL\$1UNION\$1AGG combina varios bocetos HLL en un solo boceto unificado. Utiliza el algoritmo HyperLogLog (HLL) para combinar un grupo de bocetos en uno solo. Las consultas pueden usar los búferes resultantes para calcular recuentos únicos aproximados con la `hll_sketch_estimate` función.

## Sintaxis
<a name="HLL_UNION_AGG-syntax"></a>

```
HLL_UNION_AGG ( expr [, allowDifferentLgConfigK ] )
```

## Argumento
<a name="HLL_UNION_AGG-argument"></a>

 *expr*   
`BINARY`Expresión que contiene un boceto generado por HLL\$1SKETCH\$1AGG.

*allowDifferentLgConfiguración*  
Una expresión BOOLEANA opcional que controla si se permite la fusión de dos bocetos con valores de lgConfigK diferentes. El valor predeterminado es `false`.

## Tipo de retorno
<a name="HLL_UNION_AGG-return-type"></a>

La función HLL\$1UNION\$1AGG devuelve un búfer BINARIO que contiene el HyperLogLog boceto calculado como resultado de la combinación de las expresiones de entrada del mismo grupo. Cuando el `allowDifferentLgConfigK` parámetro es`true`, el boceto resultante utiliza el menor de los dos valores proporcionados. `lgConfigK`

## Ejemplos
<a name="HLL_UNION_AGG-examples"></a>

Los siguientes ejemplos utilizan el algoritmo de boceto HyperLogLog (HLL) para estimar el recuento único de valores en varios bocetos HLL.

El primer ejemplo estima el recuento único de valores de un conjunto de datos.

```
SELECT hll_sketch_estimate(hll_union_agg(sketch, true))
    FROM (SELECT hll_sketch_agg(col) as sketch
            FROM VALUES (1) AS tab(col)
          UNION ALL
          SELECT hll_sketch_agg(col, 20) as sketch
            FROM VALUES (1) AS tab(col));
  1
```

La consulta interna crea dos bocetos HLL:
+ La primera instrucción SELECT crea un boceto a partir de un único valor de 1. 
+ La segunda instrucción SELECT crea un boceto a partir de otro valor único de 1, pero con una precisión de 20. 

La consulta externa utiliza la función HLL\$1UNION\$1AGG para combinar los dos bocetos en un solo boceto. A continuación, aplica la función HLL\$1SKETCH\$1ESTIMATE a este boceto combinado para estimar el recuento único de valores.

El resultado de esta consulta es el recuento único estimado de los valores de la columna, que es. `col` `1` Esto significa que los dos valores de entrada de 1 se consideran únicos, aunque tengan el mismo valor.

El segundo ejemplo incluye un parámetro de precisión diferente para la función HLL\$1UNION\$1AGG. En este caso, ambos bocetos HLL se crean con una precisión de 14 bits, lo que permite combinarlos correctamente con el parámetro. `hll_union_agg` `true`

```
SELECT hll_sketch_estimate(hll_union_agg(sketch, true))
    FROM (SELECT hll_sketch_agg(col, 14) as sketch
            FROM VALUES (1) AS tab(col)
          UNION ALL
          SELECT hll_sketch_agg(col, 14) as sketch
            FROM VALUES (1) AS tab(col));
  1
```

El resultado final de la consulta es el recuento único estimado, que en este caso también `1` lo es. Esto significa que los dos valores de entrada de 1 se consideran únicos, aunque tengan el mismo valor.