thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-11-10 01:25:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

More complete "es" translation (#9791)

Browse Source 
* replace exit with assert in test_single_page

* improve save_raw_single_page docs option

* More grammar fixes

* "Built from" link in new tab

* fix mistype

* Example of include in docs

* add anchor to meeting form

* Draft of translation helper

* WIP on translation helper

* Replace some fa docs content with machine translation

* add normalize-en-markdown.sh

* normalize some en markdown

* normalize some en markdown

* admonition support

* normalize

* normalize

* normalize

* support wide tables

* normalize

* normalize

* normalize

* normalize

* normalize

* normalize

* normalize

* normalize

* normalize

* normalize

* normalize

* normalize

* normalize

* lightly edited machine translation of introdpection.md

* lightly edited machhine translation of lazy.md

* WIP on translation utils

* Normalize ru docs

* Normalize other languages

* some fixes

* WIP on normalize/translate tools

* add requirements.txt

* [experimental] add es docs language as machine translated draft

* remove duplicate script

* Back to wider tab-stop (narrow renders not so well)

* Links to nowhere check at least for English

* use f string

* More complete es translation
This commit is contained in:
Ivan Blinkov 2020-03-21 12:17:06 +03:00 committed by GitHub
parent 6550aa5e6c
commit f315e5079b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
164 changed files with 1692 additions and 3856 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
docs/es/changelog/2017.md
View File

@ -24,13 +24,13 @@ Esta versión contiene correcciones de errores para la versión anterior 1.1.543
- Se agregó soporte para zonas horarias con desplazamientos no enteros de UTC.
- Se agregó soporte para operaciones aritméticas con intervalos de tiempo.
- El intervalo de valores para los tipos Date y DateTime se extiende hasta el año 2105.
- Se agregó el `CREATE MATERIALIZED VIEW x TO y` consulta (especifica una tabla existente para almacenar los datos de una vista materializada).
- Se agregó el `ATTACH TABLE` consulta sin argumentos.
- Se agregó el `CREATE MATERIALIZED VIEW x TO y` Consulta (especifica una tabla existente para almacenar los datos de una vista materializada).
- Se agregó el `ATTACH TABLE` Consulta sin argumentos.
- La lógica de procesamiento para columnas anidadas con nombres que terminan en -Map en una tabla SummingMergeTree se extrajo a la función de agregado sumMap. Ahora puede especificar dichas columnas explícitamente.
- El tamaño máximo del diccionario IP trie se incrementa a 128M entradas.
- Se agregó la función getSizeOfEnumType.
- Se agregó la función agregada sumWithOverflow.
- Se agregó soporte para el formato de entrada Cap’n Proto.
- Se agregó soporte para el formato de entrada Cap'n Proto.
- Ahora puede personalizar el nivel de compresión al usar el algoritmo zstd.
#### Cambios incompatibles hacia atrás: {#backward-incompatible-changes}
@ -58,7 +58,7 @@ Esta versión contiene correcciones de errores para la versión anterior 1.1.543
#### Novedad: {#new-features-1}
- Soporte TLS en el protocolo nativo (para habilitar, establecer `tcp_ssl_port` en `config.xml` ).
- Soporte TLS en el protocolo nativo (para habilitar, establecer `tcp_ssl_port` es `config.xml` ).
#### Corrección de errores: {#bug-fixes-1}
@ -116,11 +116,11 @@ Esta versión contiene correcciones de errores para la versión anterior 1.1.543
- Se ha mejorado el proceso de eliminación de nodos antiguos en ZooKeeper. Anteriormente, los nodos antiguos a veces no se eliminaban si había inserciones muy frecuentes, lo que hacía que el servidor tardara en apagarse, entre otras cosas.
- Se corrigió la aleatorización al elegir hosts para la conexión a ZooKeeper.
- Se corrigió la exclusión de réplicas rezagadas en consultas distribuidas si la réplica es localhost.
- Se corrigió un error por el que una parte de datos en un `ReplicatedMergeTree` la tabla podría estar rota después de correr `ALTER MODIFY` en un elemento en un `Nested` estructura.
- Se corrigió un error por el que una parte de datos en un `ReplicatedMergeTree` la tabla podría estar rota después de correr `ALTER MODIFY` es un elemento en un `Nested` estructura.
- Se corrigió un error que podía causar que las consultas SELECT “hang”.
- Mejoras en las consultas DDL distribuidas.
- Se corrigió la consulta `CREATE TABLE ... AS <materialized view>`.
- Se resolvió el punto muerto en el `ALTER ... CLEAR COLUMN IN PARTITION` consulta para `Buffer` tabla.
- Se resolvió el punto muerto en el `ALTER ... CLEAR COLUMN IN PARTITION` Consulta para `Buffer` tabla.
- Se corrigió el valor predeterminado no válido para `Enum` s (0 en lugar del mínimo) cuando se utiliza el `JSONEachRow` y `TSKV` formato.
- Se resolvió la aparición de procesos zombis al usar un diccionario con un `executable` fuente.
- Se corrigió el segfault para la consulta HEAD.
@ -128,12 +128,12 @@ Esta versión contiene correcciones de errores para la versión anterior 1.1.543
#### Flujo de trabajo mejorado para desarrollar y ensamblar ClickHouse: {#improved-workflow-for-developing-and-assembling-clickhouse}
- Usted puede utilizar `pbuilder` para construir ClickHouse.
- Usted puede utilizar `libc++` en lugar de `libstdc++` para construir en Linux.
- Usted puede utilizar `libc++` es lugar de `libstdc++` para construir en Linux.
- Se agregaron instrucciones para usar herramientas de análisis de código estático: `Coverage`, `clang-tidy`, `cppcheck`.
#### Tenga en cuenta al actualizar: {#please-note-when-upgrading}
- Ahora hay un valor predeterminado más alto para la configuración MergeTree `max_bytes_to_merge_at_max_space_in_pool` (el tamaño total máximo de las partes de datos a fusionar, en bytes): ha aumentado de 100 GiB a 150 GiB. Esto podría dar lugar a grandes fusiones que se ejecutan después de la actualización del servidor, lo que podría provocar una mayor carga en el subsistema de disco. Si el espacio libre disponible en el servidor es inferior al doble de la cantidad total de las fusiones que se están ejecutando, esto hará que todas las demás fusiones dejen de ejecutarse, incluidas las fusiones de pequeñas partes de datos. Como resultado, las consultas INSERT fallarán con el mensaje “Merges are processing significantly slower than inserts.” Utilice el `SELECT * FROM system.merges` consulta para supervisar la situación. También puede comprobar el `DiskSpaceReservedForMerge` métrica en el `system.metrics` mesa, o en Grafito. No necesita hacer nada para solucionar esto, ya que el problema se resolverá una vez que finalicen las fusiones grandes. Si encuentra esto inaceptable, puede restaurar el valor anterior para el `max_bytes_to_merge_at_max_space_in_pool` configuración. Para hacer esto, vaya al <merge_tree> sección en config.xml, establecer ``` <merge_tree>``<max_bytes_to_merge_at_max_space_in_pool>107374182400</max_bytes_to_merge_at_max_space_in_pool> ``` y reinicie el servidor.
- Ahora hay un valor predeterminado más alto para la configuración MergeTree `max_bytes_to_merge_at_max_space_in_pool` (el tamaño total máximo de las partes de datos a fusionar, en bytes): ha aumentado de 100 GiB a 150 GiB. Esto podría dar lugar a grandes fusiones que se ejecutan después de la actualización del servidor, lo que podría provocar una mayor carga en el subsistema de disco. Si el espacio libre disponible en el servidor es inferior al doble de la cantidad total de las fusiones que se están ejecutando, esto hará que todas las demás fusiones dejen de ejecutarse, incluidas las fusiones de pequeñas partes de datos. Como resultado, las consultas INSERT fallarán con el mensaje “Merges are processing significantly slower than inserts.” Descripción `SELECT * FROM system.merges` consulta para supervisar la situación. También puede comprobar el `DiskSpaceReservedForMerge` métrica en el `system.metrics` mesa, o en Grafito. No necesita hacer nada para solucionar esto, ya que el problema se resolverá una vez que finalicen las fusiones grandes. Si encuentra esto inaceptable, puede restaurar el valor anterior para el `max_bytes_to_merge_at_max_space_in_pool` configuración. Para hacer esto, vaya al <merge_tree> sección en config.xml, establecer ``` <merge_tree>``<max_bytes_to_merge_at_max_space_in_pool>107374182400</max_bytes_to_merge_at_max_space_in_pool> ``` y reinicie el servidor.
### Lanzamiento de ClickHouse 1.1.54284, 2017-08-29 {#clickhouse-release-1-1-54284-2017-08-29}
@ -203,7 +203,7 @@ Esta versión contiene correcciones de errores para la versión anterior 1.1.542
- Se corrigió la actualización automática incorrecta de los diccionarios Trie.
- Se ha corregido una excepción al ejecutar consultas con una cláusula GROUP BY desde una tabla Merge cuando se usa SAMPLE.
- Se corrigió un bloqueo de GROUP BY cuando se usabaributed\_aggregation\_memory\_efficient = 1.
- Ahora puede especificar la base de datos.en el lado derecho de IN y JOIN.
- Ahora puede especificar la base de datos.es el lado derecho de IN y JOIN.
- Se usaron demasiados subprocesos para la agregación paralela. Esto ha sido solucionado.
- Corregido cómo el “if” funciona con argumentos FixedString.
- SELECT funcionó incorrectamente desde una tabla distribuida para fragmentos con un peso de 0. Esto ha sido solucionado.

1
docs/es/changelog/2018.md
View File

@ -1 +0,0 @@
../../en/changelog/2018.md

1
docs/es/changelog/2019.md
View File

@ -1 +0,0 @@
../../en/changelog/2019.md

1
docs/es/changelog/index.md
View File

@ -1 +0,0 @@
../../../CHANGELOG.md

26
docs/es/data_types/array.md
View File

@ -1,24 +1,24 @@
# Array(T) {#data-type-array}
# Matriz (T) {#data-type-array}
Array of `T`-type items.
Matriz de `T`-tipo de artículos.
`T` can be anything, including an array.
`T` puede ser cualquier cosa, incluida una matriz.
## Creating an array {#creating-an-array}
## Creación de una matriz {#creating-an-array}
You can use a function to create an array:
Puede usar una función para crear una matriz:
``` sql
array(T)
```
You can also use square brackets.
También puede usar corchetes.
``` sql
[]
```
Example of creating an array:
Ejemplo de creación de una matriz:
``` sql
SELECT array(1, 2) AS x, toTypeName(x)
@ -40,13 +40,13 @@ SELECT [1, 2] AS x, toTypeName(x)
└───────┴────────────────────┘
```
## Working with data types {#working-with-data-types}
## Trabajar con tipos de datos {#working-with-data-types}
When creating an array on the fly, ClickHouse automatically defines the argument type as the narrowest data type that can store all the listed arguments. If there are any [NULL](../query_language/syntax.md#null-literal) or [Nullable](nullable.md#data_type-nullable) type arguments, the type of array elements is [Nullable](nullable.md).
Al crear una matriz sobre la marcha, ClickHouse define automáticamente el tipo de argumento como el tipo de datos más estrecho que puede almacenar todos los argumentos enumerados. Si hay alguna [NULO](../query_language/syntax.md#null-literal) o [NULO](nullable.md#data_type-nullable) los argumentos de tipo, el tipo de elementos de la matriz es [NULO](nullable.md).
If ClickHouse couldn’t determine the data type, it will generate an exception. For instance, this will happen when trying to create an array with strings and numbers simultaneously (`SELECT array(1, 'a')`).
Si ClickHouse no pudo determinar el tipo de datos, generará una excepción. Por ejemplo, esto sucederá al intentar crear una matriz con cadenas y números simultáneamente (`SELECT array(1, 'a')`).
Examples of automatic data type detection:
Ejemplos de detección automática de tipos de datos:
``` sql
SELECT array(1, 2, NULL) AS x, toTypeName(x)
@ -58,7 +58,7 @@ SELECT array(1, 2, NULL) AS x, toTypeName(x)
└────────────┴───────────────────────────────┘
```
If you try to create an array of incompatible data types, ClickHouse throws an exception:
Si intenta crear una matriz de tipos de datos incompatibles, ClickHouse produce una excepción:
``` sql
SELECT array(1, 'a')
@ -69,4 +69,4 @@ Received exception from server (version 1.1.54388):
Code: 386. DB::Exception: Received from localhost:9000, 127.0.0.1. DB::Exception: There is no supertype for types UInt8, String because some of them are String/FixedString and some of them are not.
```
[Original article](https://clickhouse.tech/docs/es/data_types/array/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/array/) <!--hide-->

10
docs/es/data_types/date.md
View File

@ -1,8 +1,8 @@
# Date {#date}
# Fecha {#date}
A date. Stored in two bytes as the number of days since 1970-01-01 (unsigned). Allows storing values from just after the beginning of the Unix Epoch to the upper threshold defined by a constant at the compilation stage (currently, this is until the year 2106, but the final fully-supported year is 2105).
The minimum value is output as 0000-00-00.
Fecha. Almacenado en dos bytes como el número de días desde 1970-01-01 (sin signo). Permite almacenar valores desde justo después del comienzo de la Época Unix hasta el umbral superior definido por una constante en la etapa de compilación (actualmente, esto es hasta el año 2106, pero el último año totalmente soportado es 2105).
El valor mínimo se emite como 0000-00-00.
The date value is stored without the time zone.
El valor de fecha se almacena sin la zona horaria.
[Original article](https://clickhouse.tech/docs/es/data_types/date/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/date/) <!--hide-->

60
docs/es/data_types/datetime.md
View File

@ -1,34 +1,34 @@
# DateTime {#data-type-datetime}
# FechaHora {#data-type-datetime}
Allows to store an instant in time, that can be expressed as a calendar date and a time of a day.
Permite almacenar un instante en el tiempo, que se puede expresar como una fecha del calendario y una hora de un día.
Syntax:
Sintaxis:
``` sql
DateTime([timezone])
```
Supported range of values: \[1970-01-01 00:00:00, 2105-12-31 23:59:59\].
Rango de valores: \[1970-01-01 00:00:00, 2105-12-31 23:59:59\].
Resolution: 1 second.
Resolución: 1 segundo.
## Usage Remarks {#usage-remarks}
## Observaciones de uso {#usage-remarks}
The point in time is saved as a [Unix timestamp](https://en.wikipedia.org/wiki/Unix_time), regardless of the time zone or daylight saving time. Additionally, the `DateTime` type can store time zone that is the same for the entire column, that affects how the values of the `DateTime` type values are displayed in text format and how the values specified as strings are parsed (‘2020-01-01 05:00:01’). The time zone is not stored in the rows of the table (or in resultset), but is stored in the column metadata.
A list of supported time zones can be found in the [IANA Time Zone Database](https://www.iana.org/time-zones).
The `tzdata` package, containing [IANA Time Zone Database](https://www.iana.org/time-zones), should be installed in the system. Use the `timedatectl list-timezones` command to list timezones known by a local system.
El punto en el tiempo se guarda como un [Timestamp de Unix](https://en.wikipedia.org/wiki/Unix_time), independientemente de la zona horaria o el horario de verano. Además, el `DateTime` tipo puede almacenar zona horaria que es la misma para toda la columna, que afecta a cómo los valores de la `DateTime` Los valores de tipo se muestran en formato de texto y cómo se analizan los valores especificados como cadenas (‘2020-01-01 05:00:01’). La zona horaria no se almacena en las filas de la tabla (o en el conjunto de resultados), sino que se almacena en los metadatos de la columna.
Se puede encontrar una lista de zonas horarias compatibles en el [Base de datos de zonas horarias de IANA](https://www.iana.org/time-zones).
El `tzdata` paquete, que contiene [Base de datos de zonas horarias de IANA](https://www.iana.org/time-zones), debe instalarse en el sistema. Descripción `timedatectl list-timezones` comando para listar zonas horarias conocidas por un sistema local.
You can explicitly set a time zone for `DateTime`-type columns when creating a table. If the time zone isn’t set, ClickHouse uses the value of the [timezone](../operations/server_settings/settings.md#server_settings-timezone) parameter in the server settings or the operating system settings at the moment of the ClickHouse server start.
Puede establecer explícitamente una zona horaria para `DateTime`-type columnas al crear una tabla. Si la zona horaria no está establecida, ClickHouse usa el valor [Zona horaria](../operations/server_settings/settings.md#server_settings-timezone) parámetro en la configuración del servidor o la configuración del sistema operativo en el momento del inicio del servidor ClickHouse.
The [clickhouse-client](../interfaces/cli.md) applies the server time zone by default if a time zone isn’t explicitly set when initializing the data type. To use the client time zone, run `clickhouse-client` with the `--use_client_time_zone` parameter.
El [Casa de clics-cliente](../interfaces/cli.md) aplica la zona horaria del servidor de forma predeterminada si una zona horaria no se establece explícitamente al inicializar el tipo de datos. Para utilizar la zona horaria del cliente, ejecute `clickhouse-client` con el `--use_client_time_zone` parámetro.
ClickHouse outputs values in `YYYY-MM-DD hh:mm:ss` text format by default. You can change the output with the [formatDateTime](../query_language/functions/date_time_functions.md#formatdatetime) function.
ClickHouse genera valores en `YYYY-MM-DD hh:mm:ss` formato de texto por defecto. Puede cambiar la salida con el [formatDateTime](../query_language/functions/date_time_functions.md#formatdatetime) función.
When inserting data into ClickHouse, you can use different formats of date and time strings, depending on the value of the [date\_time\_input\_format](../operations/settings/settings.md#settings-date_time_input_format) setting.
Al insertar datos en ClickHouse, puede usar diferentes formatos de cadenas de fecha y hora, dependiendo del valor de la [Date\_time\_input\_format](../operations/settings/settings.md#settings-date_time_input_format) configuración.
## Examples {#examples}
## Ejemplos {#examples}
**1.** Creating a table with a `DateTime`-type column and inserting data into it:
**1.** Creación de una tabla con un `DateTime`-tipo de columna e insertar datos en ella:
``` sql
CREATE TABLE dt
@ -54,10 +54,10 @@ SELECT * FROM dt;
└─────────────────────┴──────────┘
```
- When inserting datetime as an integer, it is treated as Unix Timestamp (UTC). `1546300800` represents `'2019-01-01 00:00:00'` UTC. However, as `timestamp` column has `Europe/Moscow` (UTC+3) timezone specified, when outputting as string the value will be shown as `'2019-01-01 03:00:00'`
- When inserting string value as datetime, it is treated as being in column timezone. `'2019-01-01 00:00:00'` will be treated as being in `Europe/Moscow` timezone and saved as `1546290000`.
- Al insertar datetime como un entero, se trata como Unix Timestamp (UTC). `1546300800` representante `'2019-01-01 00:00:00'` UTC. Sin embargo, como `timestamp` tetas grandes `Europe/Moscow` (UTC + 3) zona horaria especificada, al emitir como cadena, el valor se mostrará como `'2019-01-01 03:00:00'`
- Al insertar el valor de cadena como fecha y hora, se trata como si estuviera en la zona horaria de la columna. `'2019-01-01 00:00:00'` será tratado como estar en `Europe/Moscow` zona horaria y guardado como `1546290000`.
**2.** Filtering on `DateTime` values
**2.** Filtrado en `DateTime` valor
``` sql
SELECT * FROM dt WHERE timestamp = toDateTime('2019-01-01 00:00:00', 'Europe/Moscow')
@ -69,7 +69,7 @@ SELECT * FROM dt WHERE timestamp = toDateTime('2019-01-01 00:00:00', 'Europe/Mos
└─────────────────────┴──────────┘
```
`DateTime` column values can be filtered using a string value in `WHERE` predicate. It will be converted to `DateTime` automatically:
`DateTime` se pueden filtrar usando un valor de cadena en `WHERE` predicado. Se convertirá a `DateTime` automática:
``` sql
SELECT * FROM dt WHERE timestamp = '2019-01-01 00:00:00'
@ -81,7 +81,7 @@ SELECT * FROM dt WHERE timestamp = '2019-01-01 00:00:00'
└─────────────────────┴──────────┘
```
**3.** Getting a time zone for a `DateTime`-type column:
**3.** Obtener una zona horaria para un `DateTime`-tipo columna:
``` sql
SELECT toDateTime(now(), 'Europe/Moscow') AS column, toTypeName(column) AS x
@ -93,7 +93,7 @@ SELECT toDateTime(now(), 'Europe/Moscow') AS column, toTypeName(column) AS x
└─────────────────────┴───────────────────────────┘
```
**4.** Timezone conversion
**4.** Conversión de zona horaria
``` sql
SELECT
@ -109,14 +109,14 @@ FROM dt
└─────────────────────┴─────────────────────┘
```
## See Also {#see-also}
## Ver también {#see-also}
- [Type conversion functions](../query_language/functions/type_conversion_functions.md)
- [Functions for working with dates and times](../query_language/functions/date_time_functions.md)
- [Functions for working with arrays](../query_language/functions/array_functions.md)
- [The `date_time_input_format` setting](../operations/settings/settings.md#settings-date_time_input_format)
- [The `timezone` server configuration parameter](../operations/server_settings/settings.md#server_settings-timezone)
- [Operators for working with dates and times](../query_language/operators.md#operators-datetime)
- [The `Date` data type](date.md)
- [Funciones de conversión de tipos](../query_language/functions/type_conversion_functions.md)
- [Funciones para trabajar con fechas y horas](../query_language/functions/date_time_functions.md)
- [Funciones para trabajar con matrices](../query_language/functions/array_functions.md)
- [El `date_time_input_format` configuración](../operations/settings/settings.md#settings-date_time_input_format)
- [El `timezone` parámetro de configuración del servidor](../operations/server_settings/settings.md#server_settings-timezone)
- [Operadores para trabajar con fechas y horas](../query_language/operators.md#operators-datetime)
- [El `Date` Tipo de datos](date.md)
[Original article](https://clickhouse.tech/docs/es/data_types/datetime/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/datetime/) <!--hide-->

42
docs/es/data_types/datetime64.md
View File

@ -1,20 +1,20 @@
# DateTime64 {#data-type-datetime64}
Allows to store an instant in time, that can be expressed as a calendar date and a time of a day, with defined sub-second precision
Permite almacenar un instante en el tiempo, que se puede expresar como una fecha de calendario y una hora de un día, con una precisión de subsegundo definida
Tick size (precision): 10<sup>-precision</sup> seconds
Tamaño de la marca (precisión): 10<sup>-Precision</sup> segundo
Syntax:
Sintaxis:
``` sql
DateTime64(precision, [timezone])
```
Internally, stores data as a number of ‘ticks’ since epoch start (1970-01-01 00:00:00 UTC) as Int64. The tick resolution is determined by the precision parameter. Additionally, the `DateTime64` type can store time zone that is the same for the entire column, that affects how the values of the `DateTime64` type values are displayed in text format and how the values specified as strings are parsed (‘2020-01-01 05:00:01.000’). The time zone is not stored in the rows of the table (or in resultset), but is stored in the column metadata. See details in [DateTime](datetime.md).
Internamente, almacena datos como un número de ‘ticks’ desde el inicio de la época (1970-01-01 00:00:00 UTC) como Int64. La resolución de tick está determinada por el parámetro precision. Además, el `DateTime64` tipo puede almacenar zona horaria que es la misma para toda la columna, que afecta a cómo los valores de la `DateTime64` Los valores de tipo se muestran en formato de texto y cómo se analizan los valores especificados como cadenas (‘2020-01-01 05:00:01.000’). La zona horaria no se almacena en las filas de la tabla (o en el conjunto de resultados), sino que se almacena en los metadatos de la columna. Ver detalles en [FechaHora](datetime.md).
## Examples {#examples}
## Ejemplos {#examples}
**1.** Creating a table with `DateTime64`-type column and inserting data into it:
**1.** Creación de una tabla con `DateTime64`-tipo de columna e insertar datos en ella:
``` sql
CREATE TABLE dt
@ -40,10 +40,10 @@ SELECT * FROM dt
└─────────────────────────┴──────────┘
```
- When inserting datetime as an integer, it is treated as an appropriately scaled Unix Timestamp (UTC). `1546300800000` (with precision 3) represents `'2019-01-01 00:00:00'` UTC. However, as `timestamp` column has `Europe/Moscow` (UTC+3) timezone specified, when outputting as a string the value will be shown as `'2019-01-01 03:00:00'`
- When inserting string value as datetime, it is treated as being in column timezone. `'2019-01-01 00:00:00'` will be treated as being in `Europe/Moscow` timezone and stored as `1546290000000`.
- Al insertar datetime como un entero, se trata como una marca de tiempo Unix (UTC) apropiadamente escalada. `1546300800000` (con precisión 3) representa `'2019-01-01 00:00:00'` UTC. Sin embargo, como `timestamp` tetas grandes `Europe/Moscow` (UTC + 3) zona horaria especificada, al emitir como una cadena, el valor se mostrará como `'2019-01-01 03:00:00'`
- Al insertar el valor de cadena como fecha y hora, se trata como si estuviera en la zona horaria de la columna. `'2019-01-01 00:00:00'` será tratado como estar en `Europe/Moscow` Zona horaria y se almacena como `1546290000000`.
**2.** Filtering on `DateTime64` values
**2.** Filtrado en `DateTime64` valor
``` sql
SELECT * FROM dt WHERE timestamp = toDateTime64('2019-01-01 00:00:00', 3, 'Europe/Moscow')
@ -55,9 +55,9 @@ SELECT * FROM dt WHERE timestamp = toDateTime64('2019-01-01 00:00:00', 3, 'Europ
└─────────────────────────┴──────────┘
```
Unlike `DateTime`, `DateTime64` values are not converted from `String` automatically
A diferencia de `DateTime`, `DateTime64` los valores no se convierten desde `String` automática
**3.** Getting a time zone for a `DateTime64`-type value:
**3.** Obtener una zona horaria para un `DateTime64`-tipo de valor:
``` sql
SELECT toDateTime64(now(), 3, 'Europe/Moscow') AS column, toTypeName(column) AS x
@ -69,7 +69,7 @@ SELECT toDateTime64(now(), 3, 'Europe/Moscow') AS column, toTypeName(column) AS
└─────────────────────────┴────────────────────────────────┘
```
**4.** Timezone conversion
**4.** Conversión de zona horaria
``` sql
SELECT
@ -85,13 +85,13 @@ FROM dt
└─────────────────────────┴─────────────────────────┘
```
## See Also {#see-also}
## Ver también {#see-also}
- [Type conversion functions](../query_language/functions/type_conversion_functions.md)
- [Functions for working with dates and times](../query_language/functions/date_time_functions.md)
- [Functions for working with arrays](../query_language/functions/array_functions.md)
- [The `date_time_input_format` setting](../operations/settings/settings.md#settings-date_time_input_format)
- [The `timezone` server configuration parameter](../operations/server_settings/settings.md#server_settings-timezone)
- [Operators for working with dates and times](../query_language/operators.md#operators-datetime)
- [`Date` data type](date.md)
- [`DateTime` data type](datetime.md)
- [Funciones de conversión de tipos](../query_language/functions/type_conversion_functions.md)
- [Funciones para trabajar con fechas y horas](../query_language/functions/date_time_functions.md)
- [Funciones para trabajar con matrices](../query_language/functions/array_functions.md)
- [El `date_time_input_format` configuración](../operations/settings/settings.md#settings-date_time_input_format)
- [El `timezone` parámetro de configuración del servidor](../operations/server_settings/settings.md#server_settings-timezone)
- [Operadores para trabajar con fechas y horas](../query_language/operators.md#operators-datetime)
- [`Date` Tipo de datos](date.md)
- [`DateTime` Tipo de datos](datetime.md)

2
docs/es/data_types/decimal.md
View File

@ -36,7 +36,7 @@ Las operaciones binarias en Decimal dan como resultado un tipo de resultado más
Reglas para la escala:
- Sumar, restar: S = max(S1, S2).
- Sumar, restar: S = max (S1, S2).
- multuply: S = S1 + S2.
- división: S = S1.

18
docs/es/data_types/domains/ipv4.md
View File

@ -1,8 +1,8 @@
## IPv4 {#ipv4}
`IPv4` is a domain based on `UInt32` type and serves as typed replacement for storing IPv4 values. It provides compact storage with human-friendly input-output format, and column type information on inspection.
`IPv4` es un dominio basado en `UInt32` tipo y sirve como reemplazo tipo para almacenar valores IPv4. Proporciona un almacenamiento compacto con un formato de entrada-salida amigable para los humanos e información de tipo de columna sobre la inspección.
### Basic Usage {#basic-usage}
### Uso básico {#basic-usage}
``` sql
CREATE TABLE hits (url String, from IPv4) ENGINE = MergeTree() ORDER BY url;
@ -17,13 +17,13 @@ DESCRIBE TABLE hits;
└──────┴────────┴──────────────┴────────────────────┴─────────┴──────────────────┘
```
OR you can use IPv4 domain as a key:
O puede usar el dominio IPv4 como clave:
``` sql
CREATE TABLE hits (url String, from IPv4) ENGINE = MergeTree() ORDER BY from;
```
`IPv4` domain supports custom input format as IPv4-strings:
`IPv4` Todos los derechos reservados:
``` sql
INSERT INTO hits (url, from) VALUES ('https://wikipedia.org', '116.253.40.133')('https://clickhouse.tech', '183.247.232.58')('https://clickhouse.yandex/docs/es/', '116.106.34.242');
@ -39,7 +39,7 @@ SELECT * FROM hits;
└────────────────────────────────────┴────────────────┘
```
Values are stored in compact binary form:
Los valores se almacenan en forma binaria compacta:
``` sql
SELECT toTypeName(from), hex(from) FROM hits LIMIT 1;
@ -51,8 +51,8 @@ SELECT toTypeName(from), hex(from) FROM hits LIMIT 1;
└──────────────────┴───────────┘
```
Domain values are not implicitly convertible to types other than `UInt32`.
If you want to convert `IPv4` value to a string, you have to do that explicitly with `IPv4NumToString()` function:
Los valores de dominio no se pueden convertir implícitamente en tipos distintos de `UInt32`.
Si desea convertir `IPv4` valor a una cadena, tienes que hacer eso explícitamente con `IPv4NumToString()` función:
``` sql
SELECT toTypeName(s), IPv4NumToString(from) as s FROM hits LIMIT 1;
@ -62,7 +62,7 @@ SELECT toTypeName(s), IPv4NumToString(from) as s FROM hits LIMIT 1;
│ String │ 183.247.232.58 │
└───────────────────────────────────┴────────────────┘
Or cast to a `UInt32` value:
O echar una ONU `UInt32` valor:
``` sql
SELECT toTypeName(i), CAST(from as UInt32) as i FROM hits LIMIT 1;
@ -74,4 +74,4 @@ SELECT toTypeName(i), CAST(from as UInt32) as i FROM hits LIMIT 1;
└──────────────────────────────────┴────────────┘
```
[Original article](https://clickhouse.tech/docs/es/data_types/domains/ipv4) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/domains/ipv4) <!--hide-->

18
docs/es/data_types/domains/ipv6.md
View File

@ -1,8 +1,8 @@
## IPv6 {#ipv6}
`IPv6` is a domain based on `FixedString(16)` type and serves as typed replacement for storing IPv6 values. It provides compact storage with human-friendly input-output format, and column type information on inspection.
`IPv6` es un dominio basado en `FixedString(16)` tipo y sirve como reemplazo tipo para almacenar valores IPv6. Proporciona un almacenamiento compacto con un formato de entrada-salida amigable para los humanos e información de tipo de columna sobre la inspección.
### Basic Usage {#basic-usage}
### Uso básico {#basic-usage}
``` sql
CREATE TABLE hits (url String, from IPv6) ENGINE = MergeTree() ORDER BY url;
@ -17,13 +17,13 @@ DESCRIBE TABLE hits;
└──────┴────────┴──────────────┴────────────────────┴─────────┴──────────────────┘
```
OR you can use `IPv6` domain as a key:
O puedes usar `IPv6` dominio como clave:
``` sql
CREATE TABLE hits (url String, from IPv6) ENGINE = MergeTree() ORDER BY from;
```
`IPv6` domain supports custom input as IPv6-strings:
`IPv6` dominio admite entradas personalizadas como cadenas IPv6:
``` sql
INSERT INTO hits (url, from) VALUES ('https://wikipedia.org', '2a02:aa08:e000:3100::2')('https://clickhouse.tech', '2001:44c8:129:2632:33:0:252:2')('https://clickhouse.yandex/docs/es/', '2a02:e980:1e::1');
@ -39,7 +39,7 @@ SELECT * FROM hits;
└────────────────────────────────────┴───────────────────────────────┘
```
Values are stored in compact binary form:
Los valores se almacenan en forma binaria compacta:
``` sql
SELECT toTypeName(from), hex(from) FROM hits LIMIT 1;
@ -51,8 +51,8 @@ SELECT toTypeName(from), hex(from) FROM hits LIMIT 1;
└──────────────────┴──────────────────────────────────┘
```
Domain values are not implicitly convertible to types other than `FixedString(16)`.
If you want to convert `IPv6` value to a string, you have to do that explicitly with `IPv6NumToString()` function:
Los valores de dominio no se pueden convertir implícitamente en tipos distintos de `FixedString(16)`.
Si desea convertir `IPv6` valor a una cadena, tienes que hacer eso explícitamente con `IPv6NumToString()` función:
``` sql
SELECT toTypeName(s), IPv6NumToString(from) as s FROM hits LIMIT 1;
@ -64,7 +64,7 @@ SELECT toTypeName(s), IPv6NumToString(from) as s FROM hits LIMIT 1;
└───────────────────────────────────┴───────────────────────────────┘
```
Or cast to a `FixedString(16)` value:
O echar una ONU `FixedString(16)` valor:
``` sql
SELECT toTypeName(i), CAST(from as FixedString(16)) as i FROM hits LIMIT 1;
@ -76,4 +76,4 @@ SELECT toTypeName(i), CAST(from as FixedString(16)) as i FROM hits LIMIT 1;
└───────────────────────────────────────────┴─────────┘
```
[Original article](https://clickhouse.tech/docs/es/data_types/domains/ipv6) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/domains/ipv6) <!--hide-->

36
docs/es/data_types/domains/overview.md
View File

@ -1,26 +1,26 @@
# Domains {#domains}
# Dominio {#domains}
Domains are special-purpose types, that add some extra features atop of existing base type, leaving on-wire and on-disc format of underlying table intact. At the moment, ClickHouse does not support user-defined domains.
Los dominios son tipos de propósito especial, que agregan algunas características adicionales encima del tipo base existente, dejando intacto el formato en cable y en disco de la tabla subyacente. Por el momento, ClickHouse no admite dominios definidos por el usuario.
You can use domains anywhere corresponding base type can be used:
Puede usar dominios en cualquier lugar que se pueda usar el tipo base correspondiente:
- Create a column of domain type
- Read/write values from/to domain column
- Use it as index if base type can be used as index
- Call functions with values of domain column
- etc.
- Crear una columna de tipo de dominio
- Leer/escribir valores desde/a la columna de dominio
- Úselo como índice si el tipo base se puede usar como índice
- Funciones de llamada con valores de la columna de dominio
- sucesivamente.
### Extra Features of Domains {#extra-features-of-domains}
### Características adicionales de los dominios {#extra-features-of-domains}
- Explicit column type name in `SHOW CREATE TABLE` or `DESCRIBE TABLE`
- Input from human-friendly format with `INSERT INTO domain_table(domain_column) VALUES(...)`
- Output to human-friendly format for `SELECT domain_column FROM domain_table`
- Loading data from external source in human-friendly format: `INSERT INTO domain_table FORMAT CSV ...`
- Nombre de tipo de columna explícito en `SHOW CREATE TABLE` o `DESCRIBE TABLE`
- Entrada del formato humano-amistoso con `INSERT INTO domain_table(domain_column) VALUES(...)`
- Salida al formato humano-amistoso para `SELECT domain_column FROM domain_table`
- Carga de datos desde una fuente externa en un formato amigable para los humanos: `INSERT INTO domain_table FORMAT CSV ...`
### Limitations {#limitations}
### Limitación {#limitations}
- Can’t convert index column of base type to domain type via `ALTER TABLE`.
- Can’t implicitly convert string values into domain values when inserting data from another column or table.
- Domain adds no constrains on stored values.
- No se puede convertir la columna de índice del tipo base al tipo de dominio a través de `ALTER TABLE`.
- No se pueden convertir implícitamente valores de cadena en valores de dominio al insertar datos de otra columna o tabla.
- Domain no agrega restricciones en los valores almacenados.
[Original article](https://clickhouse.tech/docs/es/data_types/domains/overview) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/domains/overview) <!--hide-->

56
docs/es/data_types/enum.md
View File

@ -1,19 +1,19 @@
# Enum {#enum}
Enumerated type consisting of named values.
Tipo enumerado que consta de valores con nombre.
Named values must be declared as `'string' = integer` pairs. ClickHouse stores only numbers, but supports operations with the values through their names.
Los valores con nombre deben declararse como `'string' = integer` par. ClickHouse almacena solo números, pero admite operaciones con los valores a través de sus nombres.
ClickHouse supports:
Soporta ClickHouse:
- 8-bit `Enum`. It can contain up to 256 values enumerated in the `[-128, 127]` range.
- 16-bit `Enum`. It can contain up to 65536 values enumerated in the `[-32768, 32767]` range.
- de 8 bits `Enum`. Puede contener hasta 256 valores enumerados en el `[-128, 127]` gama.
- de 16 bits `Enum`. Puede contener hasta 65536 valores enumerados en el `[-32768, 32767]` gama.
ClickHouse automatically chooses the type of `Enum` when data is inserted. You can also use `Enum8` or `Enum16` types to be sure in the size of storage.
ClickHouse elige automáticamente el tipo de `Enum` cuando se insertan datos. También puede utilizar `Enum8` o `Enum16` para estar seguro en el tamaño de almacenamiento.
## Usage examples {#usage-examples}
## Ejemplos de uso {#usage-examples}
Here we create a table with an `Enum8('hello' = 1, 'world' = 2)` type column:
Aquí creamos una tabla con un `Enum8('hello' = 1, 'world' = 2)` tipo columna:
``` sql
CREATE TABLE t_enum
@ -23,7 +23,7 @@ CREATE TABLE t_enum
ENGINE = TinyLog
```
Column `x` can only store values that are listed in the type definition: `'hello'` or `'world'`. If you try to save any other value, ClickHouse will raise an exception. 8-bit size for this `Enum` is chosen automatically.
Columna `x` sólo puede almacenar valores que se enumeran en la definición de tipo: `'hello'` o `'world'`. Si intenta guardar cualquier otro valor, ClickHouse generará una excepción. Tamaño de 8 bits para esto `Enum` se elige automáticamente.
``` sql
INSERT INTO t_enum VALUES ('hello'), ('world'), ('hello')
@ -42,7 +42,7 @@ Exception on client:
Code: 49. DB::Exception: Unknown element 'a' for type Enum('hello' = 1, 'world' = 2)
```
When you query data from the table, ClickHouse outputs the string values from `Enum`.
Al consultar datos de la tabla, ClickHouse genera los valores de cadena de `Enum`.
``` sql
SELECT * FROM t_enum
@ -56,7 +56,7 @@ SELECT * FROM t_enum
└───────┘
```
If you need to see the numeric equivalents of the rows, you must cast the `Enum` value to integer type.
Si necesita ver los equivalentes numéricos de las filas, debe `Enum` valor a tipo entero.
``` sql
SELECT CAST(x, 'Int8') FROM t_enum
@ -70,7 +70,7 @@ SELECT CAST(x, 'Int8') FROM t_enum
└─────────────────┘
```
To create an Enum value in a query, you also need to use `CAST`.
Para crear un valor Enum en una consulta, también debe usar `CAST`.
``` sql
SELECT toTypeName(CAST('a', 'Enum(\'a\' = 1, \'b\' = 2)'))
@ -82,13 +82,13 @@ SELECT toTypeName(CAST('a', 'Enum(\'a\' = 1, \'b\' = 2)'))
└─────────────────────────────────────────────────────┘
```
## General rules and usage {#general-rules-and-usage}
## Reglas generales y uso {#general-rules-and-usage}
Each of the values is assigned a number in the range `-128 ... 127` for `Enum8` or in the range `-32768 ... 32767` for `Enum16`. All the strings and numbers must be different. An empty string is allowed. If this type is specified (in a table definition), numbers can be in an arbitrary order. However, the order does not matter.
A cada uno de los valores se le asigna un número en el rango `-128 ... 127` para `Enum8` o en el rango `-32768 ... 32767` para `Enum16`. Todas las cadenas y números deben ser diferentes. Se permite una cadena vacía. Si se especifica este tipo (en una definición de tabla), los números pueden estar en un orden arbitrario. Sin embargo, el orden no importa.
Neither the string nor the numeric value in an `Enum` can be [NULL](../query_language/syntax.md).
Ni la cadena ni el valor numérico en un `Enum` puede ser [NULO](../query_language/syntax.md).
An `Enum` can be contained in [Nullable](nullable.md) type. So if you create a table using the query
Un `Enum` puede estar contenido en [NULL](nullable.md) tipo. Entonces, si crea una tabla usando la consulta
``` sql
CREATE TABLE t_enum_nullable
@ -98,28 +98,28 @@ CREATE TABLE t_enum_nullable
ENGINE = TinyLog
```
it can store not only `'hello'` and `'world'`, but `NULL`, as well.
puede almacenar no sólo `'hello'` y `'world'`, pero `NULL`, también.
``` sql
INSERT INTO t_enum_nullable Values('hello'),('world'),(NULL)
```
In RAM, an `Enum` column is stored in the same way as `Int8` or `Int16` of the corresponding numerical values.
En RAM, un `Enum` columna se almacena de la misma manera que `Int8` o `Int16` de los valores numéricos correspondientes.
When reading in text form, ClickHouse parses the value as a string and searches for the corresponding string from the set of Enum values. If it is not found, an exception is thrown. When reading in text format, the string is read and the corresponding numeric value is looked up. An exception will be thrown if it is not found.
When writing in text form, it writes the value as the corresponding string. If column data contains garbage (numbers that are not from the valid set), an exception is thrown. When reading and writing in binary form, it works the same way as for Int8 and Int16 data types.
The implicit default value is the value with the lowest number.
Al leer en forma de texto, ClickHouse analiza el valor como una cadena y busca la cadena correspondiente del conjunto de valores Enum. Si no se encuentra, se lanza una excepción. Al leer en formato de texto, se lee la cadena y se busca el valor numérico correspondiente. Se lanzará una excepción si no se encuentra.
Al escribir en forma de texto, escribe el valor como la cadena correspondiente. Si los datos de columna contienen elementos no utilizados (números que no son del conjunto válido), se produce una excepción. Al leer y escribir en forma binaria, funciona de la misma manera que para los tipos de datos Int8 e Int16.
El valor predeterminado es el valor con el número más bajo.
During `ORDER BY`, `GROUP BY`, `IN`, `DISTINCT` and so on, Enums behave the same way as the corresponding numbers. For example, ORDER BY sorts them numerically. Equality and comparison operators work the same way on Enums as they do on the underlying numeric values.
Durante `ORDER BY`, `GROUP BY`, `IN`, `DISTINCT` y así sucesivamente, las enumeraciones se comportan de la misma manera que los números correspondientes. Por ejemplo, ORDER BY los ordena numéricamente. Los operadores de igualdad y comparación funcionan de la misma manera en enumeraciones que en los valores numéricos subyacentes.
Enum values cannot be compared with numbers. Enums can be compared to a constant string. If the string compared to is not a valid value for the Enum, an exception will be thrown. The IN operator is supported with the Enum on the left-hand side and a set of strings on the right-hand side. The strings are the values of the corresponding Enum.
Los valores de Enum no se pueden comparar con los números. Las enumeraciones se pueden comparar con una cadena constante. Si la cadena en comparación con no es un valor válido para el Enum, se lanzará una excepción. El operador IN es compatible con el Enum en el lado izquierdo y un conjunto de cadenas en el lado derecho. Las cadenas son los valores del Enum correspondiente.
Most numeric and string operations are not defined for Enum values, e.g. adding a number to an Enum or concatenating a string to an Enum.
However, the Enum has a natural `toString` function that returns its string value.
Sin embargo, el Enum tiene un `toString` función que devuelve su valor de cadena.
Enum values are also convertible to numeric types using the `toT` function, where T is a numeric type. When T corresponds to the enum’s underlying numeric type, this conversion is zero-cost.
The Enum type can be changed without cost using ALTER, if only the set of values is changed. It is possible to both add and remove members of the Enum using ALTER (removing is safe only if the removed value has never been used in the table). As a safeguard, changing the numeric value of a previously defined Enum member will throw an exception.
Los valores de Enum también se pueden convertir a tipos numéricos utilizando el `toT` función, donde T es un tipo numérico. Cuando T corresponde al tipo numérico subyacente de la enumeración, esta conversión es de costo cero.
El tipo Enum se puede cambiar sin costo usando ALTER, si solo se cambia el conjunto de valores. Es posible agregar y eliminar miembros del Enum usando ALTER (eliminar es seguro solo si el valor eliminado nunca se ha usado en la tabla). Como salvaguardia, al cambiar el valor numérico de un miembro Enum definido previamente se producirá una excepción.
Using ALTER, it is possible to change an Enum8 to an Enum16 or vice versa, just like changing an Int8 to Int16.
Usando ALTER, es posible cambiar un Enum8 a un Enum16 o viceversa, al igual que cambiar un Int8 a Int16.
[Original article](https://clickhouse.tech/docs/es/data_types/enum/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/enum/) <!--hide-->

36
docs/es/data_types/fixedstring.md
View File

@ -1,34 +1,34 @@
# FixedString {#fixedstring}
# Cadena fija {#fixedstring}
A fixed-length string of `N` bytes (neither characters nor code points).
Una cadena de longitud fija de `N` bytes (ni caracteres ni puntos de código).
To declare a column of `FixedString` type, use the following syntax:
Para declarar una columna de `FixedString` tipo, utilice la siguiente sintaxis:
``` sql
<column_name> FixedString(N)
```
Where `N` is a natural number.
Donde `N` es un número natural.
The `FixedString` type is efficient when data has the length of precisely `N` bytes. In all other cases, it is likely to reduce efficiency.
El `FixedString` tipo es eficiente cuando los datos tienen la longitud de `N` byte. En todos los demás casos, es probable que reduzca la eficiencia.
Examples of the values that can be efficiently stored in `FixedString`-typed columns:
Ejemplos de los valores que se pueden almacenar eficientemente en `FixedString`Escrito columnas:
- The binary representation of IP addresses (`FixedString(16)` for IPv6).
- La representación binaria de direcciones IP (`FixedString(16)` para IPv6).
- Language codes (ru\_RU, en\_US … ).
- Currency codes (USD, RUB … ).
- Binary representation of hashes (`FixedString(16)` for MD5, `FixedString(32)` for SHA256).
- Representación binaria de hashes (`FixedString(16)` para MD5, `FixedString(32)` para SHA256).
To store UUID values, use the [UUID](uuid.md) data type.
Para almacenar valores UUID, utilice el [UUID](uuid.md) tipo de datos.
When inserting the data, ClickHouse:
Al insertar los datos, ClickHouse:
- Complements a string with null bytes if the string contains fewer than `N` bytes.
- Throws the `Too large value for FixedString(N)` exception if the string contains more than `N` bytes.
- Complementa una cadena con bytes nulos si la cadena contiene menos de `N` byte.
- Lanza el `Too large value for FixedString(N)` excepción si la cadena contiene más de `N` byte.
When selecting the data, ClickHouse does not remove the null bytes at the end of the string. If you use the `WHERE` clause, you should add null bytes manually to match the `FixedString` value. The following example illustrates how to use the `WHERE` clause with `FixedString`.
Al seleccionar los datos, ClickHouse no elimina los bytes nulos al final de la cadena. Si utiliza el `WHERE` cláusula, debe agregar bytes nulos manualmente para que coincida con el `FixedString` valor. En el ejemplo siguiente se muestra cómo utilizar el `WHERE` cláusula con `FixedString`.
Let’s consider the following table with the single `FixedString(2)` column:
Consideremos la siguiente tabla con el único `FixedString(2)` columna:
``` text
┌─name──┐
@ -36,7 +36,7 @@ Let’s consider the following table with the single `FixedString(2)` column:
└───────┘
```
The query `SELECT * FROM FixedStringTable WHERE a = 'b'` does not return any data as a result. We should complement the filter pattern with null bytes.
Consulta `SELECT * FROM FixedStringTable WHERE a = 'b'` no devuelve ningún dato como resultado. Debemos complementar el patrón de filtro con bytes nulos.
``` sql
SELECT * FROM FixedStringTable
@ -49,8 +49,8 @@ WHERE a = 'b\0'
└───┘
```
This behaviour differs from MySQL for the `CHAR` type (where strings are padded with spaces, and the spaces are removed for output).
Este comportamiento difiere de MySQL para el `CHAR` tipo (donde las cadenas se rellenan con espacios y los espacios se eliminan para la salida).
Note that the length of the `FixedString(N)` value is constant. The [length](../query_language/functions/array_functions.md#array_functions-length) function returns `N` even if the `FixedString(N)` value is filled only with null bytes, but the [empty](../query_language/functions/string_functions.md#empty) function returns `1` in this case.
Tenga en cuenta que la longitud del `FixedString(N)` el valor es constante. El [longitud](../query_language/functions/array_functions.md#array_functions-length) función devuelve `N` incluso si el `FixedString(N)` sólo se rellena con bytes nulos, pero el valor [Vaciar](../query_language/functions/string_functions.md#empty) función devuelve `1` en este caso.
[Original article](https://clickhouse.tech/docs/es/data_types/fixedstring/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/fixedstring/) <!--hide-->

8
docs/es/data_types/int_uint.md
View File

@ -1,19 +1,19 @@
# UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64 {#uint8-uint16-uint32-uint64-int8-int16-int32-int64}
Fixed-length integers, with or without a sign.
Enteros de longitud fija, con o sin signo.
## Int Ranges {#int-ranges}
## Rangos Int {#int-ranges}
- Int8 - \[-128 : 127\]
- Int16 - \[-32768 : 32767\]
- Int32 - \[-2147483648 : 2147483647\]
- Int64 - \[-9223372036854775808 : 9223372036854775807\]
## Uint Ranges {#uint-ranges}
## Rangos de Uint {#uint-ranges}
- UInt8 - \[0 : 255\]
- UInt16 - \[0 : 65535\]
- UInt32 - \[0 : 4294967295\]
- UInt64 - \[0 : 18446744073709551615\]
[Original article](https://clickhouse.tech/docs/es/data_types/int_uint/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/int_uint/) <!--hide-->

38
docs/es/data_types/nested_data_structures/aggregatefunction.md
View File

@ -1,18 +1,18 @@
# AggregateFunction(name, types\_of\_arguments…) {#data-type-aggregatefunction}
The intermediate state of an aggregate function. To get it, use aggregate functions with the `-State` suffix. To get aggregated data in the future, you must use the same aggregate functions with the `-Merge`suffix.
El estado intermedio de una función agregada. Para obtenerlo, use funciones agregadas con el `-State` sufijo. Para obtener datos agregados en el futuro, debe utilizar las mismas funciones agregadas con el `-Merge`sufijo.
`AggregateFunction` — parametric data type.
**Parameters**
**Parámetros**
- Name of the aggregate function.
- Nombre de la función de agregado.
If the function is parametric specify its parameters too.
- Types of the aggregate function arguments.
- Tipos de los argumentos de la función agregada.
**Example**
**Ejemplo**
``` sql
CREATE TABLE t
@ -23,32 +23,32 @@ CREATE TABLE t
) ENGINE = ...
```
[uniq](../../query_language/agg_functions/reference.md#agg_function-uniq), anyIf ([any](../../query_language/agg_functions/reference.md#agg_function-any)+[If](../../query_language/agg_functions/combinators.md#agg-functions-combinator-if)) and [quantiles](../../query_language/agg_functions/reference.md) are the aggregate functions supported in ClickHouse.
[uniq](../../query_language/agg_functions/reference.md#agg_function-uniq), anyIf ([cualquier](../../query_language/agg_functions/reference.md#agg_function-any)+[Si](../../query_language/agg_functions/combinators.md#agg-functions-combinator-if)) y [cantiles](../../query_language/agg_functions/reference.md) son las funciones agregadas admitidas en ClickHouse.
## Usage {#usage}
## Uso {#usage}
### Data Insertion {#data-insertion}
### Inserción de datos {#data-insertion}
To insert data, use `INSERT SELECT` with aggregate `-State`- functions.
Para insertar datos, utilice `INSERT SELECT` con agregado `-State`- función.
**Function examples**
**Ejemplos de funciones**
``` sql
uniqState(UserID)
quantilesState(0.5, 0.9)(SendTiming)
```
In contrast to the corresponding functions `uniq` and `quantiles`, `-State`- functions return the state, instead of the final value. In other words, they return a value of `AggregateFunction` type.
En contraste con las funciones correspondientes `uniq` y `quantiles`, `-State`- funciones devuelven el estado, en lugar del valor final. En otras palabras, devuelven un valor de `AggregateFunction` tipo.
In the results of `SELECT` query, the values of `AggregateFunction` type have implementation-specific binary representation for all of the ClickHouse output formats. If dump data into, for example, `TabSeparated` format with `SELECT` query then this dump can be loaded back using `INSERT` query.
En los resultados de `SELECT` consulta, los valores de `AggregateFunction` tipo tiene representación binaria específica de la implementación para todos los formatos de salida de ClickHouse. Si volcar datos en, por ejemplo, `TabSeparated` Formato con `SELECT` Consulta entonces este volcado se puede cargar de nuevo usando `INSERT` consulta.
### Data Selection {#data-selection}
### Selección de datos {#data-selection}
When selecting data from `AggregatingMergeTree` table, use `GROUP BY` clause and the same aggregate functions as when inserting data, but using `-Merge`suffix.
Al seleccionar datos de `AggregatingMergeTree` mesa, uso `GROUP BY` cláusula y las mismas funciones agregadas que al insertar datos, pero usando `-Merge`sufijo.
An aggregate function with `-Merge` suffix takes a set of states, combines them, and returns the result of complete data aggregation.
Una función agregada con `-Merge` sufijo toma un conjunto de estados, los combina y devuelve el resultado de la agregación de datos completa.
For example, the following two queries return the same result:
Por ejemplo, las siguientes dos consultas devuelven el mismo resultado:
``` sql
SELECT uniq(UserID) FROM table
@ -56,8 +56,8 @@ SELECT uniq(UserID) FROM table
SELECT uniqMerge(state) FROM (SELECT uniqState(UserID) AS state FROM table GROUP BY RegionID)
```
## Usage Example {#usage-example}
## Ejemplo de uso {#usage-example}
See [AggregatingMergeTree](../../operations/table_engines/aggregatingmergetree.md) engine description.
Ver [AgregaciónMergeTree](../../operations/table_engines/aggregatingmergetree.md) Descripción del motor.
[Original article](https://clickhouse.tech/docs/es/data_types/nested_data_structures/aggregatefunction/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/nested_data_structures/aggregatefunction/) <!--hide-->

4
docs/es/data_types/nested_data_structures/index.md
View File

@ -1,3 +1,3 @@
# Nested Data Structures {#nested-data-structures}
# Estructuras de datos anidados {#nested-data-structures}
[Original article](https://clickhouse.tech/docs/es/data_types/nested_data_structures/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/nested_data_structures/) <!--hide-->

24
docs/es/data_types/nested_data_structures/nested.md
View File

@ -2,7 +2,7 @@
A nested data structure is like a nested table. The parameters of a nested data structure – the column names and types – are specified the same way as in a CREATE query. Each table row can correspond to any number of rows in a nested data structure.
Example:
Ejemplo:
``` sql
CREATE TABLE test.visits
@ -27,13 +27,13 @@ CREATE TABLE test.visits
) ENGINE = CollapsingMergeTree(StartDate, intHash32(UserID), (CounterID, StartDate, intHash32(UserID), VisitID), 8192, Sign)
```
This example declares the `Goals` nested data structure, which contains data about conversions (goals reached). Each row in the ‘visits’ table can correspond to zero or any number of conversions.
Este ejemplo declara la `Goals` estructura de datos anidada, que contiene datos sobre conversiones (objetivos alcanzados). Cada fila en el ‘visits’ la tabla puede corresponder a cero o cualquier número de conversiones.
Only a single nesting level is supported. Columns of nested structures containing arrays are equivalent to multidimensional arrays, so they have limited support (there is no support for storing these columns in tables with the MergeTree engine).
Solo se admite un único nivel de anidamiento. Las columnas de estructuras anidadas que contienen matrices son equivalentes a matrices multidimensionales, por lo que tienen un soporte limitado (no hay soporte para almacenar estas columnas en tablas con el motor MergeTree).
In most cases, when working with a nested data structure, its individual columns are specified. To do this, the column names are separated by a dot. These columns make up an array of matching types. All the column arrays of a single nested data structure have the same length.
En la mayoría de los casos, cuando se trabaja con una estructura de datos anidada, se especifican sus columnas individuales. Para hacer esto, los nombres de columna están separados por un punto. Estas columnas forman una matriz de tipos coincidentes. Todas las matrices de columnas de una sola estructura de datos anidados tienen la misma longitud.
Example:
Ejemplo:
``` sql
SELECT
@ -59,9 +59,9 @@ LIMIT 10
└────────────────────────────────┴───────────────────────────────────────────────────────────────────────────────────────────┘
```
It is easiest to think of a nested data structure as a set of multiple column arrays of the same length.
Es más fácil pensar en una estructura de datos anidados como un conjunto de múltiples matrices de columnas de la misma longitud.
The only place where a SELECT query can specify the name of an entire nested data structure instead of individual columns is the ARRAY JOIN clause. For more information, see “ARRAY JOIN clause”. Example:
El único lugar donde una consulta SELECT puede especificar el nombre de una estructura de datos anidada completa en lugar de columnas individuales es la cláusula ARRAY JOIN. Para obtener más información, consulte “ARRAY JOIN clause”. Ejemplo:
``` sql
SELECT
@ -88,12 +88,12 @@ LIMIT 10
└─────────┴─────────────────────┘
```
You can’t perform SELECT for an entire nested data structure. You can only explicitly list individual columns that are part of it.
No puede realizar SELECT para toda una estructura de datos anidados. Solo puede enumerar explícitamente columnas individuales que forman parte de él.
For an INSERT query, you should pass all the component column arrays of a nested data structure separately (as if they were individual column arrays). During insertion, the system checks that they have the same length.
Para una consulta INSERT, debe pasar todas las matrices de columnas de componentes de una estructura de datos anidada por separado (como si fueran matrices de columnas individuales). Durante la inserción, el sistema comprueba que tienen la misma longitud.
For a DESCRIBE query, the columns in a nested data structure are listed separately in the same way.
Para una consulta DESCRIBE, las columnas de una estructura de datos anidada se enumeran por separado de la misma manera.
The ALTER query is very limited for elements in a nested data structure.
La consulta ALTER es muy limitada para los elementos de una estructura de datos anidada.
[Original article](https://clickhouse.tech/docs/es/data_types/nested_data_structures/nested/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/nested_data_structures/nested/) <!--hide-->

22
docs/es/data_types/nullable.md
View File

@ -1,21 +1,21 @@
# Nullable(TypeName) {#data-type-nullable}
# Nombre de tipo) {#data-type-nullable}
Allows to store special marker ([NULL](../query_language/syntax.md)) that denotes “missing value” alongside normal values allowed by `TypeName`. For example, a `Nullable(Int8)` type column can store `Int8` type values, and the rows that don’t have a value will store `NULL`.
Permite almacenar marcador especial ([NULO](../query_language/syntax.md)) que denota “missing value” con los valores normales permitidos por `TypeName`. Por ejemplo, un `Nullable(Int8)` Tipo columna puede almacenar `Int8` valores de tipo, y las filas que no tienen un valor almacenarán `NULL`.
For a `TypeName`, you can’t use composite data types [Array](array.md) and [Tuple](tuple.md). Composite data types can contain `Nullable` type values, such as `Array(Nullable(Int8))`.
Para un `TypeName`, no puede usar tipos de datos compuestos [Matriz](array.md) y [Tupla](tuple.md). Los tipos de datos compuestos pueden contener `Nullable` valores de tipo, como `Array(Nullable(Int8))`.
A `Nullable` type field can’t be included in table indexes.
Naciones `Nullable` no se puede incluir en los índices de tabla.
`NULL` is the default value for any `Nullable` type, unless specified otherwise in the ClickHouse server configuration.
`NULL` es el valor predeterminado para cualquier `Nullable` tipo, a menos que se especifique lo contrario en la configuración del servidor ClickHouse.
## Storage features {#storage-features}
## Características de almacenamiento {#storage-features}
To store `Nullable` type values in a table column, ClickHouse uses a separate file with `NULL` masks in addition to normal file with values. Entries in masks file allow ClickHouse to distinguish between `NULL` and a default value of corresponding data type for each table row. Because of an additional file, `Nullable` column consumes additional storage space compared to a similar normal one.
Almacenar `Nullable` es una columna de tabla, ClickHouse usa un archivo separado con `NULL` máscaras además del archivo normal con valores. Las entradas en el archivo de máscaras permiten ClickHouse distinguir entre `NULL` y un valor predeterminado del tipo de datos correspondiente para cada fila de la tabla. Debido a un archivo adicional, `Nullable` La columna consume espacio de almacenamiento adicional en comparación con una normal similar.
!!! info "Note"
Using `Nullable` almost always negatively affects performance, keep this in mind when designing your databases.
!!! info "Nota"
Utilizar `Nullable` casi siempre afecta negativamente al rendimiento, tenga esto en cuenta al diseñar sus bases de datos.
## Usage example {#usage-example}
## Ejemplo de uso {#usage-example}
``` sql
CREATE TABLE t_null(x Int8, y Nullable(Int8)) ENGINE TinyLog
@ -36,4 +36,4 @@ SELECT x + y FROM t_null
└────────────┘
```
[Original article](https://clickhouse.tech/docs/es/data_types/nullable/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/nullable/) <!--hide-->

6
docs/es/data_types/special_data_types/expression.md
View File

@ -1,5 +1,5 @@
# Expression {#expression}
# Expresion {#expression}
Used for representing lambda expressions in high-order functions.
Se utiliza para representar expresiones lambda en funciones de orden superior.
[Original article](https://clickhouse.tech/docs/es/data_types/special_data_types/expression/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/special_data_types/expression/) <!--hide-->

4
docs/es/data_types/special_data_types/index.md
View File

@ -1,5 +1,5 @@
# Special Data Types {#special-data-types}
# Tipos de datos especiales {#special-data-types}
Special data type values can’t be saved to a table or output in results, but can be used as the intermediate result when running a query.
[Original article](https://clickhouse.tech/docs/es/data_types/special_data_types/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/special_data_types/) <!--hide-->

34
docs/es/data_types/special_data_types/interval.md
View File

@ -1,16 +1,16 @@
# Interval {#data-type-interval}
# Intervalo {#data-type-interval}
The family of data types representing time and date intervals. The resulting types of the [INTERVAL](../../query_language/operators.md#operator-interval) operator.
La familia de tipos de datos que representan intervalos de fecha y hora. Los tipos resultantes del [INTERVALO](../../query_language/operators.md#operator-interval) operador.
!!! warning "Warning"
`Interval` data type values can’t be stored in tables.
!!! warning "Advertencia"
`Interval` los valores de tipo de datos no se pueden almacenar en tablas.
Structure:
Estructura:
- Time interval as an unsigned integer value.
- Type of an interval.
- Intervalo de tiempo como un valor entero sin signo.
- Tipo de intervalo.
Supported interval types:
Tipos de intervalo admitidos:
- `SECOND`
- `MINUTE`
@ -21,7 +21,7 @@ Supported interval types:
- `QUARTER`
- `YEAR`
For each interval type, there is a separate data type. For example, the `DAY` interval is expressed as the `IntervalDay` data type:
Para cada tipo de intervalo, hay un tipo de datos independiente. Por ejemplo, el `DAY` se expresa como el intervalo `IntervalDay` Tipo de datos:
``` sql
SELECT toTypeName(INTERVAL 4 DAY)
@ -33,9 +33,9 @@ SELECT toTypeName(INTERVAL 4 DAY)
└──────────────────────────────┘
```
## Usage Remarks {#data-type-interval-usage-remarks}
## Observaciones de uso {#data-type-interval-usage-remarks}
You can use `Interval`-type values in arithmetical operations with [Date](../../data_types/date.md) and [DateTime](../../data_types/datetime.md)-type values. For example, you can add 4 days to the current time:
Usted puede utilizar `Interval`-type valores en operaciones aritméticas con [Fecha](../../data_types/date.md) y [FechaHora](../../data_types/datetime.md)-type valores. Por ejemplo, puede agregar 4 días a la hora actual:
``` sql
SELECT now() as current_date_time, current_date_time + INTERVAL 4 DAY
@ -47,9 +47,9 @@ SELECT now() as current_date_time, current_date_time + INTERVAL 4 DAY
└─────────────────────┴───────────────────────────────┘
```
Intervals with different types can’t be combined. You can’t use intervals like `4 DAY 1 HOUR`. Express intervals in units that are smaller or equal to the smallest unit of the interval, for example, the interval `1 day and an hour` interval can be expressed as `25 HOUR` or `90000 SECOND`.
Los intervalos con diferentes tipos no se pueden combinar. No puedes usar intervalos como `4 DAY 1 HOUR`. Exprese los intervalos en unidades que son más pequeñas o iguales que la unidad más pequeña del intervalo, por ejemplo, el intervalo `1 day and an hour` se puede expresar como `25 HOUR` o `90000 SECOND`.
You can’t perform arithmetical operations with `Interval`-type values, but you can add intervals of different types consequently to values in `Date` or `DateTime` data types. For example:
No puede realizar operaciones aritméticas con `Interval`-type valores, pero puede agregar intervalos de diferentes tipos en consecuencia a los valores en `Date` o `DateTime` tipos de datos. Por ejemplo:
``` sql
SELECT now() AS current_date_time, current_date_time + INTERVAL 4 DAY + INTERVAL 3 HOUR
@ -61,7 +61,7 @@ SELECT now() AS current_date_time, current_date_time + INTERVAL 4 DAY + INTERVAL
└─────────────────────┴────────────────────────────────────────────────────────┘
```
The following query causes an exception:
La siguiente consulta provoca una excepción:
``` sql
select now() AS current_date_time, current_date_time + (INTERVAL 4 DAY + INTERVAL 3 HOUR)
@ -72,7 +72,7 @@ Received exception from server (version 19.14.1):
Code: 43. DB::Exception: Received from localhost:9000. DB::Exception: Wrong argument types for function plus: if one argument is Interval, then another must be Date or DateTime..
```
## See Also {#see-also}
## Ver también {#see-also}
- [INTERVAL](../../query_language/operators.md#operator-interval) operator
- [toInterval](../../query_language/functions/type_conversion_functions.md#function-tointerval) type convertion functions
- [INTERVALO](../../query_language/operators.md#operator-interval) operador
- [ToInterval](../../query_language/functions/type_conversion_functions.md#function-tointerval) funciones de conversión de tipo

10
docs/es/data_types/special_data_types/nothing.md
View File

@ -1,10 +1,10 @@
# Nothing {#nothing}
# Nada {#nothing}
The only purpose of this data type is to represent cases where value is not expected. So you can’t create a `Nothing` type value.
El único propósito de este tipo de datos es representar casos en los que no se espera un valor. Entonces no puedes crear un `Nothing` valor de tipo.
For example, literal [NULL](../../query_language/syntax.md#null-literal) has type of `Nullable(Nothing)`. See more about [Nullable](../../data_types/nullable.md).
Por ejemplo, literal [NULO](../../query_language/syntax.md#null-literal) tiene tipo de `Nullable(Nothing)`. Ver más sobre [NULO](../../data_types/nullable.md).
The `Nothing` type can also used to denote empty arrays:
El `Nothing` tipo puede también se utiliza para denotar matrices vacías:
``` sql
SELECT toTypeName(array())
@ -16,4 +16,4 @@ SELECT toTypeName(array())
└─────────────────────┘
```
[Original article](https://clickhouse.tech/docs/es/data_types/special_data_types/nothing/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/special_data_types/nothing/) <!--hide-->

6
docs/es/data_types/special_data_types/set.md
View File

@ -1,5 +1,5 @@
# Set {#set}
# Establecer {#set}
Used for the right half of an [IN](../../query_language/select.md#select-in-operators) expression.
Utilizado para la mitad derecha de un [ES](../../query_language/select.md#select-in-operators) expresión.
[Original article](https://clickhouse.tech/docs/es/data_types/special_data_types/set/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/special_data_types/set/) <!--hide-->

4
docs/es/data_types/tuple.md
View File

@ -1,6 +1,6 @@
# Tuple (T1, T2, …) {#tuplet1-t2}
Una tupla de elementos, cada uno con un individuo [tipo](index.md#data_types).
Una tupla de elementos, cada uno con un individuo [Tipo](index.md#data_types).
Las tuplas se utilizan para la agrupación temporal de columnas. Las columnas se pueden agrupar cuando se usa una expresión IN en una consulta y para especificar ciertos parámetros formales de las funciones lambda. Para obtener más información, consulte las secciones [IN operadores](../query_language/select.md) y [Funciones de orden superior](../query_language/functions/higher_order_functions.md).
@ -28,7 +28,7 @@ SELECT tuple(1,'a') AS x, toTypeName(x)
## Trabajar con tipos de datos {#working-with-data-types}
Al crear una tupla sobre la marcha, ClickHouse detecta automáticamente el tipo de cada argumento como el mínimo de los tipos que pueden almacenar el valor del argumento. Si el argumento es [NULO](../query_language/syntax.md#null-literal), el tipo del elemento de tupla es [NULL](nullable.md).
Al crear una tupla sobre la marcha, ClickHouse detecta automáticamente el tipo de cada argumento como el mínimo de los tipos que pueden almacenar el valor del argumento. Si el argumento es [NULO](../query_language/syntax.md#null-literal), el tipo del elemento de tupla es [NULO](nullable.md).
Ejemplo de detección automática de tipos de datos:

28
docs/es/data_types/uuid.md
View File

@ -1,28 +1,28 @@
# UUID {#uuid-data-type}
A universally unique identifier (UUID) is a 16-byte number used to identify records. For detailed information about the UUID, see [Wikipedia](https://en.wikipedia.org/wiki/Universally_unique_identifier).
Un identificador único universal (UUID) es un número de 16 bytes utilizado para identificar registros. Para obtener información detallada sobre el UUID, consulte [Wikipedia](https://en.wikipedia.org/wiki/Universally_unique_identifier).
The example of UUID type value is represented below:
El ejemplo de valor de tipo UUID se representa a continuación:
``` text
61f0c404-5cb3-11e7-907b-a6006ad3dba0
```
If you do not specify the UUID column value when inserting a new record, the UUID value is filled with zero:
Si no especifica el valor de la columna UUID al insertar un nuevo registro, el valor UUID se rellena con cero:
``` text
00000000-0000-0000-0000-000000000000
```
## How to generate {#how-to-generate}
## Cómo generar {#how-to-generate}
To generate the UUID value, ClickHouse provides the [generateUUIDv4](../query_language/functions/uuid_functions.md) function.
Para generar el valor UUID, ClickHouse proporciona el [GenerateUUIDv4](../query_language/functions/uuid_functions.md) función.
## Usage example {#usage-example}
## Ejemplo de uso {#usage-example}
**Example 1**
**Ejemplo 1**
This example demonstrates creating a table with the UUID type column and inserting a value into the table.
En este ejemplo se muestra la creación de una tabla con la columna de tipo UUID e insertar un valor en la tabla.
``` sql
CREATE TABLE t_uuid (x UUID, y String) ENGINE=TinyLog
@ -42,9 +42,9 @@ SELECT * FROM t_uuid
└──────────────────────────────────────┴───────────┘
```
**Example 2**
**Ejemplo 2**
In this example, the UUID column value is not specified when inserting a new record.
En este ejemplo, el valor de la columna UUID no se especifica al insertar un nuevo registro.
``` sql
INSERT INTO t_uuid (y) VALUES ('Example 2')
@ -61,10 +61,10 @@ SELECT * FROM t_uuid
└──────────────────────────────────────┴───────────┘
```
## Restrictions {#restrictions}
## Restricción {#restrictions}
The UUID data type only supports functions which [String](string.md) data type also supports (for example, [min](../query_language/agg_functions/reference.md#agg_function-min), [max](../query_language/agg_functions/reference.md#agg_function-max), and [count](../query_language/agg_functions/reference.md#agg_function-count)).
El tipo de datos UUID sólo admite funciones que [Cadena](string.md) tipo de datos también soporta (por ejemplo, [minuto](../query_language/agg_functions/reference.md#agg_function-min), [máximo](../query_language/agg_functions/reference.md#agg_function-max), y [contar](../query_language/agg_functions/reference.md#agg_function-count)).
The UUID data type is not supported by arithmetic operations (for example, [abs](../query_language/functions/arithmetic_functions.md#arithm_func-abs)) or aggregate functions, such as [sum](../query_language/agg_functions/reference.md#agg_function-sum) and [avg](../query_language/agg_functions/reference.md#agg_function-avg).
El tipo de datos UUID no es compatible con operaciones aritméticas (por ejemplo, [abdominales](../query_language/functions/arithmetic_functions.md#arithm_func-abs)) o funciones agregadas, tales como [resumir](../query_language/agg_functions/reference.md#agg_function-sum) y [avg](../query_language/agg_functions/reference.md#agg_function-avg).
[Original article](https://clickhouse.tech/docs/es/data_types/uuid/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/data_types/uuid/) <!--hide-->

2
docs/es/database_engines/index.md
View File

@ -2,7 +2,7 @@
Los motores de bases de datos le permiten trabajar con tablas.
De forma predeterminada, ClickHouse utiliza su motor de base de datos nativa, que proporciona [motores de mesa](../operations/table_engines/index.md) y una [Dialecto SQL](../query_language/syntax.md).
De forma predeterminada, ClickHouse utiliza su motor de base de datos nativa, que proporciona [motores de mesa](../operations/table_engines/index.md) y una [Sistema abierto.](../query_language/syntax.md).
También puede utilizar los siguientes motores de base de datos:

4
docs/es/database_engines/mysql.md
View File

@ -1,6 +1,6 @@
# MySQL {#mysql}
Permite conectarse a bases de datos en un servidor MySQL remoto y realizar `INSERT` y `SELECT` consultas para intercambiar datos entre ClickHouse y MySQL.
Permite conectarse a bases de datos en un servidor MySQL remoto y realizar `INSERT` y `SELECT` Consultas para intercambiar datos entre ClickHouse y MySQL.
El `MySQL` motor de base de datos traducir consultas al servidor MySQL para que pueda realizar operaciones tales como `SHOW TABLES` o `SHOW CREATE TABLE`.
@ -44,7 +44,7 @@ ENGINE = MySQL('host:port', 'database', 'user', 'password')
Todos los demás tipos de datos MySQL se convierten en [Cadena](../data_types/string.md).
[NULL](../data_types/nullable.md) se admite.
[NULO](../data_types/nullable.md) se admite.
## Ejemplos de uso {#examples-of-use}

36
docs/es/development/architecture.md
View File

@ -8,7 +8,7 @@ Existen dos enfoques diferentes para acelerar el procesamiento de consultas: la
## Columna {#columns}
Para representar columnas en la memoria (en realidad, fragmentos de columnas), el `IColumn` se utiliza la interfaz. Esta interfaz proporciona métodos auxiliares para la implementación de varios operadores relacionales. Casi todas las operaciones son inmutables: no modifican la columna original, sino que crean una nueva modificada. Por ejemplo, el `IColumn :: filter` método acepta una máscara de bytes de filtro. Se utiliza para el `WHERE` y `HAVING` operadores relacionales. Ejemplos adicionales: el `IColumn :: permute` para apoyar `ORDER BY`, el `IColumn :: cut` para apoyar `LIMIT` y así sucesivamente.
Para representar columnas en la memoria (en realidad, fragmentos de columnas), el `IColumn` se utiliza la interfaz. Esta interfaz proporciona métodos auxiliares para la implementación de varios operadores relacionales. Casi todas las operaciones son inmutables: no modifican la columna original, sino que crean una nueva modificada. Por ejemplo, el `IColumn :: filter` método acepta una máscara de bytes de filtro. Se utiliza para el `WHERE` y `HAVING` operadores relacionales. Ejemplos adicionales: el `IColumn :: permute` para apoyar `ORDER BY` el `IColumn :: cut` para apoyar `LIMIT` y así sucesivamente.
Diversos `IColumn` aplicación (`ColumnUInt8`, `ColumnString` y así sucesivamente) son responsables del diseño de memoria de las columnas. El diseño de memoria suele ser una matriz contigua. Para el tipo entero de columnas, es solo una matriz contigua, como `std :: vector`. Para `String` y `Array` columnas, son dos vectores: uno para todos los elementos de la matriz, colocados contiguamente, y un segundo para los desplazamientos al comienzo de cada matriz. También hay `ColumnConst` que almacena solo un valor en la memoria, pero parece una columna.
@ -16,7 +16,7 @@ Diversos `IColumn` aplicación (`ColumnUInt8`, `ColumnString` y así sucesivamen
Sin embargo, también es posible trabajar con valores individuales. Para representar un valor individual, el `Field` se utiliza. `Field` es sólo una unión discriminada de `UInt64`, `Int64`, `Float64`, `String` y `Array`. `IColumn` tiene el `operator[]` para obtener el valor n-ésimo como un `Field` y el `insert` método para agregar un `Field` al final de una columna. Estos métodos no son muy eficientes, ya que requieren tratar con temporal `Field` objetos que representan un valor individual. Hay métodos más eficientes, tales como `insertFrom`, `insertRangeFrom` y así sucesivamente.
`Field` no tiene suficiente información sobre un tipo de datos específico para una tabla. Por ejemplo, `UInt8`, `UInt16`, `UInt32`, y `UInt64` todos están representados como `UInt64` en una `Field`.
`Field` no tiene suficiente información sobre un tipo de datos específico para una tabla. Por ejemplo, `UInt8`, `UInt16`, `UInt32`, y `UInt64` todos están representados como `UInt64` es una `Field`.
## Abstracciones con fugas {#leaky-abstractions}
@ -26,17 +26,17 @@ Varias funciones en columnas se pueden implementar de una manera genérica, no e
## Tipos de datos {#data-types}
`IDataType` es responsable de la serialización y deserialización: para leer y escribir fragmentos de columnas o valores individuales en formato binario o de texto. `IDataType` corresponde directamente a los tipos de datos en las tablas. Por ejemplo, hay `DataTypeUInt32`, `DataTypeDateTime`, `DataTypeString` y así sucesivamente.
`IDataType` es responsable de la serialización y deserialización: para leer y escribir fragmentos de columnas o valores individuales en formato binario o de texto. `IDataType` corresponde directamente a los tipos de datos en las tablas. Por ejemplo, heno `DataTypeUInt32`, `DataTypeDateTime`, `DataTypeString` y así sucesivamente.
`IDataType` y `IColumn` están vagamente relacionados entre sí. Diferentes tipos de datos se pueden representar en la memoria por el mismo `IColumn` aplicación. Por ejemplo, `DataTypeUInt32` y `DataTypeDateTime` están representados por `ColumnUInt32` o `ColumnConstUInt32`. Además, el mismo tipo de datos se puede representar mediante `IColumn` aplicación. Por ejemplo, `DataTypeUInt8` puede ser representado por `ColumnUInt8` o `ColumnConstUInt8`.
`IDataType` sólo almacena metadatos. Por ejemplo, `DataTypeUInt8` no almacena nada en absoluto (excepto vptr) y `DataTypeFixedString` tiendas solo `N` (el tamaño de las cadenas de tamaño fijo).
`IDataType` sólo almacena metadatos. Por ejemplo, `DataTypeUInt8` no almacena nada en absoluto (excepto vptr) y `DataTypeFixedString` tiendas en solitario `N` (el tamaño de las cadenas de tamaño fijo).
`IDataType` tiene métodos auxiliares para varios formatos de datos. Los ejemplos son métodos para serializar un valor con posibles citas, para serializar un valor para JSON y para serializar un valor como parte del formato XML. No hay correspondencia directa con los formatos de datos. Por ejemplo, los diferentes formatos de datos `Pretty` y `TabSeparated` puede utilizar el mismo `serializeTextEscaped` método de ayuda de la `IDataType` interfaz.
`IDataType` tiene métodos auxiliares para varios formatos de datos. Los ejemplos son métodos para serializar un valor con posibles citas, para serializar un valor para JSON y para serializar un valor como parte del formato XML. No hay correspondencia directa con los formatos de datos. Por ejemplo, los diferentes formatos de datos `Pretty` y `TabSeparated` Puede utilizar el mismo `serializeTextEscaped` método de ayuda de la `IDataType` interfaz.
## Bloque {#block}
Un `Block` es un contenedor que representa un subconjunto (porción) de una tabla en la memoria. Es sólo un conjunto de triples: `(IColumn, IDataType, column name)`. Durante la ejecución de la consulta, los datos son procesados por `Block`s. Si tenemos un `Block`, tenemos datos (en el `IColumn` objeto), tenemos información sobre su tipo (en `IDataType`) que nos dice cómo lidiar con esa columna, y tenemos el nombre de la columna (ya sea el nombre de la columna original de la tabla o algún nombre artificial asignado para obtener resultados temporales de los cálculos).
Naciones `Block` es un contenedor que representa un subconjunto (porción) de una tabla en la memoria. Es sólo un conjunto de triples: `(IColumn, IDataType, column name)`. Durante la ejecución de la consulta, los datos son procesados por `Block`s. Si tenemos un `Block`, tenemos datos (en el `IColumn` objeto), tenemos información sobre su tipo (en `IDataType`) que nos dice cómo lidiar con esa columna, y tenemos el nombre de la columna (ya sea el nombre de la columna original de la tabla o algún nombre artificial asignado para obtener resultados temporales de los cálculos).
Cuando calculamos alguna función sobre columnas en un bloque, agregamos otra columna con su resultado al bloque, y no tocamos columnas para argumentos de la función porque las operaciones son inmutables. Más tarde, las columnas innecesarias se pueden eliminar del bloque, pero no se pueden modificar. Esto es conveniente para la eliminación de subexpresiones comunes.
@ -50,7 +50,7 @@ Los flujos son responsables de:
1. Leer o escribir en una mesa. La tabla solo devuelve una secuencia para leer o escribir bloques.
2. Implementación de formatos de datos. Por ejemplo, si desea enviar datos a un terminal en `Pretty` formato, crea un flujo de salida de bloque donde presiona bloques y los formatea.
3. Realización de transformaciones de datos. Digamos que tienes `IBlockInputStream` y desea crear una secuencia filtrada. Usted crea `FilterBlockInputStream` e inicializarlo con su transmisión. Luego, cuando tiras de un bloque de `FilterBlockInputStream`, extrae un bloque de su flujo, lo filtra y le devuelve el bloque filtrado. Las canalizaciones de ejecución de consultas se representan de esta manera.
3. Realización de transformaciones de datos. Digamos que tienes `IBlockInputStream` y desea crear una secuencia filtrada. Bienvenidos `FilterBlockInputStream` e inicializarlo con su transmisión. Luego, cuando tiras de un bloque de `FilterBlockInputStream`, extrae un bloque de su flujo, lo filtra y le devuelve el bloque filtrado. Las canalizaciones de ejecución de consultas se representan de esta manera.
Hay transformaciones más sofisticadas. Por ejemplo, cuando tiras de `AggregatingBlockInputStream`, lee todos los datos de su origen, los agrega y, a continuación, devuelve un flujo de datos agregados para usted. Otro ejemplo: `UnionBlockInputStream` acepta muchas fuentes de entrada en el constructor y también una serie de subprocesos. Lanza múltiples hilos y lee de múltiples fuentes en paralelo.
@ -60,13 +60,13 @@ Debemos tener en cuenta que la canalización de ejecución de consultas crea dat
## Formato {#formats}
Los formatos de datos se implementan con flujos de bloques. Hay “presentational” sólo es adecuado para la salida de datos al cliente, tales como `Pretty` formato, que proporciona sólo `IBlockOutputStream`. Y hay formatos de entrada / salida, como `TabSeparated` o `JSONEachRow`.
Los formatos de datos se implementan con flujos de bloques. Heno “presentational” sólo es adecuado para la salida de datos al cliente, tales como `Pretty` formato, que proporciona sólo `IBlockOutputStream`. Y hay formatos de entrada / salida, como `TabSeparated` o `JSONEachRow`.
También hay secuencias de filas: `IRowInputStream` y `IRowOutputStream`. Permiten pull/push datos por filas individuales, no por bloques. Y solo son necesarios para simplificar la implementación de formatos orientados a filas. Envoltura `BlockInputStreamFromRowInputStream` y `BlockOutputStreamFromRowOutputStream` le permite convertir flujos orientados a filas en flujos regulares orientados a bloques.
También hay secuencias de filas: `IRowInputStream` y `IRowOutputStream`. Permiten pull/push datos por filas individuales, no por bloques. Y solo son necesarios para simplificar la implementación de formatos orientados a filas. Envoltura `BlockInputStreamFromRowInputStream` y `BlockOutputStreamFromRowOutputStream` seguros de que el usuario puede acceder a la información sobre cualquier tipo de información.
## E/S {#io}
Para la entrada / salida orientada a bytes, hay `ReadBuffer` y `WriteBuffer` clases abstractas. Se usan en lugar de C ++ `iostream`s. No se preocupe: cada proyecto maduro de C ++ está usando algo más que `iostream`s por buenas razones.
Para la entrada / salida orientada a bytes, heno `ReadBuffer` y `WriteBuffer` clases abstractas. Se usan en lugar de C ++ `iostream`s. No se preocupe: cada proyecto maduro de C ++ está usando algo más que `iostream`s por buenas razones.
`ReadBuffer` y `WriteBuffer` son solo un búfer contiguo y un cursor apuntando a la posición en ese búfer. Las implementaciones pueden poseer o no la memoria del búfer. Hay un método virtual para llenar el búfer con los siguientes datos (para `ReadBuffer`) o para vaciar el búfer en algún lugar (para `WriteBuffer`). Los métodos virtuales rara vez se llaman.
@ -74,13 +74,13 @@ Implementaciones de `ReadBuffer`/`WriteBuffer` se utilizan para trabajar con arc
Read / WriteBuffers solo se ocupan de bytes. Para ayudar con la entrada / salida formateada (por ejemplo, para escribir un número en formato decimal), hay funciones de `ReadHelpers` y `WriteHelpers` archivos de encabezado.
Veamos qué sucede cuando quieres escribir un conjunto de resultados en `JSON` formato a stdout. Tiene un conjunto de resultados listo para ser recuperado de `IBlockInputStream`. Usted crea `WriteBufferFromFileDescriptor(STDOUT_FILENO)` para escribir bytes en stdout. Usted crea `JSONRowOutputStream`, inicializado con eso `WriteBuffer` para escribir filas en `JSON` a stdout. Usted crea `BlockOutputStreamFromRowOutputStream` encima de él, para representarlo como `IBlockOutputStream`. Entonces usted llama `copyData` para transferir datos desde `IBlockInputStream` a `IBlockOutputStream` y todo funciona. Internamente, `JSONRowOutputStream` escribirá varios delimitadores JSON y llamará al `IDataType::serializeTextJSON` con una referencia a `IColumn` y el número de fila como argumentos. Consecuentemente, `IDataType::serializeTextJSON` llamará a un método de `WriteHelpers.h`: por ejemplo, `writeText` para tipos numéricos y `writeJSONString` para `DataTypeString`.
Veamos qué sucede cuando quieres escribir un conjunto de resultados en `JSON` Formato una salida estándar. Tiene un conjunto de resultados listo para ser recuperado de `IBlockInputStream`. Bienvenidos `WriteBufferFromFileDescriptor(STDOUT_FILENO)` para escribir bytes en stdout. Bienvenidos `JSONRowOutputStream`, inicializado con eso `WriteBuffer` para escribir filas en `JSON` una salida estándar. Bienvenidos `BlockOutputStreamFromRowOutputStream` encima de él, para representarlo como `IBlockOutputStream`. Entonces usted llama `copyData` para transferir datos desde `IBlockInputStream` Naciones `IBlockOutputStream` y todo funciona. Internamente, `JSONRowOutputStream` escribirá varios delimitadores JSON y llamará al `IDataType::serializeTextJSON` con una referencia a `IColumn` y el número de fila como argumentos. Consecuentemente, `IDataType::serializeTextJSON` llamará a un método de `WriteHelpers.h`: por ejemplo, `writeText` para tipos numéricos y `writeJSONString` para `DataTypeString`.
## Tabla {#tables}
Las tablas están representadas por el `IStorage` interfaz. Las diferentes implementaciones de esa interfaz son diferentes motores de tabla. Los ejemplos son `StorageMergeTree`, `StorageMemory` y así sucesivamente. Las instancias de estas clases son solo tablas.
Las tablas están representadas por el `IStorage` interfaz. Las diferentes implementaciones de esa interfaz son diferentes motores de tabla. Los ejemplos hijo `StorageMergeTree`, `StorageMemory` y así sucesivamente. Las instancias de estas clases son solo tablas.
El más importante `IStorage` son `read` y `write`. También hay `alter`, `rename`, `drop` y así sucesivamente. El `read` método acepta los siguientes argumentos: el conjunto de columnas para leer de una tabla, el `AST` consulta a considerar, y el número deseado de flujos para devolver. Devuelve uno o varios `IBlockInputStream` objetos e información sobre la etapa de procesamiento de datos que se completó dentro de un motor de tablas durante la ejecución de la consulta.
El más importante `IStorage` hijo `read` y `write`. También hay `alter`, `rename`, `drop` y así sucesivamente. El `read` método acepta los siguientes argumentos: el conjunto de columnas para leer de una tabla, el `AST` consulta a considerar, y el número deseado de flujos para devolver. Devuelve uno o varios `IBlockInputStream` objetos e información sobre la etapa de procesamiento de datos que se completó dentro de un motor de tablas durante la ejecución de la consulta.
En la mayoría de los casos, el método de lectura solo es responsable de leer las columnas especificadas de una tabla, no de ningún procesamiento de datos adicional. Todo el procesamiento de datos adicional es realizado por el intérprete de consultas y está fuera de la responsabilidad de `IStorage`.
@ -91,7 +91,7 @@ Pero hay excepciones notables:
La mesa de `read` método puede devolver múltiples `IBlockInputStream` objetos para permitir el procesamiento de datos en paralelo. Estos flujos de entrada de bloques múltiples pueden leer de una tabla en paralelo. A continuación, puede ajustar estas secuencias con varias transformaciones (como la evaluación de expresiones o el filtrado) que se pueden calcular de forma independiente y crear un `UnionBlockInputStream` encima de ellos, para leer desde múltiples flujos en paralelo.
También hay `TableFunction`s. Estas son funciones que devuelven un `IStorage` objeto a utilizar en el `FROM` cláusula de una consulta.
También hay `TableFunction`Estas son funciones que devuelven un `IStorage` objeto a utilizar en el `FROM` cláusula de una consulta.
Para tener una idea rápida de cómo implementar su propio motor de tablas, vea algo simple, como `StorageMemory` o `StorageTinyLog`.
@ -105,9 +105,9 @@ Una consulta es analizada por un analizador de descenso recursivo escrito a mano
## Interprete {#interpreters}
Los intérpretes son responsables de crear la canalización de ejecución de consultas `AST`. Hay intérpretes simples, como `InterpreterExistsQuery` y `InterpreterDropQuery` o el más sofisticado `InterpreterSelectQuery`. La canalización de ejecución de consultas es una combinación de flujos de entrada o salida de bloques. Por ejemplo, el resultado de interpretar el `SELECT` la consulta es la `IBlockInputStream` para leer el conjunto de resultados; el resultado de la consulta INSERT es el `IBlockOutputStream` para escribir datos para su inserción, y el resultado de interpretar el `INSERT SELECT` la consulta es la `IBlockInputStream` que devuelve un conjunto de resultados vacío en la primera lectura, pero que copia datos de `SELECT` a `INSERT` al mismo tiempo.
Los intérpretes son responsables de crear la canalización de ejecución de consultas `AST`. Hay intérpretes simples, como `InterpreterExistsQuery` y `InterpreterDropQuery` o el más sofisticado `InterpreterSelectQuery`. La canalización de ejecución de consultas es una combinación de flujos de entrada o salida de bloques. Por ejemplo, el resultado de interpretar el `SELECT` la consulta es la `IBlockInputStream` para leer el conjunto de resultados; el resultado de la consulta INSERT es el `IBlockOutputStream` para escribir datos para su inserción, y el resultado de interpretar el `INSERT SELECT` la consulta es la `IBlockInputStream` que devuelve un conjunto de resultados vacío en la primera lectura, pero que copia datos de `SELECT` Naciones `INSERT` al mismo tiempo.
`InterpreterSelectQuery` utilizar `ExpressionAnalyzer` y `ExpressionActions` maquinaria para el análisis de consultas y transformaciones. Aquí es donde se realizan la mayoría de las optimizaciones de consultas basadas en reglas. `ExpressionAnalyzer` es bastante complicado y debe reescribirse: se deben extraer varias transformaciones de consultas y optimizaciones para separar clases para permitir transformaciones modulares o consultas.
`InterpreterSelectQuery` utilizar `ExpressionAnalyzer` y `ExpressionActions` maquinaria para el análisis de consultas y transformaciones. Aquí es donde se realizan la mayoría de las optimizaciones de consultas basadas en reglas. `ExpressionAnalyzer` Se deben extraer varias transformaciones de consultas y optimizaciones para separar clases para permitir transformaciones modulares o consultas.
## Función {#functions}
@ -163,7 +163,7 @@ No existe un plan de consulta global para la ejecución de consultas distribuida
`MergeTree` es una familia de motores de almacenamiento que admite la indexación por clave principal. La clave principal puede ser una tupla arbitraria de columnas o expresiones. Datos en un `MergeTree` se almacena en “parts”. Cada parte almacena datos en el orden de clave primaria (los datos son ordenados lexicográficamente por la tupla de clave primaria). Todas las columnas de la tabla se almacenan en `column.bin` archivos en estas partes. Los archivos consisten en bloques comprimidos. Cada bloque suele ser de 64 KB a 1 MB de datos sin comprimir, dependiendo del tamaño del valor promedio. Los bloques constan de valores de columna colocados contiguamente uno tras otro. Los valores de columna están en el mismo orden para cada columna (el orden está definido por la clave principal), por lo que cuando itera por muchas columnas, obtiene valores para las filas correspondientes.
La clave principal en sí es “sparse”. No aborda todas las filas, sino solo algunos rangos de datos. Separado `primary.idx` file tiene el valor de la clave principal para cada fila N-ésima, donde se llama N `index_granularity` (generalmente, N = 8192). Además, para cada columna, tenemos `column.mrk` archivos con “marks,” que son desplazamientos a cada fila N-ésima en el archivo de datos. Cada marca es un par: el desplazamiento en el archivo al comienzo del bloque comprimido y el desplazamiento en el bloque descomprimido al comienzo de los datos. Por lo general, los bloques comprimidos están alineados por marcas, y el desplazamiento en el bloque descomprimido es cero. Datos para `primary.idx` siempre reside en la memoria y los datos para `column.mrk` archivos se almacena en caché.
La clave principal en sí es “sparse”. No aborda todas las filas, sino solo algunos rangos de datos. Separado `primary.idx` file tiene el valor de la clave principal para cada fila N-ésima, donde se llama N `index_granularity` (generalmente, N = 8192). Además, para cada columna, tenemos `column.mrk` Archivos con “marks,” que son desplazamientos a cada fila N-ésima en el archivo de datos. Cada marca es un par: el desplazamiento en el archivo al comienzo del bloque comprimido y el desplazamiento en el bloque descomprimido al comienzo de los datos. Por lo general, los bloques comprimidos están alineados por marcas, y el desplazamiento en el bloque descomprimido es cero. Datos para `primary.idx` siempre reside en la memoria y los datos para `column.mrk` archivos se almacena en caché.
Cuando vamos a leer algo de una parte en `MergeTree` miramos `primary.idx` datos y localice rangos que posiblemente podrían contener datos solicitados, luego mire `column.mrk` datos y calcular compensaciones para dónde comenzar a leer esos rangos. Debido a la escasez, el exceso de datos puede ser leído. ClickHouse no es adecuado para una gran carga de consultas de puntos simples, porque todo el rango con `index_granularity` se deben leer filas para cada clave, y todo el bloque comprimido debe descomprimirse para cada columna. Hicimos que el índice sea disperso porque debemos poder mantener billones de filas por único servidor sin un consumo de memoria notable para el índice. Además, debido a que la clave principal es escasa, no es única: no puede verificar la existencia de la clave en la tabla en el momento de INSERTAR. Podría tener muchas filas con la misma clave en una tabla.
@ -183,7 +183,7 @@ La replicación se implementa en el `ReplicatedMergeTree` motor de almacenamient
La replicación utiliza un esquema multi-maestro asíncrono. Puede insertar datos en cualquier réplica que tenga una sesión con `ZooKeeper`, y los datos se replican en todas las demás réplicas de forma asíncrona. Debido a que ClickHouse no admite UPDATE, la replicación está libre de conflictos. Como no hay reconocimiento de quórum de inserciones, los datos recién insertados pueden perderse si un nodo falla.
Los metadatos para la replicación se almacenan en ZooKeeper. Hay un registro de replicación que enumera las acciones que se deben realizar. Las acciones son: obtener parte; fusionar partes; soltar una partición, etc. Cada réplica copia el registro de replicación en su cola y, a continuación, ejecuta las acciones desde la cola. Por ejemplo, en la inserción, el “get the part” la acción se crea en el registro y cada réplica descarga esa parte. Las fusiones se coordinan entre réplicas para obtener resultados idénticos en bytes. Todas las piezas se combinan de la misma manera en todas las réplicas. Para lograr esto, se elige una réplica como líder y esa réplica inicia fusiones y escrituras “merge parts” acciones al registro.
Los metadatos para la replicación se almacenan en ZooKeeper. Hay un registro de replicación que enumera las acciones que se deben realizar. Las acciones son: obtener parte; fusionar partes; soltar una partición, etc. Cada réplica copia el registro de replicación en su cola y, a continuación, ejecuta las acciones desde la cola. Por ejemplo, en la inserción, el “get the part” la acción se crea en el registro y cada réplica descarga esa parte. Las fusiones se coordinan entre réplicas para obtener resultados idénticos en bytes. Todas las piezas se combinan de la misma manera en todas las réplicas. Para lograr esto, se elige una réplica como líder y esa réplica inicia fusiones y escrituras “merge parts” Acciones al registro.
La replicación es física: solo las partes comprimidas se transfieren entre nodos, no consultas. Para reducir el costo de la red (para evitar la amplificación de la red), las fusiones se procesan en cada réplica de forma independiente en la mayoría de los casos. Las piezas combinadas grandes se envían a través de la red solo en casos de retraso de replicación significativo.

2
docs/es/development/build_cross_osx.md
View File

@ -16,7 +16,7 @@ sudo apt-get install clang-8
# Instalar conjunto de herramientas de compilación cruzada {#install-cross-compilation-toolset}
Recordemos la ruta donde instalamos `cctools` como ${CCTOOLS}
Recordemos la ruta donde instalamos `cctools` Como ${CCTOOLS}
``` bash
mkdir ${CCTOOLS}

8
docs/es/development/contrib.md
View File

@ -3,14 +3,14 @@
| Biblioteca | Licencia |
|--------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
| base64 | [Licencia BSD de 2 cláusulas](https://github.com/aklomp/base64/blob/a27c565d1b6c676beaf297fe503c4518185666f7/LICENSE) |
| impulsar | [Licencia de software Boost 1.0](https://github.com/ClickHouse-Extras/boost-extra/blob/6883b40449f378019aec792f9983ce3afc7ff16e/LICENSE_1_0.txt) |
| Impulsar | [Licencia de software Boost 1.0](https://github.com/ClickHouse-Extras/boost-extra/blob/6883b40449f378019aec792f9983ce3afc7ff16e/LICENSE_1_0.txt) |
| Bienvenido | [MIT](https://github.com/google/brotli/blob/master/LICENSE) |
| capnproto | [MIT](https://github.com/capnproto/capnproto/blob/master/LICENSE) |
| Cctz | [Licencia Apache 2.0](https://github.com/google/cctz/blob/4f9776a310f4952454636363def82c2bf6641d5f/LICENSE.txt) |
| doble conversión | [Licencia de 3 cláusulas BSD](https://github.com/google/double-conversion/blob/cf2f0f3d547dc73b4612028a155b80536902ba02/LICENSE) |
| FastMemcpy | [MIT](https://github.com/ClickHouse/ClickHouse/blob/master/libs/libmemcpy/impl/LICENSE) |
| Más información | [Licencia de 3 cláusulas BSD](https://github.com/google/googletest/blob/master/LICENSE) |
| H3 | [Licencia Apache 2.0](https://github.com/uber/h3/blob/master/LICENSE) |
| Hombre | [Licencia Apache 2.0](https://github.com/uber/h3/blob/master/LICENSE) |
| hyperscan | [Licencia de 3 cláusulas BSD](https://github.com/intel/hyperscan/blob/master/LICENSE) |
| libbtrie | [Licencia BSD de 2 cláusulas](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/libbtrie/LICENSE) |
| libcxxabi | [Sistema abierto.](https://github.com/ClickHouse/ClickHouse/blob/master/libs/libglibc-compatibility/libcxxabi/LICENSE.TXT) |
@ -18,13 +18,13 @@
| libgsasl | [Información adicional](https://github.com/ClickHouse-Extras/libgsasl/blob/3b8948a4042e34fb00b4fb987535dc9e02e39040/LICENSE) |
| libhdfs3 | [Licencia Apache 2.0](https://github.com/ClickHouse-Extras/libhdfs3/blob/bd6505cbb0c130b0db695305b9a38546fa880e5a/LICENSE.txt) |
| libmetrohash | [Licencia Apache 2.0](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/libmetrohash/LICENSE) |
| libpcg-al azar | [Licencia Apache 2.0](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/libpcg-random/LICENSE-APACHE.txt) |
| Libpcg-al azar | [Licencia Apache 2.0](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/libpcg-random/LICENSE-APACHE.txt) |
| Libressl | [Licencia OpenSSL](https://github.com/ClickHouse-Extras/ssl/blob/master/COPYING) |
| Librdkafka | [Licencia BSD de 2 cláusulas](https://github.com/edenhill/librdkafka/blob/363dcad5a23dc29381cc626620e68ae418b3af19/LICENSE) |
| libwidechar\_width | [CC0 1.0 Universal](https://github.com/ClickHouse/ClickHouse/blob/master/libs/libwidechar_width/LICENSE) |
| llvm | [Licencia de 3 cláusulas BSD](https://github.com/ClickHouse-Extras/llvm/blob/163def217817c90fb982a6daf384744d8472b92b/llvm/LICENSE.TXT) |
| lz4 | [Licencia BSD de 2 cláusulas](https://github.com/lz4/lz4/blob/c10863b98e1503af90616ae99725ecd120265dfb/LICENSE) |
| mariadb-conector-c | [Información adicional](https://github.com/ClickHouse-Extras/mariadb-connector-c/blob/3.1/COPYING.LIB) |
| Mariadb-conector-c | [Información adicional](https://github.com/ClickHouse-Extras/mariadb-connector-c/blob/3.1/COPYING.LIB) |
| murmurhash | [Dominio público](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/murmurhash/LICENSE) |
| pdqsort | [Licencia Zlib](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/pdqsort/license.txt) |
| Poco | [Boost Software License - Versión 1.0](https://github.com/ClickHouse-Extras/poco/blob/fe5505e56c27b6ecb0dcbc40c49dc2caf4e9637f/LICENSE) |

14
docs/es/development/developer_instruction.md
View File

@ -2,7 +2,7 @@ La construcción de ClickHouse es compatible con Linux, FreeBSD y Mac OS X.
# Si utiliza Windows {#if-you-use-windows}
Si usa Windows, necesita crear una máquina virtual con Ubuntu. Para comenzar a trabajar con una máquina virtual, instale VirtualBox. Puede descargar Ubuntu desde el sitio web: https://www.ubuntu.com/\#download. Por favor, cree una máquina virtual a partir de la imagen descargada (debe reservar al menos 4 GB de RAM para ello). Para ejecutar un terminal de línea de comandos en Ubuntu, busque un programa que contenga la palabra “terminal” en su nombre (gnome-terminal, konsole etc.) o simplemente presione Ctrl + Alt + T.
Si usa Windows, necesita crear una máquina virtual con Ubuntu. Para comenzar a trabajar con una máquina virtual, instale VirtualBox. Puede descargar Ubuntu desde el sitio web: https://www.ubuntu.com/\#download. Por favor, cree una máquina virtual a partir de la imagen descargada (debe reservar al menos 4 GB de RAM para ello). Para ejecutar un terminal de línea de comandos en Ubuntu, busque un programa que contenga la palabra “terminal” es su nombre (gnome-terminal, konsole, etc.) o simplemente presione Ctrl + Alt + T.
# Si utiliza un sistema de 32 bits {#if-you-use-a-32-bit-system}
@ -16,7 +16,7 @@ Probablemente ya tenga uno, pero si no lo hace, regístrese en https://github.co
Cree una bifurcación del repositorio ClickHouse. Para hacerlo por favor haga clic en el “fork” botón en la esquina superior derecha en https://github.com/ClickHouse/ClickHouse . Se bifurcará su propia copia de ClickHouse/ClickHouse a su cuenta.
El proceso de desarrollo consiste en comprometer primero los cambios previstos en su bifurcación de ClickHouse y luego crear un “pull request” para que estos cambios sean aceptados en el repositorio principal (ClickHouse / ClickHouse).
El proceso de desarrollo consiste en comprometer primero los cambios previstos en su bifurcación de ClickHouse y luego crear un “pull request” Para que estos cambios sean aceptados en el repositorio principal (ClickHouse / ClickHouse).
Para trabajar con repositorios git, instale `git`.
@ -138,11 +138,11 @@ Compruebe la versión de gcc: `gcc --version`. Si está por debajo de 9, siga la
La compilación de Mac OS X solo es compatible con Clang. Sólo tiene que ejecutar `brew install llvm`
Si decide utilizar Clang, también puede instalar `libc++` y `lld` si usted sabe lo que es. Utilizar `ccache` también se recomienda.
Si decide utilizar Clang, también puede instalar `libc++` y `lld` sabe lo que es. Utilizar `ccache` también se recomienda.
# El proceso de construcción {#the-building-process}
Ahora que está listo para construir ClickHouse, le recomendamos que cree un directorio separado `build` dentro `ClickHouse` que contendrá todos los de la generación de artefactos:
Ahora que está listo para construir ClickHouse, le recomendamos que cree un directorio separado `build` Dentro `ClickHouse` que contendrá todos los de la generación de artefactos:
mkdir build
cd build
@ -167,7 +167,7 @@ Para una construcción más rápida, puede recurrir al `debug` tipo de compilaci
cmake -D CMAKE_BUILD_TYPE=Debug ..
Puede cambiar el tipo de compilación ejecutando este comando en el `build` directorio.
Puede cambiar el tipo de compilación ejecutando este comando en el `build` Directorio.
Ejecutar ninja para construir:
@ -217,7 +217,7 @@ Puede reemplazar la versión de producción del binario ClickHouse instalado en
sudo cp ClickHouse/build/dbms/programs/clickhouse /usr/bin/
sudo service clickhouse-server start
Tenga en cuenta que `clickhouse-client`, `clickhouse-server` y otros son enlaces simbólicos a los comúnmente compartidos `clickhouse` binario.
Tenga en cuenta que `clickhouse-client`, `clickhouse-server` y otros son enlaces simbólicos a los comúnmente compartidos `clickhouse` Binario.
También puede ejecutar su binario ClickHouse personalizado con el archivo de configuración del paquete ClickHouse instalado en su sistema:
@ -273,6 +273,6 @@ Se puede crear una solicitud de extracción incluso si el trabajo aún no se ha
Las pruebas comenzarán tan pronto como los empleados de Yandex etiqueten su PR con una etiqueta “can be tested”. Los resultados de algunas primeras comprobaciones (por ejemplo, el estilo de código) llegarán en varios minutos. Los resultados de la comprobación de compilación llegarán dentro de media hora. Y el conjunto principal de pruebas se informará dentro de una hora.
El sistema preparará compilaciones binarias ClickHouse para su solicitud de extracción individualmente. Para recuperar estas compilaciones, haga clic en “Details” junto al link “ClickHouse build check” en la lista de cheques. Allí encontrará enlaces directos a la construcción.deb paquetes de ClickHouse que puede implementar incluso en sus servidores de producción (si no tiene miedo).
El sistema preparará compilaciones binarias ClickHouse para su solicitud de extracción individualmente. Para recuperar estas compilaciones, haga clic en “Details” junto al enlace “ClickHouse build check” en la lista de cheques. Allí encontrará enlaces directos a la construcción.deb paquetes de ClickHouse que puede implementar incluso en sus servidores de producción (si no tiene miedo).
Lo más probable es que algunas de las compilaciones fallen las primeras veces. Esto se debe al hecho de que verificamos las compilaciones tanto con gcc como con clang, con casi todas las advertencias existentes (siempre con el `-Werror` bandera) habilitado para sonido. En esa misma página, puede encontrar todos los registros de compilación para que no tenga que compilar ClickHouse de todas las formas posibles.

28
docs/es/development/style.md
View File

@ -81,7 +81,7 @@ Si es necesario, el operador se puede envolver a la siguiente línea. En este ca
**11.** No utilice un espacio para separar los operadores unarios (`--`, `++`, `*`, `&`, …) del argumento.
**12.** Pon un espacio después de una coma, pero no antes. La misma regla se aplica a un punto y coma dentro de un `for` expresion.
**12.** Pon un espacio después de una coma, pero no antes. La misma regla se aplica a un punto y coma dentro de un `for` expresión.
**13.** No utilice espacios para separar el `[]` operador.
@ -93,7 +93,7 @@ struct AggregatedStatElement
{}
```
**15.** En clases y estructuras, escribe `public`, `private`, y `protected` en el mismo nivel que `class/struct`, y sangrar el resto del código.
**15.** En clases y estructuras, escribe `public`, `private`, y `protected` es el mismo nivel que `class/struct`, y sangrar el resto del código.
``` cpp
template <typename T>
@ -598,11 +598,11 @@ Las bibliotecas pequeñas tampoco necesitan esto.
Para bibliotecas medianas a grandes, coloque todo en un `namespace`.
En la biblioteca `.h` archivo, se puede utilizar `namespace detail` para ocultar los detalles de implementación no necesarios para el código de la aplicación.
En la biblioteca `.h` Archivo, se puede utilizar `namespace detail` para ocultar los detalles de implementación no necesarios para el código de la aplicación.
En un `.cpp` archivo, puede usar un `static` o espacio de nombres anónimo para ocultar símbolos.
Además, un `namespace` puede ser utilizado para un `enum` para evitar que los nombres correspondientes caigan en un `namespace` (pero es mejor usar un `enum class`).
Además, un `namespace` Puede ser utilizado para un `enum` para evitar que los nombres correspondientes caigan en un `namespace` (pero es mejor usar un `enum class`).
**16.** Inicialización diferida.
@ -623,7 +623,7 @@ Si la clase no está destinada para uso polimórfico, no necesita hacer que las
**18.** Codificación.
Usa UTF-8 en todas partes. Utilizar `std::string`y`char *`. No use `std::wstring`y`wchar_t`.
Usa UTF-8 en todas partes. Utilizar `std::string`y`char *`. No uso `std::wstring`y`wchar_t`.
**19.** Tala.
@ -649,7 +649,7 @@ Utilice la codificación UTF-8 en el registro. En casos excepcionales, puede usa
No utilice `iostreams` en ciclos internos que son críticos para el rendimiento de la aplicación (y nunca usan `stringstream`).
Utilice el `DB/IO` biblioteca en su lugar.
Descripción `DB/IO` biblioteca en su lugar.
**21.** Fecha y hora.
@ -663,7 +663,7 @@ Utilice siempre `#pragma once` en lugar de incluir guardias.
`using namespace` no se utiliza. Usted puede utilizar `using` con algo específico. Pero hazlo local dentro de una clase o función.
**24.** No use `trailing return type` para funciones a menos que sea necesario.
**24.** No uso `trailing return type` para funciones a menos que sea necesario.
``` cpp
[auto f() -&gt; void;]{.strike}
@ -680,7 +680,7 @@ std::string s{"Hello"};
auto s = std::string{"Hello"};
```
**26.** Para funciones virtuales, escriba `virtual` en la clase base, pero escribe `override` en lugar de `virtual` en las clases descendientes.
**26.** Para funciones virtuales, escriba `virtual` es la clase base, pero escribe `override` es lugar de `virtual` en las clases descendientes.
## Características no utilizadas de C ++ {#unused-features-of-c}
@ -694,7 +694,7 @@ auto s = std::string{"Hello"};
Pero en igualdad de condiciones, se prefiere el código multiplataforma o portátil.
**2.** Idioma: C ++ 17.
**2.** Idioma: hacer ++ 17.
**3.** Compilación: `gcc`. En este momento (diciembre de 2017), el código se compila utilizando la versión 7.2. (También se puede compilar usando `clang 4`.)
@ -718,7 +718,7 @@ El conjunto de instrucciones de CPU es el conjunto mínimo admitido entre nuestr
**2.** Para la depuración, use `gdb`, `valgrind` (`memcheck`), `strace`, `-fsanitize=...`, o `tcmalloc_minimal_debug`.
**3.** Para crear perfiles, use `Linux Perf`, `valgrind` (`callgrind`), o `strace -cf`.
**3.** Para crear perfiles, uso `Linux Perf`, `valgrind` (`callgrind`Ciudad `strace -cf`.
**4.** Las fuentes están en Git.
@ -774,17 +774,17 @@ Si ya hay una buena solución disponible, úsela, incluso si eso significa que d
**1.** Especificar explícitamente `std::` para tipos de `stddef.h`
no se recomienda. En otras palabras, recomendamos escribir `size_t` en su lugar `std::size_t` porque es más corto.
no se recomienda. En otras palabras, recomendamos escribir `size_t` es su lugar `std::size_t` porque es más corto.
Es aceptable agregar `std::`.
**2.** Especificar explícitamente `std::` para funciones de la biblioteca C estándar
no se recomienda. En otras palabras, escribir `memcpy` en lugar de `std::memcpy`.
no se recomienda. En otras palabras, escribir `memcpy` es lugar de `std::memcpy`.
La razón es que hay funciones no estándar similares, tales como `memmem`. Utilizamos estas funciones en ocasiones. Estas funciones no existen en `namespace std`.
Si usted escribe `std::memcpy` en lugar de `memcpy` en todas partes, entonces `memmem` sin `std::` se verá extraño.
Si usted escribe `std::memcpy` es lugar de `memcpy` es todas partes, entonces `memmem` pecado `std::` se verá extraño.
Sin embargo, todavía puedes usar `std::` si lo prefieres.
@ -792,7 +792,7 @@ Sin embargo, todavía puedes usar `std::` si lo prefieres.
Esto es aceptable si es más eficiente.
Por ejemplo, use `memcpy` en lugar de `std::copy` para copiar grandes trozos de memoria.
Por ejemplo, uso `memcpy` es lugar de `std::copy` para copiar grandes trozos de memoria.
**4.** Argumentos de función multilínea.

30
docs/es/development/tests.md
View File

@ -6,15 +6,15 @@ Las pruebas funcionales son las más simples y cómodas de usar. La mayoría de
Cada prueba funcional envía una o varias consultas al servidor ClickHouse en ejecución y compara el resultado con la referencia.
Las pruebas se encuentran en `dbms/tests/queries` directorio. Hay dos subdirectorios: `stateless` y `stateful`. Las pruebas sin estado ejecutan consultas sin datos de prueba precargados: a menudo crean pequeños conjuntos de datos sintéticos sobre la marcha, dentro de la prueba misma. Las pruebas estatales requieren datos de prueba precargados de Yandex.Métrica y no está disponible para el público en general. Tendemos a usar sólo `stateless` pruebas y evitar la adición de nuevos `stateful` prueba.
Las pruebas se encuentran en `dbms/tests/queries` Directorio. Hay dos subdirectorios: `stateless` y `stateful`. Las pruebas sin estado ejecutan consultas sin datos de prueba precargados: a menudo crean pequeños conjuntos de datos sintéticos sobre la marcha, dentro de la prueba misma. Las pruebas estatales requieren datos de prueba precargados de Yandex.Métrica y no está disponible para el público en general. Tendemos a usar sólo `stateless` pruebas y evitar la adición de nuevos `stateful` prueba.
Cada prueba puede ser de dos tipos: `.sql` y `.sh`. `.sql` test es el script SQL simple que se canaliza a `clickhouse-client --multiquery --testmode`. `.sh` test es un script que se ejecuta por sí mismo.
Cada prueba puede ser de dos tipos: `.sql` y `.sh`. `.sql` prueba es el script SQL simple que se canaliza a `clickhouse-client --multiquery --testmode`. `.sh` test es un script que se ejecuta por sí mismo.
Para ejecutar todas las pruebas, use `dbms/tests/clickhouse-test` herramienta. Mira `--help` para la lista de posibles opciones. Simplemente puede ejecutar todas las pruebas o ejecutar un subconjunto de pruebas filtradas por subcadena en el nombre de la prueba: `./clickhouse-test substring`.
La forma más sencilla de invocar pruebas funcionales es copiar `clickhouse-client` a `/usr/bin/`, ejecutar `clickhouse-server` y luego ejecutar `./clickhouse-test` de su propio directorio.
La forma más sencilla de invocar pruebas funcionales es copiar `clickhouse-client` Naciones `/usr/bin/`, ejecutar `clickhouse-server` y luego ejecutar `./clickhouse-test` de su propio directorio.
Para agregar una nueva prueba, cree un `.sql` o `.sh` archivo en `dbms/tests/queries/0_stateless` directorio, compruébelo manualmente y luego genere `.reference` archivo de la siguiente manera: `clickhouse-client -n --testmode < 00000_test.sql > 00000_test.reference` o `./00000_test.sh > ./00000_test.reference`.
Atracciones cercanas al hotel `.sql` o `.sh` archivo en `dbms/tests/queries/0_stateless` directorio, compruébelo manualmente y luego genere `.reference` archivo de la siguiente manera: `clickhouse-client -n --testmode < 00000_test.sql > 00000_test.reference` o `./00000_test.sh > ./00000_test.reference`.
Las pruebas deben usar (crear, soltar, etc.) solo tablas en `test` base de datos que se supone que se crea de antemano; también las pruebas pueden usar tablas temporales.
@ -22,12 +22,12 @@ Si desea utilizar consultas distribuidas en pruebas funcionales, puede aprovecha
Algunas pruebas están marcadas con `zookeeper`, `shard` o `long` en sus nombres.
`zookeeper` es para pruebas que están usando ZooKeeper. `shard` es para pruebas que
requiere servidor para escuchar `127.0.0.*`; `distributed` o `global` tienen el mismo
Requiere servidor para escuchar `127.0.0.*`; `distributed` o `global` Tienen el mismo
significado. `long` es para pruebas que duran un poco más de un segundo. Usted puede
deshabilitar estos grupos de pruebas utilizando `--no-zookeeper`, `--no-shard` y
Deshabilitar estos grupos de pruebas utilizando `--no-zookeeper`, `--no-shard` y
`--no-long` opciones, respectivamente.
## Bugs conocidos {#known-bugs}
## Errores conocidos {#known-bugs}
Si conocemos algunos errores que se pueden reproducir fácilmente mediante pruebas funcionales, colocamos pruebas funcionales preparadas en `dbms/tests/queries/bugs` directorio. Estas pruebas se moverán a `dbms/tests/queries/0_stateless` cuando se corrigen errores.
@ -55,11 +55,11 @@ Si desea mejorar el rendimiento de ClickHouse en algún escenario, y si se puede
## Herramientas de prueba y secuencias de comandos {#test-tools-and-scripts}
Algunos programas en `tests` directorio no son pruebas preparadas, pero son herramientas de prueba. Por ejemplo, para `Lexer` hay una herramienta `dbms/src/Parsers/tests/lexer` que solo hacen la tokenización de stdin y escriben el resultado coloreado en stdout. Puede usar este tipo de herramientas como ejemplos de código y para exploración y pruebas manuales.
Algunos programas en `tests` directorio no son pruebas preparadas, pero son herramientas de prueba. Por ejemplo, párr `Lexer` hay una herramienta `dbms/src/Parsers/tests/lexer` que solo hacen la tokenización de stdin y escriben el resultado coloreado en stdout. Puede usar este tipo de herramientas como ejemplos de código y para exploración y pruebas manuales.
También puede colocar un par de archivos `.sh` y `.reference` junto con la herramienta para ejecutarlo en alguna entrada predefinida, entonces el resultado del script se puede comparar con `.reference` file. Este tipo de pruebas no están automatizadas.
## Miscellanous Pruebas {#miscellanous-tests}
## Pruebas misceláneas {#miscellanous-tests}
Hay pruebas para diccionarios externos ubicados en `dbms/tests/external_dictionaries` y para modelos aprendidos a máquina en `dbms/tests/external_models`. Estas pruebas no se actualizan y deben transferirse a pruebas de integración.
@ -73,7 +73,7 @@ Cuando desarrolla una nueva característica, es razonable probarla también manu
Construir ClickHouse. Ejecute ClickHouse desde el terminal: cambie el directorio a `dbms/src/programs/clickhouse-server` y ejecutarlo con `./clickhouse-server`. Se utilizará la configuración (`config.xml`, `users.xml` y archivos dentro de `config.d` y `users.d` directorios) desde el directorio actual de forma predeterminada. Para conectarse al servidor ClickHouse, ejecute `dbms/src/programs/clickhouse-client/clickhouse-client`.
Tenga en cuenta que todas las herramientas de clickhouse (servidor, cliente, etc.) son solo enlaces simbólicos a un único binario llamado `clickhouse`. Puede encontrar este binario en `dbms/src/programs/clickhouse`. Todas las herramientas también se pueden invocar como `clickhouse tool` en lugar de `clickhouse-tool`.
Tenga en cuenta que todas las herramientas de clickhouse (servidor, cliente, etc.) son solo enlaces simbólicos a un único binario llamado `clickhouse`. Puede encontrar este binario en `dbms/src/programs/clickhouse`. Todas las herramientas también se pueden invocar como `clickhouse tool` es lugar de `clickhouse-tool`.
Alternativamente, puede instalar el paquete ClickHouse: ya sea una versión estable del repositorio de Yandex o puede crear un paquete para usted con `./release` en la raíz de fuentes de ClickHouse. Luego inicie el servidor con `sudo service clickhouse-server start` (o detener para detener el servidor). Busque registros en `/etc/clickhouse-server/clickhouse-server.log`.
@ -150,9 +150,9 @@ Normalmente lanzamos y ejecutamos todas las pruebas en una sola variante de comp
- construir en FreeBSD;
- construir en Debian con bibliotecas de paquetes del sistema;
- construir con enlaces compartidos de bibliotecas;
- Construir con enlaces compartidos de bibliotecas;
- construir en la plataforma AArch64;
- construir en la plataforma PowerPc.
- Construir en la plataforma PowerPc.
Por ejemplo, construir con paquetes del sistema es una mala práctica, porque no podemos garantizar qué versión exacta de paquetes tendrá un sistema. Pero esto es realmente necesario para los mantenedores de Debian. Por esta razón, al menos tenemos que admitir esta variante de construcción. Otro ejemplo: la vinculación compartida es una fuente común de problemas, pero es necesaria para algunos entusiastas.
@ -164,7 +164,7 @@ Cuando ampliamos el protocolo de red ClickHouse, probamos manualmente que el ant
## Ayuda del compilador {#help-from-the-compiler}
Código principal de ClickHouse (que se encuentra en `dbms` directorio) se construye con `-Wall -Wextra -Werror` y con algunas advertencias habilitadas adicionales. Aunque estas opciones no están habilitadas para bibliotecas de terceros.
Código principal de ClickHouse (que se encuentra en `dbms` Directorio) se construye con `-Wall -Wextra -Werror` y con algunas advertencias habilitadas adicionales. Aunque estas opciones no están habilitadas para bibliotecas de terceros.
Clang tiene advertencias aún más útiles: puedes buscarlas con `-Weverything` y elige algo para la compilación predeterminada.
@ -176,7 +176,7 @@ Para las compilaciones de producción, se usa gcc (todavía genera un código li
Ejecutamos pruebas funcionales y de integración bajo ASan por compromiso.
**Valgrind (Memcheck)**.
Realizamos pruebas funcionales bajo Valgrind durante la noche. Se tarda varias horas. Actualmente hay un falso positivo conocido en `re2` biblioteca, ver [este artículo](https://research.swtch.com/sparse).
Realizamos pruebas funcionales bajo Valgrind durante la noche. Se tarda varias horas. Actualmente hay un falso positivo conocido en `re2` Biblioteca, ver [este artículo](https://research.swtch.com/sparse).
**Desinfectante de comportamiento indefinido.**
Ejecutamos pruebas funcionales y de integración bajo ASan por compromiso.
@ -204,7 +204,7 @@ La gente del departamento de Yandex Cloud hace una visión general básica de la
Corremos `PVS-Studio` por compromiso. Hemos evaluado `clang-tidy`, `Coverity`, `cppcheck`, `PVS-Studio`, `tscancode`. Encontrará instrucciones de uso en `dbms/tests/instructions/` directorio. También puedes leer [el artículo en ruso](https://habr.com/company/yandex/blog/342018/).
Si usted usa `CLion` como IDE, puede aprovechar algunos `clang-tidy` comprueba fuera de la caja.
Si usted estados unidos `CLion` Como IDE, puede aprovechar algunos `clang-tidy` comprueba fuera de la caja.
## Endurecer {#hardening}

2
docs/es/faq/general.md
View File

@ -30,7 +30,7 @@ Por ejemplo:
SELECT * FROM table INTO OUTFILE 'file'
```
De forma predeterminada, ClickHouse usa el [TabSeparated](../interfaces/formats.md#tabseparated) formato de datos de salida. Para seleccionar el [formato de datos](../interfaces/formats.md), utilizar el [Cláusula FORMAT](../query_language/select/#format-clause).
De forma predeterminada, ClickHouse usa el [TabSeparated](../interfaces/formats.md#tabseparated) formato de datos de salida. Para seleccionar el [Formato de datos](../interfaces/formats.md), utilizar el [Cláusula FORMAT](../query_language/select/#format-clause).
Por ejemplo:

16
docs/es/getting_started/example_datasets/amplab_benchmark.md
View File

@ -1,10 +1,10 @@
# AMPLab Big Data Benchmark {#amplab-big-data-benchmark}
# Referencia de Big Data de AMPLab {#amplab-big-data-benchmark}
See https://amplab.cs.berkeley.edu/benchmark/
Ver https://amplab.cs.berkeley.edu/benchmark/
Sign up for a free account at https://aws.amazon.com. You will need a credit card, email and phone number. Get a new access key at https://console.aws.amazon.com/iam/home?nc2=h\_m\_sc\#security\_credential
Regístrese para obtener una cuenta gratuita en https://aws.amazon.com. Necesitará una tarjeta de crédito, correo electrónico y número de teléfono. Obtenga una nueva clave de acceso en https://console.aws.amazon.com/iam/home?nc2=h\_m\_sc\#security\_credential
Run the following in the console:
Ejecute lo siguiente en la consola:
``` bash
$ sudo apt-get install s3cmd
@ -19,7 +19,7 @@ $ s3cmd sync s3://big-data-benchmark/pavlo/text-deflate/5nodes/ .
$ cd ..
```
Run the following ClickHouse queries:
Ejecute las siguientes consultas de ClickHouse:
``` sql
CREATE TABLE rankings_tiny
@ -83,7 +83,7 @@ CREATE TABLE uservisits_5nodes_on_single
) ENGINE = MergeTree(visitDate, visitDate, 8192);
```
Go back to the console:
Volver a la consola:
``` bash
$ for i in tiny/rankings/*.deflate; do echo $i; zlib-flate -uncompress < $i | clickhouse-client --host=example-perftest01j --query="INSERT INTO rankings_tiny FORMAT CSV"; done
@ -94,7 +94,7 @@ $ for i in 5nodes/rankings/*.deflate; do echo $i; zlib-flate -uncompress < $i |
$ for i in 5nodes/uservisits/*.deflate; do echo $i; zlib-flate -uncompress < $i | clickhouse-client --host=example-perftest01j --query="INSERT INTO uservisits_5nodes_on_single FORMAT CSV"; done
```
Queries for obtaining data samples:
Consultas para obtener muestras de datos:
``` sql
SELECT pageURL, pageRank FROM rankings_1node WHERE pageRank > 1000
@ -119,4 +119,4 @@ ORDER BY totalRevenue DESC
LIMIT 1
```
[Original article](https://clickhouse.tech/docs/es/getting_started/example_datasets/amplab_benchmark/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/getting_started/example_datasets/amplab_benchmark/) <!--hide-->

14
docs/es/getting_started/example_datasets/criteo.md
View File

@ -1,20 +1,20 @@
# Terabyte of Click Logs from Criteo {#terabyte-of-click-logs-from-criteo}
# Terabyte de registros de clics de Criteo {#terabyte-of-click-logs-from-criteo}
Download the data from http://labs.criteo.com/downloads/download-terabyte-click-logs/
Descargue los datos de http://labs.criteo.com/downloads/download-terabyte-click-logs/
Create a table to import the log to:
Cree una tabla para importar el registro:
``` sql
CREATE TABLE criteo_log (date Date, clicked UInt8, int1 Int32, int2 Int32, int3 Int32, int4 Int32, int5 Int32, int6 Int32, int7 Int32, int8 Int32, int9 Int32, int10 Int32, int11 Int32, int12 Int32, int13 Int32, cat1 String, cat2 String, cat3 String, cat4 String, cat5 String, cat6 String, cat7 String, cat8 String, cat9 String, cat10 String, cat11 String, cat12 String, cat13 String, cat14 String, cat15 String, cat16 String, cat17 String, cat18 String, cat19 String, cat20 String, cat21 String, cat22 String, cat23 String, cat24 String, cat25 String, cat26 String) ENGINE = Log
```
Download the data:
Descargar los datos:
``` bash
$ for i in {00..23}; do echo $i; zcat datasets/criteo/day_${i#0}.gz | sed -r 's/^/2000-01-'${i/00/24}'\t/' | clickhouse-client --host=example-perftest01j --query="INSERT INTO criteo_log FORMAT TabSeparated"; done
```
Create a table for the converted data:
Crear una tabla para los datos convertidos:
``` sql
CREATE TABLE criteo
@ -63,7 +63,7 @@ CREATE TABLE criteo
) ENGINE = MergeTree(date, intHash32(icat1), (date, intHash32(icat1)), 8192)
```
Transform data from the raw log and put it in the second table:
Transforme los datos del registro sin procesar y colóquelos en la segunda tabla:
``` sql
INSERT INTO criteo SELECT date, clicked, int1, int2, int3, int4, int5, int6, int7, int8, int9, int10, int11, int12, int13, reinterpretAsUInt32(unhex(cat1)) AS icat1, reinterpretAsUInt32(unhex(cat2)) AS icat2, reinterpretAsUInt32(unhex(cat3)) AS icat3, reinterpretAsUInt32(unhex(cat4)) AS icat4, reinterpretAsUInt32(unhex(cat5)) AS icat5, reinterpretAsUInt32(unhex(cat6)) AS icat6, reinterpretAsUInt32(unhex(cat7)) AS icat7, reinterpretAsUInt32(unhex(cat8)) AS icat8, reinterpretAsUInt32(unhex(cat9)) AS icat9, reinterpretAsUInt32(unhex(cat10)) AS icat10, reinterpretAsUInt32(unhex(cat11)) AS icat11, reinterpretAsUInt32(unhex(cat12)) AS icat12, reinterpretAsUInt32(unhex(cat13)) AS icat13, reinterpretAsUInt32(unhex(cat14)) AS icat14, reinterpretAsUInt32(unhex(cat15)) AS icat15, reinterpretAsUInt32(unhex(cat16)) AS icat16, reinterpretAsUInt32(unhex(cat17)) AS icat17, reinterpretAsUInt32(unhex(cat18)) AS icat18, reinterpretAsUInt32(unhex(cat19)) AS icat19, reinterpretAsUInt32(unhex(cat20)) AS icat20, reinterpretAsUInt32(unhex(cat21)) AS icat21, reinterpretAsUInt32(unhex(cat22)) AS icat22, reinterpretAsUInt32(unhex(cat23)) AS icat23, reinterpretAsUInt32(unhex(cat24)) AS icat24, reinterpretAsUInt32(unhex(cat25)) AS icat25, reinterpretAsUInt32(unhex(cat26)) AS icat26 FROM criteo_log;
@ -71,4 +71,4 @@ INSERT INTO criteo SELECT date, clicked, int1, int2, int3, int4, int5, int6, int
DROP TABLE criteo_log;
```
[Original article](https://clickhouse.tech/docs/es/getting_started/example_datasets/criteo/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/getting_started/example_datasets/criteo/) <!--hide-->

24
docs/es/getting_started/example_datasets/metrica.md
View File

@ -1,12 +1,12 @@
# Anonymized Yandex.Metrica Data {#anonymized-yandex-metrica-data}
# Yandex anonimizado.Metrica Datos {#anonymized-yandex-metrica-data}
Dataset consists of two tables containing anonymized data about hits (`hits_v1`) and visits (`visits_v1`) of Yandex.Metrica. You can read more about Yandex.Metrica in [ClickHouse history](../../introduction/history.md) section.
El conjunto de datos consta de dos tablas que contienen datos anónimos sobre los hits (`hits_v1`) y visitas (`visits_v1`) el Yandex.Métrica. Puedes leer más sobre Yandex.Metrica en [Historial de ClickHouse](../../introduction/history.md) apartado.
The dataset consists of two tables, either of them can be downloaded as a compressed `tsv.xz` file or as prepared partitions. In addition to that, an extended version of the `hits` table containing 100 million rows is available as TSV at https://clickhouse-datasets.s3.yandex.net/hits/tsv/hits\_100m\_obfuscated\_v1.tsv.xz and as prepared partitions at https://clickhouse-datasets.s3.yandex.net/hits/partitions/hits\_100m\_obfuscated\_v1.tar.xz.
El conjunto de datos consta de dos tablas, cualquiera de ellas se puede descargar como `tsv.xz` o como particiones preparadas. Además, una versión extendida de la `hits` La tabla que contiene 100 millones de filas está disponible como TSV en https://clickhouse-datasets.s3.yandex.net/hits/tsv/hits\_100m\_obfuscated\_v1.tsv.xz y como particiones preparadas en https://clickhouse-datasets.s3.yandex.net/hits/partitions/hits\_100m\_obfuscated\_v1.tar.xz.
## Obtaining Tables from Prepared Partitions {#obtaining-tables-from-prepared-partitions}
## Obtención de tablas a partir de particiones preparadas {#obtaining-tables-from-prepared-partitions}
Download and import hits table:
Descargar e importar tabla de hits:
``` bash
curl -O https://clickhouse-datasets.s3.yandex.net/hits/partitions/hits_v1.tar
@ -16,7 +16,7 @@ sudo service clickhouse-server restart
clickhouse-client --query "SELECT COUNT(*) FROM datasets.hits_v1"
```
Download and import visits:
Descargar e importar visitas:
``` bash
curl -O https://clickhouse-datasets.s3.yandex.net/visits/partitions/visits_v1.tar
@ -26,9 +26,9 @@ sudo service clickhouse-server restart
clickhouse-client --query "SELECT COUNT(*) FROM datasets.visits_v1"
```
## Obtaining Tables from Compressed TSV File {#obtaining-tables-from-compressed-tsv-file}
## Obtención de tablas a partir de un archivo TSV comprimido {#obtaining-tables-from-compressed-tsv-file}
Download and import hits from compressed TSV file:
Descargar e importar hits desde un archivo TSV comprimido:
``` bash
curl https://clickhouse-datasets.s3.yandex.net/hits/tsv/hits_v1.tsv.xz | unxz --threads=`nproc` > hits_v1.tsv
@ -42,7 +42,7 @@ clickhouse-client --query "OPTIMIZE TABLE datasets.hits_v1 FINAL"
clickhouse-client --query "SELECT COUNT(*) FROM datasets.hits_v1"
```
Download and import visits from compressed tsv-file:
Descargue e importe visitas desde un archivo tsv comprimido:
``` bash
curl https://clickhouse-datasets.s3.yandex.net/visits/tsv/visits_v1.tsv.xz | unxz --threads=`nproc` > visits_v1.tsv
@ -56,8 +56,8 @@ clickhouse-client --query "OPTIMIZE TABLE datasets.visits_v1 FINAL"
clickhouse-client --query "SELECT COUNT(*) FROM datasets.visits_v1"
```
## Example Queries {#example-queries}
## Consultas de ejemplo {#example-queries}
[ClickHouse tutorial](../../getting_started/tutorial.md) is based on Yandex.Metrica dataset and the recommended way to get started with this dataset is to just go through tutorial.
[Tutorial de ClickHouse](../../getting_started/tutorial.md) se basa en Yandex.El conjunto de datos de Metrica y la forma recomendada de comenzar con este conjunto de datos es simplemente pasar por el tutorial.
Additional examples of queries to these tables can be found among [stateful tests](https://github.com/ClickHouse/ClickHouse/tree/master/dbms/tests/queries/1_stateful) of ClickHouse (they are named `test.hists` and `test.visits` there).
Se pueden encontrar ejemplos adicionales de consultas a estas tablas entre [pruebas estatales](https://github.com/ClickHouse/ClickHouse/tree/master/dbms/tests/queries/1_stateful) de ClickHouse (se nombran `test.hists` y `test.visits` Todos los derechos reservados.

132
docs/es/getting_started/example_datasets/nyc_taxi.md
View File

File diff suppressed because one or more lines are too long

58
docs/es/getting_started/example_datasets/ontime.md
View File

@ -1,13 +1,13 @@
# OnTime {#ontime}
# Un tiempo {#ontime}
This dataset can be obtained in two ways:
Este conjunto de datos se puede obtener de dos maneras:
- import from raw data
- download of prepared partitions
- importación de datos sin procesar
- descarga de particiones preparadas
## Import From Raw Data {#import-from-raw-data}
## Importar desde datos sin procesar {#import-from-raw-data}
Downloading data:
Descarga de datos:
``` bash
for s in `seq 1987 2018`
@ -19,9 +19,9 @@ done
done
```
(from https://github.com/Percona-Lab/ontime-airline-performance/blob/master/download.sh )
(a partir de https://github.com/Percona-Lab/ontime-airline-performance/blob/master/download.sh )
Creating a table:
Creación de una tabla:
``` sql
CREATE TABLE `ontime` (
@ -140,13 +140,13 @@ ORDER BY (Carrier, FlightDate)
SETTINGS index_granularity = 8192;
```
Loading data:
Carga de datos:
``` bash
$ for i in *.zip; do echo $i; unzip -cq $i '*.csv' | sed 's/\.00//g' | clickhouse-client --host=example-perftest01j --query="INSERT INTO ontime FORMAT CSVWithNames"; done
```
## Download of Prepared Partitions {#download-of-prepared-partitions}
## Descarga de Particiones Preparadas {#download-of-prepared-partitions}
``` bash
$ curl -O https://clickhouse-datasets.s3.yandex.net/ontime/partitions/ontime.tar
@ -156,10 +156,10 @@ $ sudo service clickhouse-server restart
$ clickhouse-client --query "select count(*) from datasets.ontime"
```
!!! info "Info"
If you will run the queries described below, you have to use the full table name, `datasets.ontime`.
!!! info "INFO"
Si va a ejecutar las consultas que se describen a continuación, debe usar el nombre completo de la tabla, `datasets.ontime`.
## Queries {#queries}
## Consulta {#queries}
Q0.
@ -173,7 +173,7 @@ FROM
);
```
Q1. The number of flights per day from the year 2000 to 2008
Q1. El número de vuelos por día desde el año 2000 hasta 2008
``` sql
SELECT DayOfWeek, count(*) AS c
@ -183,7 +183,7 @@ GROUP BY DayOfWeek
ORDER BY c DESC;
```
Q2. The number of flights delayed by more than 10 minutes, grouped by the day of the week, for 2000-2008
Preguntas frecuentes El número de vuelos retrasados por más de 10 minutos, agrupados por el día de la semana, para 2000-2008
``` sql
SELECT DayOfWeek, count(*) AS c
@ -193,7 +193,7 @@ GROUP BY DayOfWeek
ORDER BY c DESC;
```
Q3. The number of delays by the airport for 2000-2008
Q3. El número de retrasos por parte del aeropuerto para 2000-2008
``` sql
SELECT Origin, count(*) AS c
@ -204,7 +204,7 @@ ORDER BY c DESC
LIMIT 10;
```
Q4. The number of delays by carrier for 2007
Preguntas más frecuentes Número de retrasos por transportista para 2007
``` sql
SELECT Carrier, count(*)
@ -214,7 +214,7 @@ GROUP BY Carrier
ORDER BY count(*) DESC;
```
Q5. The percentage of delays by carrier for 2007
Q5. El porcentaje de retrasos por transportista para 2007
``` sql
SELECT Carrier, c, c2, c*100/c2 as c3
@ -240,7 +240,7 @@ JOIN
ORDER BY c3 DESC;
```
Better version of the same query:
Mejor versión de la misma consulta:
``` sql
SELECT Carrier, avg(DepDelay>10)*100 AS c3
@ -250,7 +250,7 @@ GROUP BY Carrier
ORDER BY c3 DESC
```
Q6. The previous request for a broader range of years, 2000-2008
¿Por qué? La solicitud anterior de una gama más amplia de años, 2000-2008
``` sql
SELECT Carrier, c, c2, c*100/c2 as c3
@ -276,7 +276,7 @@ JOIN
ORDER BY c3 DESC;
```
Better version of the same query:
Mejor versión de la misma consulta:
``` sql
SELECT Carrier, avg(DepDelay>10)*100 AS c3
@ -286,7 +286,7 @@ GROUP BY Carrier
ORDER BY c3 DESC;
```
Q7. Percentage of flights delayed for more than 10 minutes, by year
Preguntas frecuentes Porcentaje de vuelos retrasados por más de 10 minutos, por año
``` sql
SELECT Year, c1/c2
@ -310,7 +310,7 @@ JOIN
ORDER BY Year;
```
Better version of the same query:
Mejor versión de la misma consulta:
``` sql
SELECT Year, avg(DepDelay>10)*100
@ -319,7 +319,7 @@ GROUP BY Year
ORDER BY Year;
```
Q8. The most popular destinations by the number of directly connected cities for various year ranges
¿Por qué? Los destinos más populares por el número de ciudades conectadas directamente para varios rangos de año
``` sql
SELECT DestCityName, uniqExact(OriginCityName) AS u
@ -329,7 +329,7 @@ GROUP BY DestCityName
ORDER BY u DESC LIMIT 10;
```
Q9.
¿Por qué?
``` sql
SELECT Year, count(*) AS c1
@ -337,7 +337,7 @@ FROM ontime
GROUP BY Year;
```
Q10.
Preguntas frecuentes
``` sql
SELECT
@ -355,7 +355,7 @@ ORDER by rate DESC
LIMIT 1000;
```
Bonus:
Bono:
``` sql
SELECT avg(cnt)
@ -393,7 +393,7 @@ ORDER BY c DESC
LIMIT 10;
```
This performance test was created by Vadim Tkachenko. See:
Esta prueba de rendimiento fue creada por Vadim Tkachenko. Ver:
- https://www.percona.com/blog/2009/10/02/analyzing-air-traffic-performance-with-infobright-and-monetdb/
- https://www.percona.com/blog/2009/10/26/air-traffic-queries-in-luciddb/
@ -402,4 +402,4 @@ This performance test was created by Vadim Tkachenko. See:
- https://www.percona.com/blog/2016/01/07/apache-spark-with-air-ontime-performance-data/
- http://nickmakos.blogspot.ru/2012/08/analyzing-air-traffic-performance-with.html
[Original article](https://clickhouse.tech/docs/es/getting_started/example_datasets/ontime/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/getting_started/example_datasets/ontime/) <!--hide-->

46
docs/es/getting_started/example_datasets/star_schema.md
View File

@ -1,6 +1,6 @@
# Star Schema Benchmark {#star-schema-benchmark}
# Estrella Schema Benchmark {#star-schema-benchmark}
Compiling dbgen:
Compilación de dbgen:
``` bash
$ git clone git@github.com:vadimtk/ssb-dbgen.git
@ -8,10 +8,10 @@ $ cd ssb-dbgen
$ make
```
Generating data:
Generación de datos:
!!! warning "Attention"
With `-s 100` dbgen generates 600 million rows (67 GB), while while `-s 1000` it generates 6 billion rows (which takes a lot of time)
!!! warning "Atención"
Desventaja `-s 100` dbgen genera 600 millones de filas (67 GB), mientras que `-s 1000` genera 6 mil millones de filas (lo que lleva mucho tiempo)
``` bash
$ ./dbgen -s 1000 -T c
@ -21,7 +21,7 @@ $ ./dbgen -s 1000 -T s
$ ./dbgen -s 1000 -T d
```
Creating tables in ClickHouse:
Creación de tablas en ClickHouse:
``` sql
CREATE TABLE customer
@ -86,7 +86,7 @@ CREATE TABLE supplier
ENGINE = MergeTree ORDER BY S_SUPPKEY;
```
Inserting data:
Inserte datos:
``` bash
$ clickhouse-client --query "INSERT INTO customer FORMAT CSV" < customer.tbl
@ -95,7 +95,7 @@ $ clickhouse-client --query "INSERT INTO supplier FORMAT CSV" < supplier.tbl
$ clickhouse-client --query "INSERT INTO lineorder FORMAT CSV" < lineorder.tbl
```
Converting “star schema” to denormalized “flat schema”:
Conversión “star schema” a desnormalizado “flat schema”:
``` sql
SET max_memory_usage = 20000000000;
@ -149,9 +149,9 @@ INNER JOIN supplier AS s ON s.S_SUPPKEY = l.LO_SUPPKEY
INNER JOIN part AS p ON p.P_PARTKEY = l.LO_PARTKEY;
```
Running the queries:
Las consultas:
Q1.1
Número de teléfono
``` sql
SELECT sum(LO_EXTENDEDPRICE * LO_DISCOUNT) AS revenue
@ -159,7 +159,7 @@ FROM lineorder_flat
WHERE toYear(LO_ORDERDATE) = 1993 AND LO_DISCOUNT BETWEEN 1 AND 3 AND LO_QUANTITY < 25;
```
Q1.2
¿Qué puedes encontrar en Neodigit
``` sql
SELECT sum(LO_EXTENDEDPRICE * LO_DISCOUNT) AS revenue
@ -167,7 +167,7 @@ FROM lineorder_flat
WHERE toYYYYMM(LO_ORDERDATE) = 199401 AND LO_DISCOUNT BETWEEN 4 AND 6 AND LO_QUANTITY BETWEEN 26 AND 35;
```
Q1.3
¿Qué puedes encontrar en Neodigit
``` sql
SELECT sum(LO_EXTENDEDPRICE * LO_DISCOUNT) AS revenue
@ -176,7 +176,7 @@ WHERE toISOWeek(LO_ORDERDATE) = 6 AND toYear(LO_ORDERDATE) = 1994
AND LO_DISCOUNT BETWEEN 5 AND 7 AND LO_QUANTITY BETWEEN 26 AND 35;
```
Q2.1
Preguntas frecuentes
``` sql
SELECT
@ -193,7 +193,7 @@ ORDER BY
P_BRAND;
```
Q2.2
Preguntas frecuentes
``` sql
SELECT
@ -210,7 +210,7 @@ ORDER BY
P_BRAND;
```
Q2.3
Preguntas más frecuentes
``` sql
SELECT
@ -227,7 +227,7 @@ ORDER BY
P_BRAND;
```
Q3.1
¿Qué puedes encontrar en Neodigit
``` sql
SELECT
@ -246,7 +246,7 @@ ORDER BY
revenue DESC;
```
Q3.2
¿Qué puedes encontrar en Neodigit
``` sql
SELECT
@ -265,7 +265,7 @@ ORDER BY
revenue DESC;
```
Q3.3
¿Qué puedes encontrar en Neodigit
``` sql
SELECT
@ -284,7 +284,7 @@ ORDER BY
revenue DESC;
```
Q3.4
¿Qué puedes encontrar en Neodigit
``` sql
SELECT
@ -303,7 +303,7 @@ ORDER BY
revenue DESC;
```
Q4.1
Preguntas más frecuentes
``` sql
SELECT
@ -320,7 +320,7 @@ ORDER BY
C_NATION ASC;
```
Q4.2
Preguntas más frecuentes
``` sql
SELECT
@ -340,7 +340,7 @@ ORDER BY
P_CATEGORY ASC;
```
Q4.3
Preguntas más frecuentes
``` sql
SELECT
@ -360,4 +360,4 @@ ORDER BY
P_BRAND ASC;
```
[Original article](https://clickhouse.tech/docs/es/getting_started/example_datasets/star_schema/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/getting_started/example_datasets/star_schema/) <!--hide-->

10
docs/es/getting_started/example_datasets/wikistat.md
View File

@ -1,8 +1,8 @@
# WikiStat {#wikistat}
# Nombre de la red inalámbrica (SSID): {#wikistat}
See: http://dumps.wikimedia.org/other/pagecounts-raw/
Ver: http://dumps.wikimedia.org/other/pagecounts-raw/
Creating a table:
Creación de una tabla:
``` sql
CREATE TABLE wikistat
@ -17,7 +17,7 @@ CREATE TABLE wikistat
) ENGINE = MergeTree(date, (path, time), 8192);
```
Loading data:
Carga de datos:
``` bash
$ for i in {2007..2016}; do for j in {01..12}; do echo $i-$j >&2; curl -sSL "http://dumps.wikimedia.org/other/pagecounts-raw/$i/$i-$j/" | grep -oE 'pagecounts-[0-9]+-[0-9]+\.gz'; done; done | sort | uniq | tee links.txt
@ -25,4 +25,4 @@ $ cat links.txt | while read link; do wget http://dumps.wikimedia.org/other/page
$ ls -1 /opt/wikistat/ | grep gz | while read i; do echo $i; gzip -cd /opt/wikistat/$i | ./wikistat-loader --time="$(echo -n $i | sed -r 's/pagecounts-([0-9]{4})([0-9]{2})([0-9]{2})-([0-9]{2})([0-9]{2})([0-9]{2})\.gz/\1-\2-\3 \4-00-00/')" | clickhouse-client --query="INSERT INTO wikistat FORMAT TabSeparated"; done
```
[Original article](https://clickhouse.tech/docs/es/getting_started/example_datasets/wikistat/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/getting_started/example_datasets/wikistat/) <!--hide-->

10
docs/es/getting_started/index.md
View File

@ -1,8 +1,8 @@
# Getting Started {#getting-started}
# Primeros pasos {#getting-started}
If you are new to ClickHouse and want to get a hands-on feeling of its performance, first of all, you need to go through the [installation process](install.md). After that you can:
Si eres nuevo en ClickHouse y quieres tener una sensación práctica de su rendimiento, antes que nada, debes pasar por el [proceso de instalación](install.md). Después de eso puedes:
- [Go through detailed tutorial](tutorial.md)
- [Experiment with example datasets](example_datasets/ontime.md)
- [Ir a través de tutorial detallado](tutorial.md)
- [Experimente con conjuntos de datos de ejemplo](example_datasets/ontime.md)
[Original article](https://clickhouse.tech/docs/es/getting_started/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/getting_started/) <!--hide-->

104
docs/es/getting_started/install.md
View File

@ -1,30 +1,30 @@
# Installation {#installation}
# Instalación {#installation}
## System Requirements {#system-requirements}
## Requisitos del sistema {#system-requirements}
ClickHouse can run on any Linux, FreeBSD or Mac OS X with x86\_64, AArch64 or PowerPC64LE CPU architecture.
ClickHouse puede ejecutarse en cualquier Linux, FreeBSD o Mac OS X con arquitectura de CPU x86\_64, AArch64 o PowerPC64LE.
Official pre-built binaries are typically compiled for x86\_64 and leverage SSE 4.2 instruction set, so unless otherwise stated usage of CPU that supports it becomes an additional system requirement. Here’s the command to check if current CPU has support for SSE 4.2:
Los binarios oficiales preconstruidos generalmente se compilan para x86\_64 y aprovechan el conjunto de instrucciones SSE 4.2, por lo que, a menos que se indique lo contrario, el uso de la CPU que lo admite se convierte en un requisito adicional del sistema. Aquí está el comando para verificar si la CPU actual tiene soporte para SSE 4.2:
``` bash
$ grep -q sse4_2 /proc/cpuinfo && echo "SSE 4.2 supported" || echo "SSE 4.2 not supported"
```
To run ClickHouse on processors that do not support SSE 4.2 or have AArch64 or PowerPC64LE architecture, you should [build ClickHouse from sources](#from-sources) with proper configuration adjustments.
Para ejecutar ClickHouse en procesadores que no admiten SSE 4.2 o tienen arquitectura AArch64 o PowerPC64LE, debe [Construir ClickHouse a partir de fuentes](#from-sources) con los ajustes de configuración adecuados.
## Available Installation Options {#available-installation-options}
## Opciones de instalación disponibles {#available-installation-options}
### From DEB Packages {#install-from-deb-packages}
### De paquetes DEB {#install-from-deb-packages}
It is recommended to use official pre-compiled `deb` packages for Debian or Ubuntu.
Se recomienda utilizar pre-compilado oficial `deb` " resultados de la búsqueda relacionados
To install official packages add the Yandex repository in `/etc/apt/sources.list` or in a separate `/etc/apt/sources.list.d/clickhouse.list` file:
Para instalar paquetes oficiales, agregue el repositorio de Yandex en `/etc/apt/sources.list` o en otra `/etc/apt/sources.list.d/clickhouse.list` file:
deb http://repo.clickhouse.tech/deb/stable/ main/
If you want to use the most recent version, replace `stable` with `testing` (this is recommended for your testing environments).
Si desea utilizar la versión más reciente, reemplace `stable` desventaja `testing` (esto se recomienda para sus entornos de prueba).
Then run these commands to actually install packages:
A continuación, ejecute estos comandos para instalar realmente los paquetes:
``` bash
sudo apt-get install dirmngr # optional
@ -33,20 +33,20 @@ sudo apt-get update
sudo apt-get install clickhouse-client clickhouse-server
```
You can also download and install packages manually from here: https://repo.yandex.ru/clickhouse/deb/stable/main/.
También puede descargar e instalar paquetes manualmente desde aquí: https://repo.yandex.ru/clickhouse/deb/stable/main/.
#### Packages {#packages}
#### Paquete {#packages}
- `clickhouse-common-static` — Installs ClickHouse compiled binary files.
- `clickhouse-server` — Creates a symbolic link for `clickhouse-server`. Installs server configuration.
- `clickhouse-client` — Creates a symbolic link for `clickhouse-client` and other client-related tools. Installs client configurations.
- `clickhouse-server` — Creates a symbolic link for `clickhouse-server`. Instala la configuración del servidor.
- `clickhouse-client` — Creates a symbolic link for `clickhouse-client` y otras herramientas relacionadas con el cliente. Instala configuraciones de cliente.
- `clickhouse-common-static-dbg` — Installs ClickHouse compiled binary files with debug info.
### From RPM Packages {#from-rpm-packages}
### De paquetes RPM {#from-rpm-packages}
It is recommended to use official pre-compiled `rpm` packages for CentOS, RedHat and all other rpm-based Linux distributions.
Se recomienda utilizar pre-compilado oficial `rpm` paquetes para CentOS, RedHat y todas las demás distribuciones de Linux basadas en rpm.
First, you need to add the official repository:
Primero, necesitas agregar el repositorio oficial:
``` bash
sudo yum install yum-utils
@ -54,22 +54,22 @@ sudo rpm --import https://repo.clickhouse.tech/CLICKHOUSE-KEY.GPG
sudo yum-config-manager --add-repo https://repo.clickhouse.tech/rpm/stable/x86_64
```
If you want to use the most recent version, replace `stable` with `testing` (this is recommended for your testing environments). The `prestable` tag is sometimes available too.
Si desea utilizar la versión más reciente, reemplace `stable` desventaja `testing` (esto se recomienda para sus entornos de prueba). El `prestable` etiqueta a veces está disponible también.
Then run these commands to install packages:
A continuación, ejecute estos comandos para instalar paquetes:
``` bash
sudo yum install clickhouse-server clickhouse-client
```
You can also download and install packages manually from here: https://repo.clickhouse.tech/rpm/stable/x86\_64.
También puede descargar e instalar paquetes manualmente desde aquí: https://repo.casa de clic.tecnología / rpm / estable / x86\_64.
### From tgz archives {#from-tgz-archives}
### De archivos tgz {#from-tgz-archives}
It is recommended to use official pre-compiled `tgz` archives for all Linux distributions, where installation of `deb` or `rpm` packages is not possible.
Se recomienda utilizar pre-compilado oficial `tgz` para todas las distribuciones de Linux, donde la instalación de `deb` o `rpm` paquetes no es posible.
The required version can be downloaded with `curl` or `wget` from repository https://repo.yandex.ru/clickhouse/tgz/.
After that downloaded archives should be unpacked and installed with installation scripts. Example for the latest version:
La versión requerida se puede descargar con `curl` o `wget` desde el repositorio https://repo.yandex.ru/clickhouse/tgz/.
Después de eso, los archivos descargados deben desempaquetarse e instalarse con scripts de instalación. Ejemplo para la última versión:
``` bash
export LATEST_VERSION=`curl https://api.github.com/repos/ClickHouse/ClickHouse/tags 2>/dev/null | grep -Eo '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' | head -n 1`
@ -92,71 +92,71 @@ tar -xzvf clickhouse-client-$LATEST_VERSION.tgz
sudo clickhouse-client-$LATEST_VERSION/install/doinst.sh
```
For production environments, it’s recommended to use the latest `stable`-version. You can find its number on GitHub page https://github.com/ClickHouse/ClickHouse/tags with postfix `-stable`.
Para los entornos de producción, se recomienda utilizar las últimas `stable`-versión. Puede encontrar su número en la página de GitHub https://github.com/ClickHouse/ClickHouse/tags con postfix `-stable`.
### From Docker Image {#from-docker-image}
### Imagen de Desde Docker {#from-docker-image}
To run ClickHouse inside Docker follow the guide on [Docker Hub](https://hub.docker.com/r/yandex/clickhouse-server/). Those images use official `deb` packages inside.
Para ejecutar ClickHouse dentro de Docker, siga la guía en [Eje de acoplador](https://hub.docker.com/r/yandex/clickhouse-server/). Esas imágenes usan oficial `deb` paquetes dentro.
### From Sources {#from-sources}
### De fuentes {#from-sources}
To manually compile ClickHouse, follow the instructions for [Linux](../development/build.md) or [Mac OS X](../development/build_osx.md).
Para compilar manualmente ClickHouse, siga las instrucciones para [Linux](../development/build.md) o [Mac OS X](../development/build_osx.md).
You can compile packages and install them or use programs without installing packages. Also by building manually you can disable SSE 4.2 requirement or build for AArch64 CPUs.
Puede compilar paquetes e instalarlos o usar programas sin instalar paquetes. Además, al construir manualmente, puede deshabilitar el requisito de SSE 4.2 o compilar para CPU AArch64.
Client: dbms/programs/clickhouse-client
Server: dbms/programs/clickhouse-server
You’ll need to create a data and metadata folders and `chown` them for the desired user. Their paths can be changed in server config (src/dbms/programs/server/config.xml), by default they are:
Tendrá que crear carpetas de datos y metadatos y `chown` para el usuario deseado. Sus rutas se pueden cambiar en la configuración del servidor (src/dbms/programs/server/config .xml), por defecto son:
/opt/clickhouse/data/default/
/opt/clickhouse/metadata/default/
On Gentoo, you can just use `emerge clickhouse` to install ClickHouse from sources.
En Gentoo, puedes usar `emerge clickhouse` para instalar ClickHouse desde fuentes.
## Launch {#launch}
## Lanzar {#launch}
To start the server as a daemon, run:
Para iniciar el servidor como demonio, ejecute:
``` bash
$ sudo service clickhouse-server start
```
If you don’t have `service` command, run as
Si no tienes `service` comando ejecutar como
``` bash
$ sudo /etc/init.d/clickhouse-server start
```
See the logs in the `/var/log/clickhouse-server/` directory.
Vea los registros en el `/var/log/clickhouse-server/` Directorio.
If the server doesn’t start, check the configurations in the file `/etc/clickhouse-server/config.xml`.
Si el servidor no se inicia, compruebe las configuraciones en el archivo `/etc/clickhouse-server/config.xml`.
You can also manually launch the server from the console:
También puede iniciar manualmente el servidor desde la consola:
``` bash
$ clickhouse-server --config-file=/etc/clickhouse-server/config.xml
```
In this case, the log will be printed to the console, which is convenient during development.
If the configuration file is in the current directory, you don’t need to specify the `--config-file` parameter. By default, it uses `./config.xml`.
En este caso, el registro se imprimirá en la consola, lo cual es conveniente durante el desarrollo.
Si el archivo de configuración está en el directorio actual, no es necesario `--config-file` parámetro. De forma predeterminada, utiliza `./config.xml`.
ClickHouse supports access restriction settings. They are located in the `users.xml` file (next to `config.xml`).
By default, access is allowed from anywhere for the `default` user, without a password. See `user/default/networks`.
For more information, see the section [“Configuration Files”](../operations/configuration_files.md).
ClickHouse admite la configuración de restricción de acceso. Están ubicados en el `users.xml` Archivo (junto a `config.xml`).
De forma predeterminada, se permite el acceso desde cualquier lugar `default` usuario, sin una contraseña. Ver `user/default/networks`.
Para obtener más información, consulte la sección [“Configuration Files”](../operations/configuration_files.md).
After launching server, you can use the command-line client to connect to it:
Después de iniciar el servidor, puede usar el cliente de línea de comandos para conectarse a él:
``` bash
$ clickhouse-client
```
By default, it connects to `localhost:9000` on behalf of the user `default` without a password. It can also be used to connect to a remote server using `--host` argument.
Por defecto, se conecta a `localhost:9000` es nombre del usuario `default` sin una contraseña. También se puede usar para conectarse a un servidor remoto usando `--host` argumento.
The terminal must use UTF-8 encoding.
For more information, see the section [“Command-line client”](../interfaces/cli.md).
El terminal debe usar codificación UTF-8.
Para obtener más información, consulte la sección [“Command-line client”](../interfaces/cli.md).
Example:
Ejemplo:
``` bash
$ ./clickhouse-client
@ -177,8 +177,8 @@ SELECT 1
:)
```
**Congratulations, the system works!**
**Felicidades, el sistema funciona!**
To continue experimenting, you can download one of the test data sets or go through [tutorial](https://clickhouse.tech/tutorial.html).
Para continuar experimentando, puede descargar uno de los conjuntos de datos de prueba o pasar por [tutorial](https://clickhouse.tech/tutorial.html).
[Original article](https://clickhouse.tech/docs/es/getting_started/install/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/getting_started/install/) <!--hide-->

144
docs/es/getting_started/tutorial.md
View File

@ -1,14 +1,14 @@
# ClickHouse Tutorial {#clickhouse-tutorial}
# Tutorial de ClickHouse {#clickhouse-tutorial}
## What to Expect from This Tutorial? {#what-to-expect-from-this-tutorial}
## Qué Esperar de Este Tutorial? {#what-to-expect-from-this-tutorial}
By going through this tutorial you’ll learn how to set up basic ClickHouse cluster, it’ll be small, but fault-tolerant and scalable. We will use one of the example datasets to fill it with data and execute some demo queries.
Al pasar por este tutorial, aprenderá cómo configurar el clúster básico de ClickHouse, será pequeño, pero tolerante a fallos y escalable. Usaremos uno de los conjuntos de datos de ejemplo para llenarlo con datos y ejecutar algunas consultas de demostración.
## Single Node Setup {#single-node-setup}
## Configuración de nodo único {#single-node-setup}
To postpone complexities of distributed environment, we’ll start with deploying ClickHouse on a single server or virtual machine. ClickHouse is usually installed from [deb](index.md#install-from-deb-packages) or [rpm](index.md#from-rpm-packages) packages, but there are [alternatives](index.md#from-docker-image) for the operating systems that do no support them.
Para posponer las complejidades del entorno distribuido, comenzaremos con la implementación de ClickHouse en un único servidor o máquina virtual. ClickHouse generalmente se instala desde [deb](index.md#install-from-deb-packages) o [RPM](index.md#from-rpm-packages) paquetes, pero hay [alternativa](index.md#from-docker-image) para los sistemas operativos que no los admiten.
For example, you have chosen `deb` packages and executed:
Por ejemplo, ha elegido `deb` paquetes y ejecutado:
``` bash
sudo apt-get install dirmngr
@ -20,48 +20,48 @@ sudo apt-get update
sudo apt-get install -y clickhouse-server clickhouse-client
```
What do we have in the packages that got installed:
¿Qué tenemos en los paquetes que tengo instalados:
- `clickhouse-client` package contains [clickhouse-client](../interfaces/cli.md) application, interactive ClickHouse console client.
- `clickhouse-common` package contains a ClickHouse executable file.
- `clickhouse-server` package contains configuration files to run ClickHouse as a server.
- `clickhouse-client` el paquete contiene [Casa de clics-cliente](../interfaces/cli.md) aplicación, cliente interactivo de la consola ClickHouse.
- `clickhouse-common` El paquete contiene un archivo ejecutable ClickHouse.
- `clickhouse-server` El paquete contiene archivos de configuración para ejecutar ClickHouse como servidor.
Server config files are located in `/etc/clickhouse-server/`. Before going further please notice the `<path>` element in `config.xml`. Path determines the location for data storage, so it should be located on volume with large disk capacity, the default value is `/var/lib/clickhouse/`. If you want to adjust the configuration it’s not handy to directly edit `config.xml` file, considering it might get rewritten on future package updates. The recommended way to override the config elements is to create [files in config.d directory](../operations/configuration_files.md) which serve as “patches” to config.xml.
Los archivos de configuración del servidor se encuentran en `/etc/clickhouse-server/`. Antes de ir más lejos, tenga en cuenta el `<path>` elemento en `config.xml`. La ruta determina la ubicación para el almacenamiento de datos, por lo que debe ubicarse en un volumen con gran capacidad de disco, el valor predeterminado es `/var/lib/clickhouse/`. Si desea ajustar la configuración, no es útil editar directamente `config.xml` archivo, teniendo en cuenta que podría ser reescrito en futuras actualizaciones de paquetes. La forma recomendada de anular los elementos de configuración es crear [archivos en config.directorio d](../operations/configuration_files.md) que sirven como “patches” de configuración.XML.
As you might have noticed, `clickhouse-server` is not launched automatically after package installation. It won’t be automatically restarted after updates either. The way you start the server depends on your init system, usually, it’s:
Como habrás notado, `clickhouse-server` no se inicia automáticamente después de la instalación del paquete. Tampoco se reiniciará automáticamente después de las actualizaciones. La forma en que inicia el servidor depende de su sistema de inicio, generalmente, es:
``` bash
sudo service clickhouse-server start
```
or
o
``` bash
sudo /etc/init.d/clickhouse-server start
```
The default location for server logs is `/var/log/clickhouse-server/`. The server will be ready to handle client connections once `Ready for connections` message was logged.
La ubicación predeterminada para los registros del servidor es `/var/log/clickhouse-server/`. El servidor estará listo para manejar las conexiones de cliente una vez `Ready for connections` se registró el mensaje.
Once the `clickhouse-server` is up and running, we can use `clickhouse-client` to connect to the server and run some test queries like `SELECT "Hello, world!";`.
Una vez que el `clickhouse-server` está en funcionamiento, podemos usar `clickhouse-client` para conectarse al servidor y ejecutar algunas consultas de prueba como `SELECT "Hello, world!";`.
<details markdown="1">
<summary>Quick tips for clickhouse-client</summary>
Interactive mode:
<summary>Consejos rápidos para clickhouse-cliente</summary>
Modo interactivo:
``` bash
clickhouse-client
clickhouse-client --host=... --port=... --user=... --password=...
```
Enable multiline queries:
Habilitar consultas multilínea:
``` bash
clickhouse-client -m
clickhouse-client --multiline
```
Run queries in batch-mode:
Ejecutar consultas en modo por lotes:
``` bash
clickhouse-client --query='SELECT 1'
@ -69,7 +69,7 @@ echo 'SELECT 1' | clickhouse-client
clickhouse-client <<< 'SELECT 1'
```
Insert data from a file in specified format:
Insertar datos de un archivo en el formato especificado:
``` bash
clickhouse-client --query='INSERT INTO table VALUES' < data.txt
@ -78,39 +78,39 @@ clickhouse-client --query='INSERT INTO table FORMAT TabSeparated' < data.tsv
</details>
## Import Sample Dataset {#import-sample-dataset}
## Importar conjunto de datos de muestra {#import-sample-dataset}
Now it’s time to fill our ClickHouse server with some sample data. In this tutorial, we’ll use anonymized data of Yandex.Metrica, the first service that runs ClickHouse in production way before it became open-source (more on that in [history section](../introduction/history.md)). There are [multiple ways to import Yandex.Metrica dataset](example_datasets/metrica.md) and for the sake of the tutorial, we’ll go with the most realistic one.
Ahora es el momento de llenar nuestro servidor ClickHouse con algunos datos de muestra. En este tutorial, usaremos datos anónimos de Yandex.Metrica, el primer servicio que ejecuta ClickHouse en forma de producción antes de que se convirtiera en código abierto (más sobre eso en [sección de historia](../introduction/history.md)). Hay [múltiples formas de importar Yandex.Conjunto de datos de Metrica](example_datasets/metrica.md) y por el bien del tutorial, iremos con el más realista.
### Download and Extract Table Data {#download-and-extract-table-data}
### Descargar y extraer datos de tabla {#download-and-extract-table-data}
``` bash
curl https://clickhouse-datasets.s3.yandex.net/hits/tsv/hits_v1.tsv.xz | unxz --threads=`nproc` > hits_v1.tsv
curl https://clickhouse-datasets.s3.yandex.net/visits/tsv/visits_v1.tsv.xz | unxz --threads=`nproc` > visits_v1.tsv
```
The extracted files are about 10GB in size.
Los archivos extraídos tienen un tamaño de aproximadamente 10 GB.
### Create Tables {#create-tables}
### Crear tablas {#create-tables}
Tables are logically grouped into “databases”. There’s a `default` database, but we’ll create a new one named `tutorial`:
Las tablas se agrupan lógicamente en “databases”. Hay un `default` base de datos, pero crearemos una nueva llamada `tutorial`:
``` bash
clickhouse-client --query "CREATE DATABASE IF NOT EXISTS tutorial"
```
Syntax for creating tables is way more complicated compared to databases (see [reference](../query_language/create.md). In general `CREATE TABLE` statement has to specify three key things:
La sintaxis para crear tablas es mucho más complicada en comparación con las bases de datos (ver [referencia](../query_language/create.md). En general `CREATE TABLE` declaración tiene que especificar tres cosas clave:
1. Name of table to create.
2. Table schema, i.e. list of columns and their [data types](../data_types/index.md).
3. [Table engine](../operations/table_engines/index.md) and it’s settings, which determines all the details on how queries to this table will be physically executed.
1. Nombre de la tabla que se va a crear.
2. Table schema, i.e. list of columns and their [tipos de datos](../data_types/index.md).
3. [Motor de tabla](../operations/table_engines/index.md) y su configuración, que determina todos los detalles sobre cómo se ejecutarán físicamente las consultas a esta tabla.
Yandex.Metrica is a web analytics service and sample dataset doesn’t cover its full functionality, so there are only two tables to create:
El Yandex.Metrica es un servicio de análisis web y el conjunto de datos de muestra no cubre toda su funcionalidad, por lo que solo hay dos tablas para crear:
- `hits` is a table with each action done by all users on all websites covered by the service.
- `visits` is a table that contains pre-built sessions instead of individual actions.
- `hits` es una tabla con cada acción realizada por todos los usuarios en todos los sitios web cubiertos por el servicio.
- `visits` es una tabla que contiene sesiones precompiladas en lugar de acciones individuales.
Let’s see and execute the real create table queries for these tables:
Veamos y ejecutemos las consultas de tabla de creación real para estas tablas:
``` sql
CREATE TABLE tutorial.hits_v1
@ -453,22 +453,22 @@ SAMPLE BY intHash32(UserID)
SETTINGS index_granularity = 8192
```
You can execute those queries using the interactive mode of `clickhouse-client` (just launch it in a terminal without specifying a query in advance) or try some [alternative interface](../interfaces/index.md) if you want.
Puede ejecutar esas consultas utilizando el modo interactivo de `clickhouse-client` (simplemente ejecútelo en un terminal sin especificar una consulta por adelantado) o pruebe algunos [interfaz alternativa](../interfaces/index.md) Si quieres.
As we can see, `hits_v1` uses the [basic MergeTree engine](../operations/table_engines/mergetree.md), while the `visits_v1` uses the [Collapsing](../operations/table_engines/collapsingmergetree.md) variant.
Como podemos ver, `hits_v1` utiliza el [motor básico MergeTree](../operations/table_engines/mergetree.md), mientras que el `visits_v1` utiliza el [Derrumbar](../operations/table_engines/collapsingmergetree.md) variante.
### Import Data {#import-data}
### Importar datos {#import-data}
Data import to ClickHouse is done via [INSERT INTO](../query_language/insert_into.md) query like in many other SQL databases. However data is usually provided in one of the [supported formats](../interfaces/formats.md) instead of `VALUES` clause (which is also supported).
La importación de datos a ClickHouse se realiza a través de [INSERTAR EN](../query_language/insert_into.md) consulta como en muchas otras bases de datos SQL. Sin embargo, los datos generalmente se proporcionan en uno de los [Formatos soportados](../interfaces/formats.md) en lugar de `VALUES` cláusula (que también es compatible).
The files we downloaded earlier are in tab-separated format, so here’s how to import them via console client:
Los archivos que descargamos anteriormente están en formato separado por tabuladores, así que aquí le mostramos cómo importarlos a través del cliente de la consola:
``` bash
clickhouse-client --query "INSERT INTO tutorial.hits_v1 FORMAT TSV" --max_insert_block_size=100000 < hits_v1.tsv
clickhouse-client --query "INSERT INTO tutorial.visits_v1 FORMAT TSV" --max_insert_block_size=100000 < visits_v1.tsv
```
ClickHouse has a lot of [settings to tune](../operations/settings/index.md) and one way to specify them in console client is via arguments, as we can see with `--max_insert_block_size`. The easiest way to figure out what settings are available, what do they mean and what the defaults are is to query the `system.settings` table:
ClickHouse tiene un montón de [ajustes para sintonizar](../operations/settings/index.md) y una forma de especificarlos en el cliente de la consola es a través de argumentos, como podemos ver con `--max_insert_block_size`. La forma más fácil de averiguar qué configuraciones están disponibles, qué significan y cuáles son los valores predeterminados es consultar el `system.settings` tabla:
``` sql
SELECT name, value, changed, description
@ -479,23 +479,23 @@ FORMAT TSV
max_insert_block_size 1048576 0 "The maximum block size for insertion, if we control the creation of blocks for insertion."
```
Optionally you can [OPTIMIZE](../query_language/misc/#misc_operations-optimize) the tables after import. Tables that are configured with MergeTree-family engine always do merges of data parts in background to optimize data storage (or at least check if it makes sense). These queries will just force the table engine to do storage optimization right now instead of some time later:
Opcionalmente se puede [OPTIMIZAR](../query_language/misc/#misc_operations-optimize) las tablas después de la importación. Las tablas que están configuradas con el motor de la familia MergeTree siempre fusionan partes de datos en segundo plano para optimizar el almacenamiento de datos (o al menos verificar si tiene sentido). Estas consultas solo obligarán al motor de tablas a realizar la optimización del almacenamiento en este momento en lugar de algún tiempo después:
``` bash
clickhouse-client --query "OPTIMIZE TABLE tutorial.hits_v1 FINAL"
clickhouse-client --query "OPTIMIZE TABLE tutorial.visits_v1 FINAL"
```
This is I/O and CPU intensive operation so if the table constantly receives new data it’s better to leave it alone and let merges run in background.
Esta es una operación intensiva de E / S y CPU, por lo que si la tabla recibe constantemente datos nuevos, es mejor dejarlo solo y dejar que las fusiones se ejecuten en segundo plano.
Now we can check that the tables are successfully imported:
Ahora podemos comprobar que las tablas se han importado correctamente:
``` bash
clickhouse-client --query "SELECT COUNT(*) FROM tutorial.hits_v1"
clickhouse-client --query "SELECT COUNT(*) FROM tutorial.visits_v1"
```
## Example Queries {#example-queries}
## Consultas de ejemplo {#example-queries}
``` sql
SELECT
@ -517,18 +517,18 @@ FROM tutorial.visits_v1
WHERE (CounterID = 912887) AND (toYYYYMM(StartDate) = 201403) AND (domain(StartURL) = 'yandex.ru')
```
## Cluster Deployment {#cluster-deployment}
## Implementación de clúster {#cluster-deployment}
ClickHouse cluster is a homogenous cluster. Steps to set up:
El clúster ClickHouse es un clúster homogéneo. Pasos para configurar:
1. Install ClickHouse server on all machines of the cluster
2. Set up cluster configs in configuration files
3. Create local tables on each instance
4. Create a [Distributed table](../operations/table_engines/distributed.md)
1. Instale el servidor ClickHouse en todas las máquinas del clúster
2. Configurar configuraciones de clúster en archivos de configuración
3. Crear tablas locales en cada instancia
4. Crear un [Tabla distribuida](../operations/table_engines/distributed.md)
[Distributed table](../operations/table_engines/distributed.md) is actually a kind of “view” to local tables of ClickHouse cluster. SELECT query from a distributed table will be executed using resources of all cluster’s shards. You may specify configs for multiple clusters and create multiple distributed tables providing views to different clusters.
[Tabla distribuida](../operations/table_engines/distributed.md) es en realidad una especie de “view” a las tablas locales del clúster ClickHouse. La consulta SELECT de una tabla distribuida se ejecutará utilizando recursos de todos los fragmentos del clúster. Puede especificar configuraciones para varios clústeres y crear varias tablas distribuidas que proporcionen vistas a diferentes clústeres.
Example config for a cluster with three shards, one replica each:
Ejemplo de configuración para un clúster con tres fragmentos, una réplica cada uno:
``` xml
<remote_servers>
@ -555,37 +555,37 @@ Example config for a cluster with three shards, one replica each:
</remote_servers>
```
For further demonstration let’s create a new local table with the same `CREATE TABLE` query that we used for `hits_v1`, but different table name:
Para más demostraciones, creemos una nueva tabla local con la misma `CREATE TABLE` consulta que utilizamos para `hits_v1`, pero nombre de tabla diferente:
``` sql
CREATE TABLE tutorial.hits_local (...) ENGINE = MergeTree() ...
```
Creating a distributed table providing a view into local tables of the cluster:
Creación de una tabla distribuida que proporcione una vista en las tablas locales del clúster:
``` sql
CREATE TABLE tutorial.hits_all AS tutorial.hits_local
ENGINE = Distributed(perftest_3shards_1replicas, tutorial, hits_local, rand());
```
A common practice is to create similar Distributed tables on all machines of the cluster. This would allow running distributed queries on any machine of the cluster. Also there’s an alternative option to create temporary distributed table for a given SELECT query using [remote](../query_language/table_functions/remote.md) table function.
Una práctica común es crear tablas distribuidas similares en todas las máquinas del clúster. Esto permitiría ejecutar consultas distribuidas en cualquier máquina del clúster. También hay una opción alternativa para crear una tabla distribuida temporal para una consulta SELECT determinada usando [remoto](../query_language/table_functions/remote.md) función de la tabla.
Let’s run [INSERT SELECT](../query_language/insert_into.md) into the Distributed table to spread the table to multiple servers.
Vamos a correr [INSERTAR SELECCIONAR](../query_language/insert_into.md) en la tabla Distributed para extender la tabla a varios servidores.
``` sql
INSERT INTO tutorial.hits_all SELECT * FROM tutorial.hits_v1;
```
!!! warning "Notice"
This approach is not suitable for sharding of large tables. There’s a separate tool [clickhouse-copier](../operations/utils/clickhouse-copier.md) that can re-shard arbitrary large tables.
!!! warning "Aviso"
Este enfoque no es adecuado para la fragmentación de tablas grandes. Hay una herramienta separada [Método de codificación de datos:](../operations/utils/clickhouse-copier.md) que puede volver a fragmentar tablas grandes arbitrarias.
As you could expect computationally heavy queries are executed N times faster being launched on 3 servers instead of one.
Como era de esperar, las consultas computacionalmente pesadas se ejecutan N veces más rápido y se lanzan en 3 servidores en lugar de uno.
In this case, we have used a cluster with 3 shards each contains a single replica.
En este caso, hemos utilizado un clúster con 3 fragmentos, cada uno contiene una única réplica.
To provide resilience in a production environment we recommend that each shard should contain 2-3 replicas distributed between multiple datacenters. Note that ClickHouse supports an unlimited number of replicas.
Para proporcionar resiliencia en un entorno de producción, recomendamos que cada fragmento contenga 2-3 réplicas distribuidas entre varios centros de datos. Tenga en cuenta que ClickHouse admite un número ilimitado de réplicas.
Example config for a cluster of one shard containing three replicas:
Ejemplo de configuración para un clúster de un fragmento que contiene tres réplicas:
``` xml
<remote_servers>
@ -609,13 +609,13 @@ Example config for a cluster of one shard containing three replicas:
</remote_servers>
```
To enable native replication <a href="http://zookeeper.apache.org/" rel="external nofollow">ZooKeeper</a> is required. ClickHouse will take care of data consistency on all replicas and run restore procedure after failure
automatically. It’s recommended to deploy ZooKeeper cluster to separate servers.
Para habilitar la replicación nativa <a href="http://zookeeper.apache.org/" rel="external nofollow">ZooKeeper</a> se requiere. ClickHouse se encargará de la coherencia de los datos en todas las réplicas y ejecutará el procedimiento de restauración después de la falla
automática. Se recomienda implementar el clúster ZooKeeper en servidores separados.
ZooKeeper is not a strict requirement: in some simple cases, you can duplicate the data by writing it into all the replicas from your application code. This approach is **not** recommended, in this case, ClickHouse won’t be able to
guarantee data consistency on all replicas. This remains the responsibility of your application.
ZooKeeper no es un requisito estricto: en algunos casos simples, puede duplicar los datos escribiéndolos en todas las réplicas de su código de aplicación. Este enfoque es **ni** recomendado, en este caso, ClickHouse no podrá
garantizar la coherencia de los datos en todas las réplicas. Esto sigue siendo responsabilidad de su aplicación.
ZooKeeper locations need to be specified in the configuration file:
Las ubicaciones de ZooKeeper deben especificarse en el archivo de configuración:
``` xml
<zookeeper>
@ -634,7 +634,7 @@ ZooKeeper locations need to be specified in the configuration file:
</zookeeper>
```
Also, we need to set macros for identifying each shard and replica, it will be used on table creation:
Además, necesitamos establecer macros para identificar cada fragmento y réplica, se usará en la creación de la tabla:
``` xml
<macros>
@ -643,7 +643,7 @@ Also, we need to set macros for identifying each shard and replica, it will be u
</macros>
```
If there are no replicas at the moment on replicated table creation, a new first replica will be instantiated. If there are already live replicas, the new replica will clone the data from existing ones. You have an option to create all replicated tables first and that insert data to it. Another option is to create some replicas and add the others after or during data insertion.
Si no hay réplicas en este momento en la creación de la tabla replicada, se creará una nueva primera réplica. Si ya hay réplicas activas, la nueva réplica clonará los datos de las existentes. Tiene la opción de crear primero todas las tablas replicadas e insertar datos en ella. Otra opción es crear algunas réplicas y agregar las otras después o durante la inserción de datos.
``` sql
CREATE TABLE tutorial.hits_replica (...)
@ -654,12 +654,12 @@ ENGINE = ReplcatedMergeTree(
...
```
Here we use [ReplicatedMergeTree](../operations/table_engines/replication.md) table engine. In parameters we specify ZooKeeper path containing shard and replica identifiers.
Aquí usamos [ReplicatedMergeTree](../operations/table_engines/replication.md) motor de mesa. En los parámetros, especificamos la ruta ZooKeeper que contiene identificadores de fragmentos y réplicas.
``` sql
INSERT INTO tutorial.hits_replica SELECT * FROM tutorial.hits_local;
```
Replication operates in multi-master mode. Data can be loaded into any replica and it will be synced with other instances automatically. Replication is asynchronous so at a given moment, not all replicas may contain recently inserted data. To allow data insertion at least one replica should be up. Others will sync up data and repair consistency once they will become active again. Please notice that such an approach allows for the low possibility of a loss of just appended data.
La replicación funciona en modo multi-master. Los datos se pueden cargar en cualquier réplica y se sincronizarán con otras instancias automáticamente. La replicación es asíncrona, por lo que en un momento dado, no todas las réplicas pueden contener datos insertados recientemente. Para permitir la inserción de datos, al menos una réplica debe estar activa. Otros sincronizarán los datos y repararán la coherencia una vez que vuelvan a activarse. Tenga en cuenta que tal enfoque permite la baja posibilidad de una pérdida de datos que acaba de agregar.
[Original article](https://clickhouse.tech/docs/es/getting_started/tutorial/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/getting_started/tutorial/) <!--hide-->

4
docs/es/guides/apply_catboost_model.md
View File

@ -22,7 +22,7 @@ Si usted no tiene el [Acoplador](https://docs.docker.com/install/) sin embargo,
Antes de aplicar un modelo CatBoost:
**1.** Tire de la [Imagen de acoplador](https://hub.docker.com/r/yandex/tutorial-catboost-clickhouse) del registro:
**1.** Neumático de la [Imagen de acoplador](https://hub.docker.com/r/yandex/tutorial-catboost-clickhouse) del registro:
``` bash
$ docker pull yandex/tutorial-catboost-clickhouse
@ -227,6 +227,6 @@ FROM
```
!!! note "Nota"
Más información sobre [avg()](../query_language/agg_functions/reference.md#agg_function-avg) y [registro()](../query_language/functions/math_functions.md) función.
Más información sobre [avg()](../query_language/agg_functions/reference.md#agg_function-avg) y [Registro()](../query_language/functions/math_functions.md) función.
[Artículo Original](https://clickhouse.tech/docs/es/guides/apply_catboost_model/) <!--hide-->

8
docs/es/index.md
View File

@ -8,7 +8,7 @@ En un “normal” DBMS orientado a filas, los datos se almacenan en este orden:
|--------|------------------------------------|------------|---------------------------|-----------|-----------------------------------|
| \#0 | Sistema abierto. | Uno | Relaciones con inversores | Uno | ¿Qué puedes encontrar en Neodigit |
| \#1 | Sistema abierto. | Cero | Contáctenos | Uno | ¿Qué puedes encontrar en Neodigit |
| Nombre | Método de codificación de datos: | Uno | Mision | Uno | ¿Qué puedes encontrar en Neodigit |
| Nombre | Método de codificación de datos: | Uno | Misión | Uno | ¿Qué puedes encontrar en Neodigit |
| \#Y | … | … | … | … | … |
En otras palabras, todos los valores relacionados con una fila se almacenan físicamente uno junto al otro.
@ -21,7 +21,7 @@ En un DBMS orientado a columnas, los datos se almacenan así:
|-------------|-----------------------------------|-----------------------------------|------------------------------------|-----|
| Argumento: | Sistema abierto. | Sistema abierto. | Método de codificación de datos: | … |
| JavaEnable: | Uno | Cero | Uno | … |
| Titular: | Relaciones con inversores | Contáctenos | Mision | … |
| Titular: | Relaciones con inversores | Contáctenos | Misión | … |
| GoodEvent: | Uno | Uno | Uno | … |
| EventTime: | ¿Qué puedes encontrar en Neodigit | ¿Qué puedes encontrar en Neodigit | ¿Qué puedes encontrar en Neodigit | … |
@ -39,7 +39,7 @@ Cuanto mayor sea la carga en el sistema, más importante es personalizar el sist
- Los datos se actualizan en lotes bastante grandes (\> 1000 filas), no por filas individuales; o no se actualiza en absoluto.
- Los datos se agregan a la base de datos pero no se modifican.
- Para las lecturas, se extrae un número bastante grande de filas de la base de datos, pero solo un pequeño subconjunto de columnas.
- Las tablas son “wide,” lo que significa que contienen un gran número de columnas.
- Las tablas hijo “wide,” lo que significa que contienen un gran número de columnas.
- Las consultas son relativamente raras (generalmente cientos de consultas por servidor o menos por segundo).
- Para consultas simples, se permiten latencias de alrededor de 50 ms.
- Los valores de columna son bastante pequeños: números y cadenas cortas (por ejemplo, 60 bytes por URL).
@ -71,7 +71,7 @@ Ver la diferencia?
2. Dado que los datos se leen en paquetes, es más fácil de comprimir. Los datos en columnas también son más fáciles de comprimir. Esto reduce aún más el volumen de E/S.
3. Debido a la reducción de E / S, más datos se ajustan a la memoria caché del sistema.
Por ejemplo, la consulta “count the number of records for each advertising platform” requiere leer uno “advertising platform ID” columna, que ocupa 1 byte sin comprimir. Si la mayor parte del tráfico no proviene de plataformas publicitarias, puede esperar al menos una compresión de 10 veces de esta columna. Cuando se utiliza un algoritmo de compresión rápida, la descompresión de datos es posible a una velocidad de al menos varios gigabytes de datos sin comprimir por segundo. En otras palabras, esta consulta se puede procesar a una velocidad de aproximadamente varios miles de millones de filas por segundo en un único servidor. Esta velocidad se logra realmente en la práctica.
Por ejemplo, la consulta “count the number of records for each advertising platform” más caliente “advertising platform ID” columna, que ocupa 1 byte sin comprimir. Si la mayor parte del tráfico no proviene de plataformas publicitarias, puede esperar al menos una compresión de 10 veces de esta columna. Cuando se utiliza un algoritmo de compresión rápida, la descompresión de datos es posible a una velocidad de al menos varios gigabytes de datos sin comprimir por segundo. En otras palabras, esta consulta se puede procesar a una velocidad de aproximadamente varios miles de millones de filas por segundo en un único servidor. Esta velocidad se logra realmente en la práctica.
<details markdown="1">

94
docs/es/interfaces/cli.md
View File

@ -1,8 +1,8 @@
# Command-line Client {#command-line-client}
# Cliente de línea de comandos {#command-line-client}
ClickHouse provides a native command-line client: `clickhouse-client`. The client supports command-line options and configuration files. For more information, see [Configuring](#interfaces_cli_configuration).
ClickHouse proporciona un cliente de línea de comandos nativo: `clickhouse-client`. El cliente admite opciones de línea de comandos y archivos de configuración. Para obtener más información, consulte [Configuración](#interfaces_cli_configuration).
[Install](../getting_started/index.md) it from the `clickhouse-client` package and run it with the command `clickhouse-client`.
[Instalar](../getting_started/index.md) desde el `clickhouse-client` paquete y ejecútelo con el comando `clickhouse-client`.
``` bash
$ clickhouse-client
@ -13,15 +13,15 @@ Connected to ClickHouse server version 19.17.1 revision 54428.
:)
```
Different client and server versions are compatible with one another, but some features may not be available in older clients. We recommend using the same version of the client as the server app. When you try to use a client of the older version, then the server, `clickhouse-client` displays the message:
Las diferentes versiones de cliente y servidor son compatibles entre sí, pero es posible que algunas funciones no estén disponibles en clientes anteriores. Se recomienda utilizar la misma versión del cliente que la aplicación de servidor. Cuando intenta usar un cliente de la versión anterior, entonces el servidor, `clickhouse-client` muestra el mensaje:
ClickHouse client version is older than ClickHouse server. It may lack support for new features.
## Usage {#cli-usage}
## Uso {#cli-usage}
The client can be used in interactive and non-interactive (batch) mode. To use batch mode, specify the ‘query’ parameter, or send data to ‘stdin’ (it verifies that ‘stdin’ is not a terminal), or both. Similar to the HTTP interface, when using the ‘query’ parameter and sending data to ‘stdin’, the request is a concatenation of the ‘query’ parameter, a line feed, and the data in ‘stdin’. This is convenient for large INSERT queries.
El cliente se puede utilizar en modo interactivo y no interactivo (por lotes). Para utilizar el modo por lotes, especifique el ‘query’ parámetro, o enviar datos a ‘stdin’ (verifica que ‘stdin’ no es un terminal), o ambos. Similar a la interfaz HTTP, cuando se utiliza el ‘query’ parámetro y el envío de datos a ‘stdin’ la solicitud es una concatenación de la ‘query’ parámetro, un avance de línea y los datos en ‘stdin’. Esto es conveniente para grandes consultas INSERT.
Example of using the client to insert data:
Ejemplo de uso del cliente para insertar datos:
``` bash
$ echo -ne "1, 'some text', '2016-08-14 00:00:00'\n2, 'some more text', '2016-08-14 00:00:01'" | clickhouse-client --database=test --query="INSERT INTO test FORMAT CSV";
@ -34,102 +34,102 @@ _EOF
$ cat file.csv | clickhouse-client --database=test --query="INSERT INTO test FORMAT CSV";
```
In batch mode, the default data format is TabSeparated. You can set the format in the FORMAT clause of the query.
En el modo por lotes, el formato de datos predeterminado es TabSeparated. Puede establecer el formato en la cláusula FORMAT de la consulta.
By default, you can only process a single query in batch mode. To make multiple queries from a “script,” use the `--multiquery` parameter. This works for all queries except INSERT. Query results are output consecutively without additional separators. Similarly, to process a large number of queries, you can run ‘clickhouse-client’ for each query. Note that it may take tens of milliseconds to launch the ‘clickhouse-client’ program.
De forma predeterminada, solo puede procesar una única consulta en modo por lotes. Para realizar múltiples consultas desde un “script,” utilizar el `--multiquery` parámetro. Esto funciona para todas las consultas excepto INSERT . Los resultados de la consulta se generan consecutivamente sin separadores adicionales. Del mismo modo, para procesar un gran número de consultas, puede ejecutar ‘clickhouse-client’ para cada consulta. Tenga en cuenta que puede tomar decenas de milisegundos para iniciar el ‘clickhouse-client’ programa.
In interactive mode, you get a command line where you can enter queries.
En el modo interactivo, obtiene una línea de comandos donde puede ingresar consultas.
If ‘multiline’ is not specified (the default): To run the query, press Enter. The semicolon is not necessary at the end of the query. To enter a multiline query, enter a backslash `\` before the line feed. After you press Enter, you will be asked to enter the next line of the query.
Si ‘multiline’ no se especifica (el valor predeterminado): Para ejecutar la consulta, pulse Intro. El punto y coma no es necesario al final de la consulta. Para introducir una consulta de varias líneas, introduzca una barra invertida `\` antes de la alimentación de línea. Después de presionar Enter, se le pedirá que ingrese la siguiente línea de la consulta.
If multiline is specified: To run a query, end it with a semicolon and press Enter. If the semicolon was omitted at the end of the entered line, you will be asked to enter the next line of the query.
Si se especifica multilínea: Para ejecutar una consulta, finalícela con un punto y coma y presione Intro. Si se omitió el punto y coma al final de la línea ingresada, se le pedirá que ingrese la siguiente línea de la consulta.
Only a single query is run, so everything after the semicolon is ignored.
Solo se ejecuta una sola consulta, por lo que se ignora todo después del punto y coma.
You can specify `\G` instead of or after the semicolon. This indicates Vertical format. In this format, each value is printed on a separate line, which is convenient for wide tables. This unusual feature was added for compatibility with the MySQL CLI.
Puede especificar `\G` en lugar o después del punto y coma. Esto indica el formato vertical. En este formato, cada valor se imprime en una línea separada, lo cual es conveniente para tablas anchas. Esta característica inusual se agregó por compatibilidad con la CLI de MySQL.
The command line is based on ‘replxx’ (similar to ‘readline’). In other words, it uses the familiar keyboard shortcuts and keeps a history. The history is written to `~/.clickhouse-client-history`.
La línea de comandos se basa en ‘replxx’ (similar a ‘readline’). En otras palabras, utiliza los atajos de teclado familiares y mantiene un historial. La historia está escrita para `~/.clickhouse-client-history`.
By default, the format used is PrettyCompact. You can change the format in the FORMAT clause of the query, or by specifying `\G` at the end of the query, using the `--format` or `--vertical` argument in the command line, or using the client configuration file.
De forma predeterminada, el formato utilizado es PrettyCompact. Puede cambiar el formato en la cláusula FORMAT de la consulta o especificando `\G` al final de la consulta, utilizando el `--format` o `--vertical` en la línea de comandos, o utilizando el archivo de configuración del cliente.
To exit the client, press Ctrl+D (or Ctrl+C), or enter one of the following instead of a query: “exit”, “quit”, “logout”, “exit;”, “quit;”, “logout;”, “q”, “Q”, “:q”
Para salir del cliente, presione Ctrl+D (o Ctrl+C) o introduzca una de las siguientes opciones en lugar de una consulta: “exit”, “quit”, “logout”, “exit;”, “quit;”, “logout;”, “q”, “Q”, “:q”
When processing a query, the client shows:
Al procesar una consulta, el cliente muestra:
1. Progress, which is updated no more than 10 times per second (by default). For quick queries, the progress might not have time to be displayed.
2. The formatted query after parsing, for debugging.
3. The result in the specified format.
4. The number of lines in the result, the time passed, and the average speed of query processing.
1. Progreso, que se actualiza no más de 10 veces por segundo (de forma predeterminada). Para consultas rápidas, es posible que el progreso no tenga tiempo para mostrarse.
2. La consulta con formato después del análisis, para la depuración.
3. El resultado en el formato especificado.
4. El número de líneas en el resultado, el tiempo transcurrido y la velocidad promedio de procesamiento de consultas.
You can cancel a long query by pressing Ctrl+C. However, you will still need to wait for a little for the server to abort the request. It is not possible to cancel a query at certain stages. If you don’t wait and press Ctrl+C a second time, the client will exit.
Puede cancelar una consulta larga presionando Ctrl + C. Sin embargo, aún tendrá que esperar un poco para que el servidor aborte la solicitud. No es posible cancelar una consulta en determinadas etapas. Si no espera y presiona Ctrl + C por segunda vez, el cliente saldrá.
The command-line client allows passing external data (external temporary tables) for querying. For more information, see the section “External data for query processing”.
El cliente de línea de comandos permite pasar datos externos (tablas temporales externas) para consultar. Para obtener más información, consulte la sección “External data for query processing”.
### Queries with Parameters {#cli-queries-with-parameters}
### Consultas con parámetros {#cli-queries-with-parameters}
You can create a query with parameters and pass values to them from client application. This allows to avoid formatting query with specific dynamic values on client side. For example:
Puede crear una consulta con parámetros y pasarles valores desde la aplicación cliente. Esto permite evitar formatear consultas con valores dinámicos específicos en el lado del cliente. Por ejemplo:
``` bash
$ clickhouse-client --param_parName="[1, 2]" -q "SELECT * FROM table WHERE a = {parName:Array(UInt16)}"
```
#### Query Syntax {#cli-queries-with-parameters-syntax}
#### Sintaxis de consulta {#cli-queries-with-parameters-syntax}
Format a query as usual, then place the values that you want to pass from the app parameters to the query in braces in the following format:
Formatee una consulta como de costumbre, luego coloque los valores que desea pasar de los parámetros de la aplicación a la consulta entre llaves en el siguiente formato:
``` sql
{<name>:<data type>}
```
- `name` — Placeholder identifier. In the console client it should be used in app parameters as `--param_<name> = value`.
- `data type` — [Data type](../data_types/index.md) of the app parameter value. For example, a data structure like `(integer, ('string', integer))` can have the `Tuple(UInt8, Tuple(String, UInt8))` data type (you can also use another [integer](../data_types/int_uint.md) types).
- `data type` — [Tipo de datos](../data_types/index.md) del valor del parámetro de la aplicación. Por ejemplo, una estructura de datos como `(integer, ('string', integer))` puede tener el `Tuple(UInt8, Tuple(String, UInt8))` tipo de datos (también puede usar otro [Entero](../data_types/int_uint.md) tipo).
#### Example {#example}
#### Ejemplo {#example}
``` bash
$ clickhouse-client --param_tuple_in_tuple="(10, ('dt', 10))" -q "SELECT * FROM table WHERE val = {tuple_in_tuple:Tuple(UInt8, Tuple(String, UInt8))}"
```
## Configuring {#interfaces-cli-configuration}
## Configuración {#interfaces-cli-configuration}
You can pass parameters to `clickhouse-client` (all parameters have a default value) using:
Puede pasar parámetros a `clickhouse-client` (todos los parámetros tienen un valor predeterminado) usando:
- From the Command Line
- Desde la línea de comandos
Command-line options override the default values and settings in configuration files.
Las opciones de la línea de comandos anulan los valores y valores predeterminados de los archivos de configuración.
- Configuration files.
- Archivos de configuración.
Settings in the configuration files override the default values.
Los valores de los archivos de configuración anulan los valores predeterminados.
### Command Line Options {#command-line-options}
### Opciones de línea de comandos {#command-line-options}
- `--host, -h` -– The server name, ‘localhost’ by default. You can use either the name or the IPv4 or IPv6 address.
- `--host, -h` -– The server name, ‘localhost’ predeterminada. Puede utilizar el nombre o la dirección IPv4 o IPv6.
- `--port` – The port to connect to. Default value: 9000. Note that the HTTP interface and the native interface use different ports.
- `--user, -u` – The username. Default value: default.
- `--password` – The password. Default value: empty string.
- `--query, -q` – The query to process when using non-interactive mode.
- `--database, -d` – Select the current default database. Default value: the current database from the server settings (‘default’ by default).
- `--database, -d` – Select the current default database. Default value: the current database from the server settings (‘default’ predeterminada).
- `--multiline, -m` – If specified, allow multiline queries (do not send the query on Enter).
- `--multiquery, -n` – If specified, allow processing multiple queries separated by semicolons.
- `--format, -f` – Use the specified default format to output the result.
- `--vertical, -E` – If specified, use the Vertical format by default to output the result. This is the same as ‘–format=Vertical’. In this format, each value is printed on a separate line, which is helpful when displaying wide tables.
- `--time, -t` – If specified, print the query execution time to ‘stderr’ in non-interactive mode.
- `--vertical, -E` – If specified, use the Vertical format by default to output the result. This is the same as ‘–format=Vertical’. En este formato, cada valor se imprime en una línea separada, lo que es útil cuando se muestran tablas anchas.
- `--time, -t` – If specified, print the query execution time to ‘stderr’ en modo no interactivo.
- `--stacktrace` – If specified, also print the stack trace if an exception occurs.
- `--config-file` – The name of the configuration file.
- `--secure` – If specified, will connect to server over secure connection.
- `--param_<name>` — Value for a [query with parameters](#cli-queries-with-parameters).
- `--param_<name>` — Value for a [consulta con parámetros](#cli-queries-with-parameters).
### Configuration Files {#configuration-files}
### Archivos de configuración {#configuration-files}
`clickhouse-client` uses the first existing file of the following:
`clickhouse-client` utiliza el primer archivo existente de los siguientes:
- Defined in the `--config-file` parameter.
- Definido en el `--config-file` parámetro.
- `./clickhouse-client.xml`
- `~/.clickhouse-client/config.xml`
- `/etc/clickhouse-client/config.xml`
Example of a config file:
Ejemplo de un archivo de configuración:
``` xml
<config>
@ -139,4 +139,4 @@ Example of a config file:
</config>
```
[Original article](https://clickhouse.tech/docs/es/interfaces/cli/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/interfaces/cli/) <!--hide-->

6
docs/es/interfaces/cpp.md
View File

@ -1,5 +1,5 @@
# C++ Client Library {#c-client-library}
# Biblioteca de clientes de C++ {#c-client-library}
See README at [clickhouse-cpp](https://github.com/ClickHouse/clickhouse-cpp) repository.
Ver README en [Bienvenidos](https://github.com/ClickHouse/clickhouse-cpp) repositorio.
[Original article](https://clickhouse.tech/docs/es/interfaces/cpp/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/interfaces/cpp/) <!--hide-->

1205
docs/es/interfaces/formats.md
View File

File diff suppressed because it is too large Load Diff

2
docs/es/interfaces/http.md
View File

@ -145,7 +145,7 @@ Puede utilizar el formato interno de compresión ClickHouse al transmitir datos.
Si ha especificado `compress=1` en la URL, el servidor comprime los datos que le envía.
Si ha especificado `decompress=1` en la dirección URL, el servidor descomprime los mismos datos que `POST` método.
También puede optar por utilizar [Compresión HTTP](https://en.wikipedia.org/wiki/HTTP_compression). Para enviar un `POST` solicitud, agregue el encabezado de solicitud `Content-Encoding: compression_method`. Para que ClickHouse comprima la respuesta, debe agregar `Accept-Encoding: compression_method`. Soporta ClickHouse `gzip`, `br`, y `deflate` [métodos de compresión](https://en.wikipedia.org/wiki/HTTP_compression#Content-Encoding_tokens). Para habilitar la compresión HTTP, debe usar ClickHouse [enable\_http\_compression](../operations/settings/settings.md#settings-enable_http_compression) configuración. Puede configurar el nivel de compresión de datos [http\_zlib\_compression\_level](#settings-http_zlib_compression_level) para todos los métodos de compresión.
También puede optar por utilizar [Compresión HTTP](https://en.wikipedia.org/wiki/HTTP_compression). Para enviar un `POST` solicitud, agregue el encabezado de solicitud `Content-Encoding: compression_method`. Para que ClickHouse comprima la respuesta, debe agregar `Accept-Encoding: compression_method`. Soporte ClickHouse `gzip`, `br`, y `deflate` [métodos de compresión](https://en.wikipedia.org/wiki/HTTP_compression#Content-Encoding_tokens). Para habilitar la compresión HTTP, debe usar ClickHouse [enable\_http\_compression](../operations/settings/settings.md#settings-enable_http_compression) configuración. Puede configurar el nivel de compresión de datos [http\_zlib\_compression\_level](#settings-http_zlib_compression_level) para todos los métodos de compresión.
Puede usar esto para reducir el tráfico de red al transmitir una gran cantidad de datos o para crear volcados que se comprimen inmediatamente.

28
docs/es/interfaces/index.md
View File

@ -1,21 +1,21 @@
# Interfaces {#interfaces}
# Interfaz {#interfaces}
ClickHouse provides two network interfaces (both can be optionally wrapped in TLS for additional security):
ClickHouse proporciona dos interfaces de red (ambas se pueden ajustar opcionalmente en TLS para mayor seguridad):
- [HTTP](http.md), which is documented and easy to use directly.
- [Native TCP](tcp.md), which has less overhead.
- [HTTP](http.md), que está documentado y fácil de usar directamente.
- [TCP nativo](tcp.md), que tiene menos sobrecarga.
In most cases it is recommended to use appropriate tool or library instead of interacting with those directly. Officially supported by Yandex are the following:
En la mayoría de los casos, se recomienda utilizar la herramienta o biblioteca apropiada en lugar de interactuar con ellos directamente. Oficialmente apoyados por Yandex son los siguientes:
- [Command-line client](cli.md)
- [JDBC driver](jdbc.md)
- [ODBC driver](odbc.md)
- [C++ client library](cpp.md)
- [Cliente de línea de comandos](cli.md)
- [Controlador JDBC](jdbc.md)
- [Controlador ODBC](odbc.md)
- [Biblioteca cliente de C++](cpp.md)
There are also a wide range of third-party libraries for working with ClickHouse:
También hay una amplia gama de bibliotecas de terceros para trabajar con ClickHouse:
- [Client libraries](third-party/client_libraries.md)
- [Integrations](third-party/integrations.md)
- [Visual interfaces](third-party/gui.md)
- [Bibliotecas de clientes](third-party/client_libraries.md)
- [Integración](third-party/integrations.md)
- [Interfaces visuales](third-party/gui.md)
[Original article](https://clickhouse.tech/docs/es/interfaces/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/interfaces/) <!--hide-->

12
docs/es/interfaces/jdbc.md
View File

@ -1,8 +1,8 @@
# JDBC Driver {#jdbc-driver}
# Controlador JDBC {#jdbc-driver}
- **[Official driver](https://github.com/ClickHouse/clickhouse-jdbc)**
- Third-party drivers:
- [ClickHouse-Native-JDBC](https://github.com/housepower/ClickHouse-Native-JDBC)
- [clickhouse4j](https://github.com/blynkkk/clickhouse4j)
- **[Conductor oficial](https://github.com/ClickHouse/clickhouse-jdbc)**
- Controladores de terceros:
- [Sistema abierto.](https://github.com/housepower/ClickHouse-Native-JDBC)
- [Método de codificación de datos:](https://github.com/blynkkk/clickhouse4j)
[Original article](https://clickhouse.tech/docs/es/interfaces/jdbc/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/interfaces/jdbc/) <!--hide-->

20
docs/es/interfaces/mysql.md
View File

@ -1,18 +1,18 @@
# MySQL interface {#mysql-interface}
# Interfaz de MySQL {#mysql-interface}
ClickHouse supports MySQL wire protocol. It can be enabled by [mysql\_port](../operations/server_settings/settings.md#server_settings-mysql_port) setting in configuration file:
ClickHouse soporta el protocolo de cable MySQL. Puede ser habilitado por [mysql\_port](../operations/server_settings/settings.md#server_settings-mysql_port) configuración en el archivo de configuración:
``` xml
<mysql_port>9004</mysql_port>
```
Example of connecting using command-line tool `mysql`:
Ejemplo de conexión mediante la herramienta de línea de comandos `mysql`:
``` bash
$ mysql --protocol tcp -u default -P 9004
```
Output if a connection succeeded:
Salida si una conexión se realizó correctamente:
``` text
Welcome to the MySQL monitor. Commands end with ; or \g.
@ -30,13 +30,13 @@ Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
mysql>
```
For compatibility with all MySQL clients, it is recommended to specify user password with [double SHA1](../operations/settings/settings_users.md#password_double_sha1_hex) in configuration file.
If user password is specified using [SHA256](../operations/settings/settings_users.md#password_sha256_hex), some clients won’t be able to authenticate (mysqljs and old versions of command-line tool mysql).
Para la compatibilidad con todos los clientes MySQL, se recomienda especificar la contraseña de usuario con [Doble SHA1](../operations/settings/settings_users.md#password_double_sha1_hex) en el archivo de configuración.
Si la contraseña de usuario se especifica usando [SHA256](../operations/settings/settings_users.md#password_sha256_hex), algunos clientes no podrán autenticarse (mysqljs y versiones antiguas de la herramienta de línea de comandos mysql).
Restrictions:
Restricción:
- prepared queries are not supported
- las consultas preparadas no son compatibles
- some data types are sent as strings
- algunos tipos de datos se envían como cadenas
[Original article](https://clickhouse.tech/docs/es/interfaces/mysql/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/interfaces/mysql/) <!--hide-->

6
docs/es/interfaces/odbc.md
View File

@ -1,5 +1,5 @@
# ODBC Driver {#odbc-driver}
# Conductor ODBC {#odbc-driver}
- [Official driver](https://github.com/ClickHouse/clickhouse-odbc).
- [Conductor oficial](https://github.com/ClickHouse/clickhouse-odbc).
[Original article](https://clickhouse.tech/docs/es/interfaces/odbc/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/interfaces/odbc/) <!--hide-->

6
docs/es/interfaces/tcp.md
View File

@ -1,5 +1,5 @@
# Native Interface (TCP) {#native-interface-tcp}
# Interfaz nativa (TCP) {#native-interface-tcp}
The native protocol is used in the [command-line client](cli.md), for inter-server communication during distributed query processing, and also in other C++ programs. Unfortunately, native ClickHouse protocol does not have formal specification yet, but it can be reverse-engineered from ClickHouse source code (starting [around here](https://github.com/ClickHouse/ClickHouse/tree/master/dbms/src/Client)) and/or by intercepting and analyzing TCP traffic.
El protocolo nativo se utiliza en el [cliente de línea de comandos](cli.md), para la comunicación entre servidores durante el procesamiento de consultas distribuidas, y también en otros programas de C, Desafortunadamente, el protocolo nativo de ClickHouse aún no tiene especificaciones formales, pero puede ser diseñado de manera inversa desde el código fuente de ClickHouse (comenzando [por aquí](https://github.com/ClickHouse/ClickHouse/tree/master/dbms/src/Client)) y/o mediante la interceptación y el análisis del tráfico TCP.
[Original article](https://clickhouse.tech/docs/es/interfaces/tcp/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/interfaces/tcp/) <!--hide-->

72
docs/es/interfaces/third-party/client_libraries.md vendored
View File

@ -1,50 +1,50 @@
# Client Libraries from Third-party Developers {#client-libraries-from-third-party-developers}
# Bibliotecas de clientes de desarrolladores de terceros {#client-libraries-from-third-party-developers}
!!! warning "Disclaimer"
Yandex does **not** maintain the libraries listed below and haven’t done any extensive testing to ensure their quality.
!!! warning "Descargo"
Yandex hace **ni** mantenga las bibliotecas enumeradas a continuación y no haya realizado ninguna prueba extensa para garantizar su calidad.
- Python
- [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)
- [clickhouse-driver](https://github.com/mymarilyn/clickhouse-driver)
- [clickhouse-client](https://github.com/yurial/clickhouse-client)
- [aiochclient](https://github.com/maximdanilchenko/aiochclient)
- Película
- [InformaciónSistema abierto.](https://github.com/Infinidat/infi.clickhouse_orm)
- [Casa de clics-conductor](https://github.com/mymarilyn/clickhouse-driver)
- [Casa de clics-cliente](https://github.com/yurial/clickhouse-client)
- [Aiochclient](https://github.com/maximdanilchenko/aiochclient)
- PHP
- [SeasClick](https://github.com/SeasX/SeasClick)
- [phpClickHouse](https://github.com/smi2/phpClickHouse)
- [clickhouse-php-client](https://github.com/8bitov/clickhouse-php-client)
- [clickhouse-client](https://github.com/bozerkins/clickhouse-client)
- [Método de codificación de datos:](https://github.com/SeasX/SeasClick)
- [Inicio](https://github.com/smi2/phpClickHouse)
- [Sistema abierto.](https://github.com/8bitov/clickhouse-php-client)
- [Casa de clics-cliente](https://github.com/bozerkins/clickhouse-client)
- [PhpClickHouseClient](https://github.com/SevaCode/PhpClickHouseClient)
- Go
- [clickhouse](https://github.com/kshvakov/clickhouse/)
- [go-clickhouse](https://github.com/roistat/go-clickhouse)
- [mailrugo-clickhouse](https://github.com/mailru/go-clickhouse)
- [golang-clickhouse](https://github.com/leprosus/golang-clickhouse)
- Ve
- [Casa de clics](https://github.com/kshvakov/clickhouse/)
- [Sistema abierto.](https://github.com/roistat/go-clickhouse)
- [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://github.com/mailru/go-clickhouse)
- [Golang-clickhouse](https://github.com/leprosus/golang-clickhouse)
- NodeJs
- [clickhouse (NodeJs)](https://github.com/TimonKK/clickhouse)
- [node-clickhouse](https://github.com/apla/node-clickhouse)
- [Casa de clic (NodeJs)](https://github.com/TimonKK/clickhouse)
- [Inicio](https://github.com/apla/node-clickhouse)
- Perl
- [perl-DBD-ClickHouse](https://github.com/elcamlost/perl-DBD-ClickHouse)
- [HTTP-ClickHouse](https://metacpan.org/release/HTTP-ClickHouse)
- [AnyEvent-ClickHouse](https://metacpan.org/release/AnyEvent-ClickHouse)
- Ruby
- [ClickHouse (Ruby)](https://github.com/shlima/click_house)
- [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://github.com/elcamlost/perl-DBD-ClickHouse)
- [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://metacpan.org/release/HTTP-ClickHouse)
- [Cualquier evento-ClickHouse](https://metacpan.org/release/AnyEvent-ClickHouse)
- Rubí
- [Haga clic en Casa (Ruby)](https://github.com/shlima/click_house)
- R
- [clickhouse-r](https://github.com/hannesmuehleisen/clickhouse-r)
- [RClickhouse](https://github.com/IMSMWU/RClickhouse)
- [Sistema abierto.](https://github.com/hannesmuehleisen/clickhouse-r)
- [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://github.com/IMSMWU/RClickhouse)
- Java
- [clickhouse-client-java](https://github.com/VirtusAI/clickhouse-client-java)
- [clickhouse-client](https://github.com/Ecwid/clickhouse-client)
- Scala
- [clickhouse-scala-client](https://github.com/crobox/clickhouse-scala-client)
- Kotlin
- [Casa de clic-cliente-java](https://github.com/VirtusAI/clickhouse-client-java)
- [Casa de clics-cliente](https://github.com/Ecwid/clickhouse-client)
- Ciudad
- [Sistema abierto.](https://github.com/crobox/clickhouse-scala-client)
- Bienvenido
- [AORM](https://github.com/TanVD/AORM)
- C\#
- [ClickHouse.Ado](https://github.com/killwort/ClickHouse-Net)
- [ClickHouse.Client](https://github.com/DarkWanderer/ClickHouse.Client)
- [ClickHouse.Net](https://github.com/ilyabreev/ClickHouse.Net)
- [Sistema abierto.Ado](https://github.com/killwort/ClickHouse-Net)
- [Sistema abierto.Cliente](https://github.com/DarkWanderer/ClickHouse.Client)
- [Sistema abierto.](https://github.com/ilyabreev/ClickHouse.Net)
- Elixir
- [clickhousex](https://github.com/appodeal/clickhousex/)
- Nim
- [nim-clickhouse](https://github.com/leonardoce/nim-clickhouse)
- [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://github.com/leonardoce/nim-clickhouse)
[Original article](https://clickhouse.tech/docs/es/interfaces/third-party/client_libraries/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/interfaces/third-party/client_libraries/) <!--hide-->

176
docs/es/interfaces/third-party/gui.md vendored
View File

@ -1,145 +1,145 @@
# Visual Interfaces from Third-party Developers {#visual-interfaces-from-third-party-developers}
# Interfaces visuales de desarrolladores de terceros {#visual-interfaces-from-third-party-developers}
## Open-Source {#open-source}
## De código abierto {#open-source}
### Tabix {#tabix}
Web interface for ClickHouse in the [Tabix](https://github.com/tabixio/tabix) project.
Interfaz web para ClickHouse en el [Tabix](https://github.com/tabixio/tabix) proyecto.
Features:
Función:
- Works with ClickHouse directly from the browser, without the need to install additional software.
- Query editor with syntax highlighting.
- Auto-completion of commands.
- Tools for graphical analysis of query execution.
- Colour scheme options.
- Funciona con ClickHouse directamente desde el navegador, sin la necesidad de instalar software adicional.
- Editor de consultas con resaltado de sintaxis.
- Autocompletado de comandos.
- Herramientas para el análisis gráfico de la ejecución de consultas.
- Opciones de esquema de color.
[Tabix documentation](https://tabix.io/doc/).
[Documentación de Tabix](https://tabix.io/doc/).
### HouseOps {#houseops}
### Sistema abierto. {#houseops}
[HouseOps](https://github.com/HouseOps/HouseOps) is a UI/IDE for OSX, Linux and Windows.
[Sistema abierto.](https://github.com/HouseOps/HouseOps) Es una interfaz de usuario / IDE para OSX, Linux y Windows.
Features:
Función:
- Query builder with syntax highlighting. View the response in a table or JSON view.
- Export query results as CSV or JSON.
- List of processes with descriptions. Write mode. Ability to stop (`KILL`) a process.
- Database graph. Shows all tables and their columns with additional information.
- A quick view of the column size.
- Server configuration.
- Generador de consultas con resaltado de sintaxis. Ver la respuesta en una tabla o vista JSON.
- Exportar resultados de consultas como CSV o JSON.
- Lista de procesos con descripciones. Modo de escritura. Capacidad de parar (`KILL`) proceso.
- Gráfico de base de datos. Muestra todas las tablas y sus columnas con información adicional.
- Una vista rápida del tamaño de la columna.
- Configuración del servidor.
The following features are planned for development:
Las siguientes características están planificadas para el desarrollo:
- Database management.
- User management.
- Real-time data analysis.
- Cluster monitoring.
- Cluster management.
- Monitoring replicated and Kafka tables.
- Gestión de bases de datos.
- Gestión de usuarios.
- Análisis de datos en tiempo real.
- Supervisión de clúster.
- Gestión de clústeres.
- Monitoreo de tablas replicadas y Kafka.
### LightHouse {#lighthouse}
### Faro {#lighthouse}
[LightHouse](https://github.com/VKCOM/lighthouse) is a lightweight web interface for ClickHouse.
[Faro](https://github.com/VKCOM/lighthouse) Es una interfaz web ligera para ClickHouse.
Features:
Función:
- Table list with filtering and metadata.
- Table preview with filtering and sorting.
- Read-only queries execution.
- Lista de tablas con filtrado y metadatos.
- Vista previa de la tabla con filtrado y clasificación.
- Ejecución de consultas de sólo lectura.
### Redash {#redash}
[Redash](https://github.com/getredash/redash) is a platform for data visualization.
[Redash](https://github.com/getredash/redash) es una plataforma para la visualización de datos.
Supports for multiple data sources including ClickHouse, Redash can join results of queries from different data sources into one final dataset.
Admite múltiples fuentes de datos, incluido ClickHouse, Redash puede unir los resultados de consultas de diferentes fuentes de datos en un conjunto de datos final.
Features:
Función:
- Powerful editor of queries.
- Database explorer.
- Visualization tools, that allow you to represent data in different forms.
- Potente editor de consultas.
- Explorador de base de datos.
- Herramientas de visualización, que le permiten representar datos en diferentes formas.
### DBeaver {#dbeaver}
[DBeaver](https://dbeaver.io/) - universal desktop database client with ClickHouse support.
[DBeaver](https://dbeaver.io/) - Cliente de base de datos de escritorio universal con soporte ClickHouse.
Features:
Función:
- Query development with syntax highlight and autocompletion.
- Table list with filters and metadata search.
- Table data preview.
- Full-text search.
- Desarrollo de consultas con resaltado de sintaxis y autocompletado.
- Lista de tablas con filtros y búsqueda de metadatos.
- Vista previa de datos de tabla.
- Búsqueda de texto completo.
### clickhouse-cli {#clickhouse-cli}
### Sistema abierto. {#clickhouse-cli}
[clickhouse-cli](https://github.com/hatarist/clickhouse-cli) is an alternative command-line client for ClickHouse, written in Python 3.
[Sistema abierto.](https://github.com/hatarist/clickhouse-cli) es un cliente de línea de comandos alternativo para ClickHouse, escrito en Python 3.
Features:
Función:
- Autocompletion.
- Syntax highlighting for the queries and data output.
- Pager support for the data output.
- Custom PostgreSQL-like commands.
- Autocompletado.
- Resaltado de sintaxis para las consultas y la salida de datos.
- Soporte de buscapersonas para la salida de datos.
- Comandos similares a PostgreSQL personalizados.
### clickhouse-flamegraph {#clickhouse-flamegraph}
### Sistema abierto. {#clickhouse-flamegraph}
[clickhouse-flamegraph](https://github.com/Slach/clickhouse-flamegraph) is a specialized tool to visualize the `system.trace_log` as [flamegraph](http://www.brendangregg.com/flamegraphs.html).
[Sistema abierto.](https://github.com/Slach/clickhouse-flamegraph) es una herramienta especializada para visualizar el `system.trace_log` como [Gráfico de llamas](http://www.brendangregg.com/flamegraphs.html).
## Commercial {#commercial}
## Comercial {#commercial}
### DataGrip {#datagrip}
[DataGrip](https://www.jetbrains.com/datagrip/) is a database IDE from JetBrains with dedicated support for ClickHouse. It is also embedded in other IntelliJ-based tools: PyCharm, IntelliJ IDEA, GoLand, PhpStorm and others.
[DataGrip](https://www.jetbrains.com/datagrip/) Es un IDE de base de datos de JetBrains con soporte dedicado para ClickHouse. También está integrado en otras herramientas basadas en IntelliJ: PyCharm, IntelliJ IDEA, GoLand, PhpStorm y otros.
Features:
Función:
- Very fast code completion.
- ClickHouse syntax highlighting.
- Support for features specific to ClickHouse, for example, nested columns, table engines.
- Data Editor.
- Refactorings.
- Search and Navigation.
- Finalización de código muy rápida.
- Resaltado de sintaxis de ClickHouse.
- Soporte para características específicas de ClickHouse, por ejemplo, columnas anidadas, motores de tablas.
- Editor de datos.
- Refactorizaciones.
- Búsqueda y navegación.
### Yandex DataLens {#yandex-datalens}
[Yandex DataLens](https://cloud.yandex.ru/services/datalens) is a service of data visualization and analytics.
[Yandex DataLens](https://cloud.yandex.ru/services/datalens) es un servicio de visualización y análisis de datos.
Features:
Función:
- Wide range of available visualizations, from simple bar charts to complex dashboards.
- Dashboards could be made publicly available.
- Support for multiple data sources including ClickHouse.
- Storage for materialized data based on ClickHouse.
- Amplia gama de visualizaciones disponibles, desde simples gráficos de barras hasta paneles complejos.
- Los paneles podrían ponerse a disposición del público.
- Soporte para múltiples fuentes de datos, incluyendo ClickHouse.
- Almacenamiento de datos materializados basados en ClickHouse.
DataLens is [available for free](https://cloud.yandex.com/docs/datalens/pricing) for low-load projects, even for commercial use.
Nivel de Cifrado WEP [disponible de forma gratuita](https://cloud.yandex.com/docs/datalens/pricing) para proyectos de baja carga, incluso para uso comercial.
- [DataLens documentation](https://cloud.yandex.com/docs/datalens/).
- [Tutorial](https://cloud.yandex.com/docs/solutions/datalens/data-from-ch-visualization) on visualizing data from a ClickHouse database.
- [Documentación de DataLens](https://cloud.yandex.com/docs/datalens/).
- [Tutorial](https://cloud.yandex.com/docs/solutions/datalens/data-from-ch-visualization) en la visualización de datos de una base de datos ClickHouse.
### Holistics Software {#holistics-software}
### Software de Holística {#holistics-software}
[Holistics](https://www.holistics.io/) is a full-stack data platform and business intelligence tool.
[Holística](https://www.holistics.io/) Este es una plataforma de datos de pila completa y una herramienta de inteligencia de negocios.
Features:
Función:
- Automated email, Slack and Google Sheet schedules of reports.
- SQL editor with visualizations, version control, auto-completion, reusable query components and dynamic filters.
- Embedded analytics of reports and dashboards via iframe.
- Data preparation and ETL capabilities.
- SQL data modelling support for relational mapping of data.
- Correo electrónico automatizado, Slack y horarios de informes de Google Sheet.
- Editor SQL con visualizaciones, control de versiones, autocompletado, componentes de consulta reutilizables y filtros dinámicos.
- Análisis integrado de informes y cuadros de mando a través de iframe.
- Preparación de datos y capacidades ETL.
- Soporte de modelado de datos SQL para mapeo relacional de datos.
### Looker {#looker}
### Mirador {#looker}
[Looker](https://looker.com) is a data platform and business intelligence tool with support for 50+ database dialects including ClickHouse. Looker is available as a SaaS platform and self-hosted. Users can use Looker via the browser to explore data, build visualizations and dashboards, schedule reports, and share their insights with colleagues. Looker provides a rich set of tools to embed these features in other applications, and an API
to integrate data with other applications.
[Mirador](https://looker.com) Es una plataforma de datos y una herramienta de inteligencia de negocios con soporte para más de 50 dialectos de bases de datos, incluido ClickHouse. Bravo está disponible como una plataforma SaaS y auto-organizada. Los usuarios pueden utilizar Looker a través del navegador para explorar datos, crear visualizaciones y paneles, programar informes y compartir sus conocimientos con colegas. Looker proporciona un amplio conjunto de herramientas para incrustar estas características en otras aplicaciones y una API
para integrar datos con otras aplicaciones.
Features:
Función:
- Easy and agile development using LookML, a language which supports curated
[Data Modeling](https://looker.com/platform/data-modeling) to support report writers and end-users.
- Powerful workflow integration via Looker’s [Data Actions](https://looker.com/platform/actions).
- Desarrollo fácil y ágil utilizando LookML, un lenguaje que soporta curado
[Modelado de datos](https://looker.com/platform/data-modeling) para apoyar a los redactores de informes y a los usuarios finales.
- Potente integración de flujo de trabajo a través de Looker's [Acciones de datos](https://looker.com/platform/actions).
[How to configure ClickHouse in Looker.](https://docs.looker.com/setup-and-management/database-config/clickhouse)
[Cómo configurar ClickHouse en Looker.](https://docs.looker.com/setup-and-management/database-config/clickhouse)
[Original article](https://clickhouse.tech/docs/es/interfaces/third-party/gui/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/interfaces/third-party/gui/) <!--hide-->

116
docs/es/interfaces/third-party/integrations.md vendored
View File

@ -1,88 +1,88 @@
# Integration Libraries from Third-party Developers {#integration-libraries-from-third-party-developers}
# Bibliotecas de integración de desarrolladores externos {#integration-libraries-from-third-party-developers}
!!! warning "Disclaimer"
Yandex does **not** maintain the tools and libraries listed below and haven’t done any extensive testing to ensure their quality.
!!! warning "Descargo"
Yandex hace **ni** mantenga las herramientas y bibliotecas que se enumeran a continuación y no haya realizado ninguna prueba extensa para garantizar su calidad.
## Infrastructure Products {#infrastructure-products}
## Productos de infraestructura {#infrastructure-products}
- Relational database management systems
- Sistemas de gestión de bases de datos relacionales
- [MySQL](https://www.mysql.com)
- [ProxySQL](https://github.com/sysown/proxysql/wiki/ClickHouse-Support)
- [clickhouse-mysql-data-reader](https://github.com/Altinity/clickhouse-mysql-data-reader)
- [horgh-replicator](https://github.com/larsnovikov/horgh-replicator)
- [Nombre de la red inalámbrica (SSID):](https://github.com/sysown/proxysql/wiki/ClickHouse-Support)
- [Casa de clic-mysql-lector de datos](https://github.com/Altinity/clickhouse-mysql-data-reader)
- [Horgh-replicador](https://github.com/larsnovikov/horgh-replicator)
- [PostgreSQL](https://www.postgresql.org)
- [clickhousedb\_fdw](https://github.com/Percona-Lab/clickhousedb_fdw)
- [infi.clickhouse\_fdw](https://github.com/Infinidat/infi.clickhouse_fdw) (uses [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm))
- [pg2ch](https://github.com/mkabilov/pg2ch)
- [clickhouse\_fdw](https://github.com/adjust/clickhouse_fdw)
- [Haga clickhousedb\_fdw](https://github.com/Percona-Lab/clickhousedb_fdw)
- [InformaciónSistema abierto.](https://github.com/Infinidat/infi.clickhouse_fdw) (utilizar [InformaciónSistema abierto.](https://github.com/Infinidat/infi.clickhouse_orm))
- [Descripción](https://github.com/mkabilov/pg2ch)
- [Sistema abierto.](https://github.com/adjust/clickhouse_fdw)
- [MSSQL](https://en.wikipedia.org/wiki/Microsoft_SQL_Server)
- [ClickHouseMigrator](https://github.com/zlzforever/ClickHouseMigrator)
- Message queues
- [Método de codificación de datos:](https://github.com/zlzforever/ClickHouseMigrator)
- Colas de mensajes
- [Kafka](https://kafka.apache.org)
- [clickhouse\_sinker](https://github.com/housepower/clickhouse_sinker) (uses [Go client](https://github.com/kshvakov/clickhouse/))
- Object storages
- [Método de codificación de datos:](https://github.com/housepower/clickhouse_sinker) (utilizar [Ir cliente](https://github.com/kshvakov/clickhouse/))
- Almacenamiento de objetos
- [S3](https://en.wikipedia.org/wiki/Amazon_S3)
- [clickhouse-backup](https://github.com/AlexAkulov/clickhouse-backup)
- Container orchestration
- [Haga clic en el botón de copia de seguridad](https://github.com/AlexAkulov/clickhouse-backup)
- Orquestación de contenedores
- [Kubernetes](https://kubernetes.io)
- [clickhouse-operator](https://github.com/Altinity/clickhouse-operator)
- Configuration management
- [puppet](https://puppet.com)
- [innogames/clickhouse](https://forge.puppet.com/innogames/clickhouse)
- [mfedotov/clickhouse](https://forge.puppet.com/mfedotov/clickhouse)
- Monitoring
- [Graphite](https://graphiteapp.org)
- [Operador de clickhouse](https://github.com/Altinity/clickhouse-operator)
- Gestión de configuración
- [marioneta](https://puppet.com)
- [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://forge.puppet.com/innogames/clickhouse)
- [Sistema abierto.](https://forge.puppet.com/mfedotov/clickhouse)
- Monitoreo
- [Grafito](https://graphiteapp.org)
- [graphouse](https://github.com/yandex/graphouse)
- [carbon-clickhouse](https://github.com/lomik/carbon-clickhouse) +
- [graphite-clickhouse](https://github.com/lomik/graphite-clickhouse)
- [graphite-ch-optimizer](https://github.com/innogames/graphite-ch-optimizer) - optimizes staled partitions in [\*GraphiteMergeTree](../../operations/table_engines/graphitemergetree.md#graphitemergetree) if rules from [rollup configuration](../../operations/table_engines/graphitemergetree.md#rollup-configuration) could be applied
- [de carbono-clickhouse](https://github.com/lomik/carbon-clickhouse) +
- [Sistema abierto.](https://github.com/lomik/graphite-clickhouse)
- [Grafito-ch-optimizador](https://github.com/innogames/graphite-ch-optimizer) - optimiza las particiones [\*GraphiteMergeTree](../../operations/table_engines/graphitemergetree.md#graphitemergetree) reglas de [Configuración de rollup](../../operations/table_engines/graphitemergetree.md#rollup-configuration) podría ser aplicado
- [Grafana](https://grafana.com/)
- [clickhouse-grafana](https://github.com/Vertamedia/clickhouse-grafana)
- [Prometheus](https://prometheus.io/)
- [clickhouse\_exporter](https://github.com/f1yegor/clickhouse_exporter)
- [PromHouse](https://github.com/Percona-Lab/PromHouse)
- [clickhouse\_exporter](https://github.com/hot-wifi/clickhouse_exporter) (uses [Go client](https://github.com/kshvakov/clickhouse/))
- [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://github.com/Vertamedia/clickhouse-grafana)
- [Prometeo](https://prometheus.io/)
- [Sistema abierto.](https://github.com/f1yegor/clickhouse_exporter)
- [Bienvenido](https://github.com/Percona-Lab/PromHouse)
- [Sistema abierto.](https://github.com/hot-wifi/clickhouse_exporter) (utilizar [Ir cliente](https://github.com/kshvakov/clickhouse/))
- [Nagios](https://www.nagios.org/)
- [check\_clickhouse](https://github.com/exogroup/check_clickhouse/)
- [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://github.com/exogroup/check_clickhouse/)
- [Zabbix](https://www.zabbix.com)
- [clickhouse-zabbix-template](https://github.com/Altinity/clickhouse-zabbix-template)
- [Sistema abierto.](https://github.com/Altinity/clickhouse-zabbix-template)
- [Sematext](https://sematext.com/)
- [clickhouse integration](https://github.com/sematext/sematext-agent-integrations/tree/master/clickhouse)
- Logging
- [integración clickhouse](https://github.com/sematext/sematext-agent-integrations/tree/master/clickhouse)
- Tala
- [rsyslog](https://www.rsyslog.com/)
- [omclickhouse](https://www.rsyslog.com/doc/master/configuration/modules/omclickhouse.html)
- [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://www.rsyslog.com/doc/master/configuration/modules/omclickhouse.html)
- [fluentd](https://www.fluentd.org)
- [loghouse](https://github.com/flant/loghouse) (for [Kubernetes](https://kubernetes.io))
- [logagent](https://www.sematext.com/logagent)
- [logagent output-plugin-clickhouse](https://sematext.com/docs/logagent/output-plugin-clickhouse/)
- [Casa de campo](https://github.com/flant/loghouse) (para [Kubernetes](https://kubernetes.io))
- [Información](https://www.sematext.com/logagent)
- [Sistema de tabiquería interior y exterior](https://sematext.com/docs/logagent/output-plugin-clickhouse/)
- Geo
- [MaxMind](https://dev.maxmind.com/geoip/)
- [clickhouse-maxmind-geoip](https://github.com/AlexeyKupershtokh/clickhouse-maxmind-geoip)
- [Para que usted pueda encontrar](https://github.com/AlexeyKupershtokh/clickhouse-maxmind-geoip)
## Programming Language Ecosystems {#programming-language-ecosystems}
## Programación de ecosistemas de lenguaje {#programming-language-ecosystems}
- Python
- Película
- [SQLAlchemy](https://www.sqlalchemy.org)
- [sqlalchemy-clickhouse](https://github.com/cloudflare/sqlalchemy-clickhouse) (uses [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm))
- [sqlalchemy-clickhouse](https://github.com/cloudflare/sqlalchemy-clickhouse) (utilizar [InformaciónSistema abierto.](https://github.com/Infinidat/infi.clickhouse_orm))
- [pandas](https://pandas.pydata.org)
- [pandahouse](https://github.com/kszucs/pandahouse)
- [Nuestros Servicios](https://github.com/kszucs/pandahouse)
- R
- [dplyr](https://db.rstudio.com/dplyr/)
- [RClickhouse](https://github.com/IMSMWU/RClickhouse) (uses [clickhouse-cpp](https://github.com/artpaul/clickhouse-cpp))
- [Dplyr](https://db.rstudio.com/dplyr/)
- [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://github.com/IMSMWU/RClickhouse) (utilizar [Bienvenidos](https://github.com/artpaul/clickhouse-cpp))
- Java
- [Hadoop](http://hadoop.apache.org)
- [clickhouse-hdfs-loader](https://github.com/jaykelin/clickhouse-hdfs-loader) (uses [JDBC](../../query_language/table_functions/jdbc.md))
- Scala
- [Sistema abierto.](https://github.com/jaykelin/clickhouse-hdfs-loader) (utilizar [JDBC](../../query_language/table_functions/jdbc.md))
- Ciudad
- [Akka](https://akka.io)
- [clickhouse-scala-client](https://github.com/crobox/clickhouse-scala-client)
- [Sistema abierto.](https://github.com/crobox/clickhouse-scala-client)
- C\#
- [ADO.NET](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/ado-net-overview)
- [ClickHouse.Ado](https://github.com/killwort/ClickHouse-Net)
- [ClickHouse.Client](https://github.com/DarkWanderer/ClickHouse.Client)
- [ClickHouse.Net](https://github.com/ilyabreev/ClickHouse.Net)
- [ClickHouse.Net.Migrations](https://github.com/ilyabreev/ClickHouse.Net.Migrations)
- [Nivel de Cifrado WEP](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/ado-net-overview)
- [Sistema abierto.Ado](https://github.com/killwort/ClickHouse-Net)
- [Sistema abierto.Cliente](https://github.com/DarkWanderer/ClickHouse.Client)
- [Sistema abierto.](https://github.com/ilyabreev/ClickHouse.Net)
- [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://github.com/ilyabreev/ClickHouse.Net.Migrations)
- Elixir
- [Ecto](https://github.com/elixir-ecto/ecto)
- [clickhouse\_ecto](https://github.com/appodeal/clickhouse_ecto)
- [Método de codificación de datos:](https://github.com/appodeal/clickhouse_ecto)
[Original article](https://clickhouse.tech/docs/es/interfaces/third-party/integrations/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/interfaces/third-party/integrations/) <!--hide-->

44
docs/es/interfaces/third-party/proxy.md vendored
View File

@ -1,39 +1,39 @@
# Proxy Servers from Third-party Developers {#proxy-servers-from-third-party-developers}
# Servidores proxy de desarrolladores de terceros {#proxy-servers-from-third-party-developers}
## chproxy {#chproxy}
[chproxy](https://github.com/Vertamedia/chproxy), is an HTTP proxy and load balancer for ClickHouse database.
[chproxy](https://github.com/Vertamedia/chproxy), es un proxy HTTP y equilibrador de carga para la base de datos ClickHouse.
Features:
Función:
- Per-user routing and response caching.
- Flexible limits.
- Automatic SSL certificate renewal.
- Enrutamiento por usuario y almacenamiento en caché de respuestas.
- Flexible límites.
- Renovación automática del certificado SSL.
Implemented in Go.
Implementado en Go.
## KittenHouse {#kittenhouse}
## Bienvenido a WordPress. {#kittenhouse}
[KittenHouse](https://github.com/VKCOM/kittenhouse) is designed to be a local proxy between ClickHouse and application server in case it’s impossible or inconvenient to buffer INSERT data on your application side.
[Bienvenido a WordPress.](https://github.com/VKCOM/kittenhouse) está diseñado para ser un proxy local entre ClickHouse y el servidor de aplicaciones en caso de que sea imposible o inconveniente almacenar los datos INSERT en el lado de su aplicación.
Features:
Función:
- In-memory and on-disk data buffering.
- Per-table routing.
- Load-balancing and health checking.
- Almacenamiento en búfer de datos en memoria y en disco.
- Enrutamiento por tabla.
- Equilibrio de carga y comprobación de estado.
Implemented in Go.
Implementado en Go.
## ClickHouse-Bulk {#clickhouse-bulk}
## Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica {#clickhouse-bulk}
[ClickHouse-Bulk](https://github.com/nikepan/clickhouse-bulk) is a simple ClickHouse insert collector.
[Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://github.com/nikepan/clickhouse-bulk) es un simple colector de insertos ClickHouse.
Features:
Función:
- Group requests and send by threshold or interval.
- Multiple remote servers.
- Basic authentication.
- Agrupe las solicitudes y envíe por umbral o intervalo.
- Múltiples servidores remotos.
- Autenticación básica.
Implemented in Go.
Implementado en Go.
[Original article](https://clickhouse.tech/docs/es/interfaces/third-party/proxy/) <!--hide-->
[Artículo Original](https://clickhouse.tech/docs/es/interfaces/third-party/proxy/) <!--hide-->

16
docs/es/introduction/adopters.md
View File

@ -17,9 +17,9 @@
| `Dataliance/UltraPower` | Telecomunicaciones | Analítica | — | — | [Diapositivas en chino, enero 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup12/telecom.pdf) |
| [CARTO](https://carto.com/) | Inteligencia de negocios | Análisis geográfico | — | — | [Procesamiento geoespacial con Clickhouse](https://carto.com/blog/geospatial-processing-with-clickhouse/) |
| [CERN](http://public.web.cern.ch/public/) | Investigación | Experimento | — | — | [Comunicado de prensa, abril de 2012](https://www.yandex.com/company/press_center/press_releases/2012/2012-04-10/) |
| [Cisco](http://cisco.com/) | Red | Análisis de tráfico | — | — | [Charla relámpago, octubre 2019](https://youtu.be/-hI1vDR2oPY?t=5057) |
| [Cisco](http://cisco.com/) | Rojo | Análisis de tráfico | — | — | [Charla relámpago, octubre 2019](https://youtu.be/-hI1vDR2oPY?t=5057) |
| [Valores de la ciudadela](https://www.citadelsecurities.com/) | Financiación | — | — | — | [Contribución, marzo 2019](https://github.com/ClickHouse/ClickHouse/pull/4774) |
| [Más información](https://city-mobil.ru) | Taxi | Analítica | — | — | [Blog Post en ruso, marzo 2020](https://habr.com/en/company/citymobil/blog/490660/) |
| [Más información](https://city-mobil.ru) | Taxi | Analítica | — | — | [Entrada de Blog en ruso, marzo de 2020](https://habr.com/en/company/citymobil/blog/490660/) |
| [ContentSquare](https://contentsquare.com) | Análisis web | Producto principal | — | — | [Publicación de blog en francés, noviembre 2018](http://souslecapot.net/2018/11/21/patrick-chatain-vp-engineering-chez-contentsquare-penser-davantage-amelioration-continue-que-revolution-constante/) |
| [Cloudflare](https://cloudflare.com) | CDN | Análisis de tráfico | 36 servidores | — | [Mensaje del blog, Mayo 2017](https://blog.cloudflare.com/how-cloudflare-analyzes-1m-dns-queries-per-second/), [Mensaje del blog, marzo 2018](https://blog.cloudflare.com/http-analytics-for-6m-requests-per-second-using-clickhouse/) |
| [Corunet](https://coru.net/) | Analítica | Producto principal | — | — | [Diapositivas en español, Abril 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup21/predictive_models.pdf) |
@ -28,26 +28,26 @@
| [Banco de Deutsche](https://db.com) | Financiación | BI Analytics | — | — | [Diapositivas en español, octubre 2019](https://bigdatadays.ru/wp-content/uploads/2019/10/D2-H3-3_Yakunin-Goihburg.pdf) |
| [Diva-e](https://www.diva-e.com) | Consultoría digital | Producto principal | — | — | [Diapositivas en español, septiembre 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup29/ClickHouse-MeetUp-Unusual-Applications-sd-2019-09-17.pdf) |
| [Exness](https://www.exness.com) | Comercio | Métricas, Registro | — | — | [Charla en ruso, mayo 2019](https://youtu.be/_rpU-TvSfZ8?t=3215) |
| [Sistema abierto.](https://geniee.co.jp) | Red Ad | Producto principal | — | — | [Publicación de blog en japonés, julio 2017](https://tech.geniee.co.jp/entry/2017/07/20/160100) |
| [Sistema abierto.](https://geniee.co.jp) | Anuncio rojo | Producto principal | — | — | [Publicación de blog en japonés, julio 2017](https://tech.geniee.co.jp/entry/2017/07/20/160100) |
| [HUYA](https://www.huya.com/) | Video Streaming | Analítica | — | — | [Diapositivas en chino, octubre 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup19/7.%20ClickHouse万亿数据分析实践%20李本旺(sundy-li)%20虎牙.pdf) |
| [Idealista](https://www.idealista.com) | Inmobiliario | Analítica | — | — | [Blog Post en Inglés, Abril 2019](https://clickhouse.yandex/blog/en/clickhouse-meetup-in-madrid-on-april-2-2019) |
| [Infovista](https://www.infovista.com/) | Red | Analítica | — | — | [Diapositivas en español, octubre 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup30/infovista.pdf) |
| [Infovista](https://www.infovista.com/) | Rojo | Analítica | — | — | [Diapositivas en español, octubre 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup30/infovista.pdf) |
| [InnoGames](https://www.innogames.com) | Juego | Métricas, Registro | — | — | [Diapositivas en ruso, septiembre 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup28/graphite_and_clickHouse.pdf) |
| [Integros](https://integros.com) | Plataforma para servicios de video | Analítica | — | — | [Diapositivas en ruso, mayo 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup22/strategies.pdf) |
| [Datos de Kodiak](https://www.kodiakdata.com/) | Nube | Producto principal | — | — | [Diapositivas en Engish, Abril 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup13/kodiak_data.pdf) |
| [Kontur](https://kontur.ru) | Desarrollo de software | Métricas | — | — | [Charla en ruso, noviembre 2018](https://www.youtube.com/watch?v=U4u4Bd0FtrY) |
| [Sistema abierto.](https://lifestreet.com/) | Red Ad | Producto principal | 75 servidores (3 réplicas) | 5.27 PiB | [Publicación de blog en ruso, febrero 2017](https://habr.com/en/post/322620/) |
| [Sistema abierto.](https://lifestreet.com/) | Anuncio rojo | Producto principal | 75 servidores (3 réplicas) | 5.27 PiB | [Publicación de blog en ruso, febrero 2017](https://habr.com/en/post/322620/) |
| [Soluciones en la nube de Mail.ru](https://mcs.mail.ru/) | Servicios en la nube | Producto principal | — | — | [Ejecución de ClickHouse Instance, en ruso](https://mcs.mail.ru/help/db-create/clickhouse#) |
| [Mensaje de pájaro](https://www.messagebird.com) | Telecomunicaciones | Estadísticas | — | — | [Diapositivas en español, noviembre 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup20/messagebird.pdf) |
| [MGID](https://www.mgid.com/) | Red Ad | Analítica Web | — | — | [Nuestra experiencia en la implementación analítica DBMS ClickHouse, en ruso](http://gs-studio.com/news-about-it/32777----clickhouse---c) |
| [MGID](https://www.mgid.com/) | Anuncio rojo | Analítica Web | — | — | [Nuestra experiencia en la implementación analítica DBMS ClickHouse, en ruso](http://gs-studio.com/news-about-it/32777----clickhouse---c) |
| [UnoAPM](https://www.oneapm.com/) | Supervisión y análisis de datos | Producto principal | — | — | [Diapositivas en chino, octubre 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup19/8.%20clickhouse在OneAPM的应用%20杜龙.pdf) |
| [Pragma Innovación](http://www.pragma-innovation.fr/) | Telemetría y Análisis de Big Data | Producto principal | — | — | [Diapositivas en español, octubre 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup18/4_pragma_innovation.pdf) |
| [QINGCLOUD](https://www.qingcloud.com/) | Servicios en la nube | Producto principal | — | — | [Diapositivas en chino, octubre 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup19/4.%20Cloud%20%2B%20TSDB%20for%20ClickHouse%20张健%20QingCloud.pdf) |
| [Qrator](https://qrator.net) | Protección DDoS | Producto principal | — | — | [Blog Post, marzo 2019](https://blog.qrator.net/en/clickhouse-ddos-mitigation_37/) |
| [Qrator](https://qrator.net) | Protección DDoS | Producto principal | — | — | [Mensaje del blog, marzo 2019](https://blog.qrator.net/en/clickhouse-ddos-mitigation_37/) |
| [Tecnología de la información del PORCIMIENTO de Pekín Co., Ltd.](https://www.percent.cn/) | Analítica | Producto principal | — | — | [Diapositivas en chino, junio 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup24/4.%20ClickHouse万亿数据双中心的设计与实践%20.pdf) |
| [Rambler](https://rambler.ru) | Servicios de Internet | Analítica | — | — | [Charla en ruso, abril 2018](https://medium.com/@ramblertop/разработка-api-clickhouse-для-рамблер-топ-100-f4c7e56f3141) |
| [Tencent](https://www.tencent.com) | Mensajería | Tala | — | — | [Charla en chino, noviembre 2019](https://youtu.be/T-iVQRuw-QY?t=5050) |
| [Estrellas de tráfico](https://trafficstars.com/) | Red AD | — | — | — | [Diapositivas en ruso, mayo 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup15/lightning/ninja.pdf) |
| [Estrellas de tráfico](https://trafficstars.com/) | Anuncio rojo | — | — | — | [Diapositivas en ruso, mayo 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup15/lightning/ninja.pdf) |
| [S7 Aerolíneas](https://www.s7.ru) | Aérea | Métricas, Registro | — | — | [Charla en ruso, marzo 2019](https://www.youtube.com/watch?v=nwG68klRpPg&t=15s) |
| [SEMrush](https://www.semrush.com/) | Marketing | Producto principal | — | — | [Diapositivas en ruso, agosto 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup17/5_semrush.pdf) |
| [Inicio](https://www.scireum.de/) | Comercio electrónico | Producto principal | — | — | [Charla en alemán, febrero de 2020](https://www.youtube.com/watch?v=7QWAn5RbyR4) |

2
docs/es/introduction/history.md
View File

@ -6,7 +6,7 @@ El Yandex.Metrica construye informes personalizados sobre la marcha basados en h
A partir de abril de 2014, Yandex.Metrica estaba rastreando alrededor de 12 mil millones de eventos (vistas de páginas y clics) diariamente. Todos estos eventos deben almacenarse para crear informes personalizados. Una sola consulta puede requerir escanear millones de filas en unos pocos cientos de milisegundos, o cientos de millones de filas en solo unos segundos.
## Uso en Yandex.Metrica y otros servicios de Yandex {#usage-in-yandex-metrica-and-other-yandex-services}
## Uso en el Yandex.Metrica y otros servicios de Yandex {#usage-in-yandex-metrica-and-other-yandex-services}
ClickHouse se utiliza para múltiples propósitos en Yandex.Métrica.
Su tarea principal es crear informes en modo en línea utilizando datos no agregados. Utiliza un clúster de 374 servidores, que almacenan más de 20,3 billones de filas en la base de datos. El volumen de datos comprimidos, sin contar la duplicación y la replicación, es de aproximadamente 2 PB. El volumen de datos sin comprimir (en formato TSV) sería de aproximadamente 17 PB.

2
docs/es/operations/access_rights.md
View File

@ -99,7 +99,7 @@ En el opcional `<allow_dictionaries>` sección, también puede especificar una l
Acceso a la `system` base de datos siempre está permitida (ya que esta base de datos se utiliza para procesar consultas).
El usuario puede obtener una lista de todas las bases de datos y tablas en ellos mediante el uso de `SHOW` consultas o tablas del sistema, incluso si no se permite el acceso a bases de datos individuales.
El usuario puede obtener una lista de todas las bases de datos y tablas en ellos mediante el uso de `SHOW` Consultas o tablas del sistema, incluso si no se permite el acceso a bases de datos individuales.
El acceso a la base de datos no está [sólo lectura](settings/permissions_for_queries.md#settings_readonly) configuración. No puede conceder acceso completo a una base de datos y `readonly` acceso a otro.

2
docs/es/operations/backup.md
View File

@ -25,7 +25,7 @@ Para volúmenes de datos más pequeños, un simple `INSERT INTO ... SELECT ...`
## Manipulaciones con piezas {#manipulations-with-parts}
ClickHouse permite usar el `ALTER TABLE ... FREEZE PARTITION ...` consulta para crear una copia local de particiones de tabla. Esto se implementa utilizando enlaces duros al `/var/lib/clickhouse/shadow/` carpeta, por lo que generalmente no consume espacio adicional en disco para datos antiguos. Las copias creadas de archivos no son manejadas por el servidor ClickHouse, por lo que puede dejarlos allí: tendrá una copia de seguridad simple que no requiere ningún sistema externo adicional, pero aún así será propenso a problemas de hardware. Por esta razón, es mejor copiarlos de forma remota en otra ubicación y luego eliminar las copias locales. Los sistemas de archivos distribuidos y los almacenes de objetos siguen siendo una buena opción para esto, pero los servidores de archivos conectados normales con una capacidad lo suficientemente grande podrían funcionar también (en este caso, la transferencia ocurrirá a través del sistema de archivos de red o tal vez [rsync](https://en.wikipedia.org/wiki/Rsync)).
Haz clickHouse permite usar el `ALTER TABLE ... FREEZE PARTITION ...` consulta para crear una copia local de particiones de tabla. Esto se implementa utilizando enlaces duros al `/var/lib/clickhouse/shadow/` carpeta, por lo que generalmente no consume espacio adicional en disco para datos antiguos. Las copias creadas de archivos no son manejadas por el servidor ClickHouse, por lo que puede dejarlos allí: tendrá una copia de seguridad simple que no requiere ningún sistema externo adicional, pero aún así será propenso a problemas de hardware. Por esta razón, es mejor copiarlos de forma remota en otra ubicación y luego eliminar las copias locales. Los sistemas de archivos distribuidos y los almacenes de objetos siguen siendo una buena opción para esto, pero los servidores de archivos conectados normales con una capacidad lo suficientemente grande podrían funcionar también (en este caso, la transferencia ocurrirá a través del sistema de archivos de red o tal vez [rsync](https://en.wikipedia.org/wiki/Rsync)).
Para obtener más información sobre las consultas relacionadas con las manipulaciones de particiones, consulte [Documentación de ALTER](../query_language/alter.md#alter_manipulations-with-partitions).

6
docs/es/operations/configuration_files.md
View File

@ -1,6 +1,6 @@
# Archivos de configuración {#configuration-files}
ClickHouse admite la administración de configuración de varios archivos. El archivo de configuración del servidor principal es `/etc/clickhouse-server/config.xml`. Otros archivos deben estar en el `/etc/clickhouse-server/config.d` directorio.
ClickHouse admite la administración de configuración de varios archivos. El archivo de configuración del servidor principal es `/etc/clickhouse-server/config.xml`. Otros archivos deben estar en el `/etc/clickhouse-server/config.d` Directorio.
!!! note "Nota"
Todos los archivos de configuración deben estar en formato XML. Además, deben tener el mismo elemento raíz, generalmente `<yandex>`.
@ -13,13 +13,13 @@ Si `replace` se especifica, reemplaza todo el elemento por el especificado.
Si `remove` se especifica, elimina el elemento.
La configuración también puede definir “substitutions”. Si un elemento tiene el `incl` atributo, la sustitución correspondiente del archivo se utilizará como el valor. De forma predeterminada, la ruta al archivo con sustituciones es `/etc/metrika.xml`. Esto se puede cambiar en el [include\_from](server_settings/settings.md#server_settings-include_from) elemento en la configuración del servidor. Los valores de sustitución se especifican en `/yandex/substitution_name` elementos en este archivo. Si una sustitución especificada en `incl` no existe, se registra en el registro. Para evitar que ClickHouse registre las sustituciones que faltan, especifique `optional="true"` atributo (por ejemplo, ajustes para [macro](server_settings/settings.md)).
La configuración también puede definir “substitutions”. Si un elemento tiene el `incl` atributo, la sustitución correspondiente del archivo se utilizará como el valor. De forma predeterminada, la ruta al archivo con sustituciones es `/etc/metrika.xml`. Esto se puede cambiar en el [include\_from](server_settings/settings.md#server_settings-include_from) elemento en la configuración del servidor. Los valores de sustitución se especifican en `/yandex/substitution_name` elementos en este archivo. Si una sustitución especificada en `incl` No existe, se registra en el registro. Para evitar que ClickHouse registre las sustituciones que faltan, especifique `optional="true"` atributo (por ejemplo, ajustes para [macro](server_settings/settings.md)).
Las sustituciones también se pueden realizar desde ZooKeeper. Para hacer esto, especifique el atributo `from_zk = "/path/to/node"`. El valor del elemento se sustituye por el contenido del nodo en `/path/to/node` en ZooKeeper. También puede colocar un subárbol XML completo en el nodo ZooKeeper y se insertará completamente en el elemento de origen.
El `config.xml` file puede especificar una configuración separada con configuraciones de usuario, perfiles y cuotas. La ruta relativa a esta configuración se establece en el ‘users\_config’ elemento. Por defecto, es `users.xml`. Si `users_config` se omite, la configuración de usuario, los perfiles y las cuotas se especifican directamente en `config.xml`.
Además, `users_config` puede tener anulaciones en los archivos `users_config.d` directorio (por ejemplo, `users.d`) y sustituciones. Por ejemplo, puede tener un archivo de configuración separado para cada usuario como este:
Además, `users_config` puede tener anulaciones en los archivos `users_config.d` Directorio (por ejemplo, `users.d`) y sustituciones. Por ejemplo, puede tener un archivo de configuración separado para cada usuario como este:
``` bash
$ cat /etc/clickhouse-server/users.d/alice.xml

4
docs/es/operations/monitoring.md
View File

@ -23,7 +23,7 @@ El servidor ClickHouse tiene instrumentos integrados para el monitoreo de estado
Para realizar un seguimiento de los eventos del servidor, use los registros del servidor. Ver el [registrador](server_settings/settings.md#server_settings-logger) sección del archivo de configuración.
ClickHouse recoge:
Recoge de ClickHouse:
- Diferentes métricas de cómo el servidor utiliza recursos computacionales.
- Estadísticas comunes sobre el procesamiento de consultas.
@ -32,6 +32,6 @@ Puede encontrar métricas en el [sistema.métricas](system_tables.md#system_tabl
Puede configurar ClickHouse para exportar métricas a [Grafito](https://github.com/graphite-project). Ver el [Sección de grafito](server_settings/settings.md#server_settings-graphite) en el archivo de configuración del servidor ClickHouse. Antes de configurar la exportación de métricas, debe configurar Graphite siguiendo sus [guiar](https://graphite.readthedocs.io/en/latest/install.html).
Además, puede supervisar la disponibilidad del servidor a través de la API HTTP. Enviar el `HTTP GET` solicitud de `/ping`. Si el servidor está disponible, responde con `200 OK`.
Además, puede supervisar la disponibilidad del servidor a través de la API HTTP. Enviar el `HTTP GET` Solicitud de `/ping`. Si el servidor está disponible, responde con `200 OK`.
Para supervisar servidores en una configuración de clúster, debe establecer [max\_replica\_delay\_for\_distributed\_queries](settings/settings.md#settings-max_replica_delay_for_distributed_queries) parámetro y utilizar el recurso HTTP `/replicas_status`. Una solicitud para `/replicas_status` devoluciones `200 OK` si la réplica está disponible y no se retrasa detrás de las otras réplicas. Si una réplica se retrasa, devuelve `503 HTTP_SERVICE_UNAVAILABLE` con información sobre la brecha.

4
docs/es/operations/performance/sampling_query_profiler.md
View File

@ -22,9 +22,9 @@ Para analizar el `trace_log` tabla del sistema:
Por razones de seguridad, las funciones de introspección están deshabilitadas de forma predeterminada.
- Utilice el `addressToLine`, `addressToSymbol` y `demangle` [funciones de la introspección](../../query_language/functions/introspection.md) para obtener nombres de funciones y sus posiciones en el código ClickHouse. Para obtener un perfil para alguna consulta, debe agregar datos del `trace_log` tabla. Puede agregar datos por funciones individuales o por los seguimientos de pila completos.
- Descripción `addressToLine`, `addressToSymbol` y `demangle` [funciones de la introspección](../../query_language/functions/introspection.md) para obtener nombres de funciones y sus posiciones en el código ClickHouse. Para obtener un perfil para alguna consulta, debe agregar datos del `trace_log` tabla. Puede agregar datos por funciones individuales o por los seguimientos de pila completos.
Si necesita visualizar `trace_log` información, intente [Flamegraph](../../interfaces/third-party/gui/#clickhouse-flamegraph) y [Nivel de Cifrado WEP](https://github.com/laplab/clickhouse-speedscope).
Si necesita visualizar `trace_log` información, intente [Gráfico de llamas](../../interfaces/third-party/gui/#clickhouse-flamegraph) y [Nivel de Cifrado WEP](https://github.com/laplab/clickhouse-speedscope).
## Ejemplo {#example}

6
docs/es/operations/performance_test.md
View File

@ -2,7 +2,7 @@
Con esta instrucción, puede ejecutar una prueba de rendimiento básica de ClickHouse en cualquier servidor sin instalar paquetes de ClickHouse.
1. Ir a “commits” página: https://github.com/ClickHouse/ClickHouse/commits/master
1. Ir a un “commits” página: https://github.com/ClickHouse/ClickHouse/commits/master
2. Haga clic en la primera marca de verificación verde o cruz roja con verde “ClickHouse Build Check” y haga clic en el “Details” enlace cerca “ClickHouse Build Check”.
@ -19,7 +19,7 @@ Con esta instrucción, puede ejecutar una prueba de rendimiento básica de Click
# Then do:
chmod a+x clickhouse
1. Descargar configs:
1. Descargar configuraciones:
<!-- -->
@ -58,7 +58,7 @@ Con esta instrucción, puede ejecutar una prueba de rendimiento básica de Click
./clickhouse client --query "SELECT count() FROM hits_100m_obfuscated"
100000000
1. Edite el benchmark-new.sh, cambie “clickhouse-client” a “./clickhouse client” y añadir “–max\_memory\_usage 100000000000” parámetro.
1. Edite el benchmark-new.sh, cambie “clickhouse-client” Naciones “./clickhouse client” y añadir “–max\_memory\_usage 100000000000” parámetro.
<!-- -->

8
docs/es/operations/requirements.md
View File

@ -6,7 +6,7 @@ Para la instalación desde paquetes deb precompilados, utilice una CPU con arqui
ClickHouse implementa el procesamiento de datos paralelo y utiliza todos los recursos de hardware disponibles. Al elegir un procesador, tenga en cuenta que ClickHouse funciona de manera más eficiente en configuraciones con un gran número de núcleos pero con una velocidad de reloj más baja que en configuraciones con menos núcleos y una velocidad de reloj más alta. Por ejemplo, 16 núcleos con 2600 MHz es preferible a 8 núcleos con 3600 MHz.
Uso de **Impulso de Turbo** y **hiper-threading** tecnologías se recomienda. Mejora significativamente el rendimiento con una carga típica.
Uso de **Impulso de Turbo** y **Hiper-threading** tecnologías se recomienda. Mejora significativamente el rendimiento con una carga típica.
## RAM {#ram}
@ -19,7 +19,7 @@ El volumen requerido de RAM depende de:
Para calcular el volumen requerido de RAM, debe estimar el tamaño de los datos temporales para [GRUPO POR](../query_language/select.md#select-group-by-clause), [DISTINTO](../query_language/select.md#select-distinct), [UNIR](../query_language/select.md#select-join) y otras operaciones que utilice.
ClickHouse puede usar memoria externa para datos temporales. Ver [GROUP BY en memoria externa](../query_language/select.md#select-group-by-in-external-memory) para más detalles.
ClickHouse puede usar memoria externa para datos temporales. Ver [GRUPO POR en memoria externa](../query_language/select.md#select-group-by-in-external-memory) para más detalles.
## Archivo de intercambio {#swap-file}
@ -41,9 +41,9 @@ El volumen de almacenamiento requerido para sus datos debe calcularse por separa
Para calcular el volumen final de datos que se almacenarán, aplique el coeficiente de compresión al volumen de datos estimado. Si planea almacenar datos en varias réplicas, multiplique el volumen estimado por el número de réplicas.
## Red {#network}
## Rojo {#network}
Si es posible, use redes de 10G o clase superior.
Si es posible, utilice redes de 10G o clase superior.
El ancho de banda de la red es fundamental para procesar consultas distribuidas con una gran cantidad de datos intermedios. Además, la velocidad de la red afecta a los procesos de replicación.

18
docs/es/operations/server_settings/settings.md
View File

@ -45,7 +45,7 @@ Puede configurar múltiples `<case>` apartado.
Acciones cuando se cumplen las condiciones:
- Si un elemento de datos coincide con un conjunto de condiciones, ClickHouse utiliza el método de compresión especificado.
- Si un elemento de datos coincide con varios conjuntos de condiciones, ClickHouse utiliza el primer conjunto de condiciones coincidente.
- Si un elemento de datos coinciden con varios conjuntos de condiciones, ClickHouse utiliza el primer conjunto de condiciones coincidente.
Si no se cumplen condiciones para un elemento de datos, ClickHouse utiliza el `lz4` compresión.
@ -129,14 +129,14 @@ La ruta de acceso al directorio con los esquemas para los datos de entrada, como
<format_schema_path>format_schemas/</format_schema_path>
```
## grafito {#server-settings-graphite}
## Grafito {#server-settings-graphite}
Envío de datos a [Grafito](https://github.com/graphite-project).
Configuración:
- host – El servidor de grafito.
- port: el puerto del servidor Graphite.
- el puerto del servidor grafito.
- intervalo – El intervalo para el envío, en segundos.
- timeout – El tiempo de espera para el envío de datos, en segundos.
- root\_path – Prefijo para las claves.
@ -339,7 +339,7 @@ Claves:
- use\_syslog — Ajuste requerido si desea escribir en el syslog.
- address — El host\[:port\] de syslogd. Si se omite, se utiliza el daemon local.
- hostname — Opcional. El nombre del host desde el que se envían los registros.
- instalación — [La palabra clave syslog facility](https://en.wikipedia.org/wiki/Syslog#Facility) en letras mayúsculas con el “LOG\_” prefijo: (`LOG_USER`, `LOG_DAEMON`, `LOG_LOCAL3` y así sucesivamente).
- instalación — [La palabra clave syslog instalación](https://en.wikipedia.org/wiki/Syslog#Facility) en letras mayúsculas con el “LOG\_” prefijo: (`LOG_USER`, `LOG_DAEMON`, `LOG_LOCAL3` y así sucesivamente).
Valor predeterminado: `LOG_USER` si `address` se especifica, `LOG_DAEMON otherwise.`
- format – Formato de mensaje. Valores posibles: `bsd` y `syslog.`
@ -359,7 +359,7 @@ Para obtener más información, consulte la sección “[Creación de tablas rep
## Método de codificación de datos: {#server-mark-cache-size}
Tamaño aproximado (en bytes) de la memoria caché de marcas utilizadas por los motores de [Método de codificación de datos:](../table_engines/mergetree.md) familia.
Tamaño aproximado (en bytes) de la memoria caché de marcas utilizadas por los motores de [Método de codificación de datos:](../table_engines/mergetree.md) Familia.
La memoria caché se comparte para el servidor y la memoria se asigna según sea necesario. El tamaño de la memoria caché debe ser al menos 5368709120.
@ -407,7 +407,7 @@ Recomendamos usar esta opción en Mac OS X desde el `getrlimit()` función devue
Restricción en la eliminación de tablas.
Si el tamaño de un [Método de codificación de datos:](../table_engines/mergetree.md) mesa excede `max_table_size_to_drop` (en bytes), no puede eliminarlo mediante una consulta DROP.
Si el tamaño de un [Método de codificación de datos:](../table_engines/mergetree.md) más caliente `max_table_size_to_drop` (en bytes), no puede eliminarlo mediante una consulta DROP.
Si aún necesita eliminar la tabla sin reiniciar el servidor ClickHouse, cree el `<clickhouse-path>/flags/force_drop_table` y ejecute la consulta DROP.
@ -446,10 +446,10 @@ Claves para la configuración del servidor/cliente:
- privateKeyFile: la ruta de acceso al archivo con la clave secreta del certificado PEM. El archivo puede contener una clave y un certificado al mismo tiempo.
- certificateFile: la ruta de acceso al archivo de certificado cliente/servidor en formato PEM. Puede omitirlo si `privateKeyFile` contiene el certificado.
- caConfig: la ruta de acceso al archivo o directorio que contiene certificados raíz de confianza.
- verificationMode: el método para verificar los certificados del nodo. Los detalles están en la descripción del [Contexto](https://github.com/ClickHouse-Extras/poco/blob/master/NetSSL_OpenSSL/include/Poco/Net/Context.h) clase. Valores posibles: `none`, `relaxed`, `strict`, `once`.
- verificationMode: el método para verificar los certificados del nodo. Los detalles están en la descripción del [Contexto](https://github.com/ClickHouse-Extras/poco/blob/master/NetSSL_OpenSSL/include/Poco/Net/Context.h) Clase. Valores posibles: `none`, `relaxed`, `strict`, `once`.
- Profundidad de verificación: la longitud máxima de la cadena de verificación. La verificación fallará si la longitud de la cadena del certificado supera el valor establecido.
- loadDefaultCAFile: indica que se usarán certificados de CA integrados para OpenSSL. Valores aceptables: `true`, `false`. \|
- cipherList: encriptaciones OpenSSL compatibles. Por ejemplo: `ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH`.
- cipherList: encriptaciones compatibles con OpenSSL. Por ejemplo: `ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH`.
- cacheSessions: habilita o deshabilita las sesiones de almacenamiento en caché. Debe usarse en combinación con `sessionIdContext`. Valores aceptables: `true`, `false`.
- sessionIdContext: un conjunto único de caracteres aleatorios que el servidor agrega a cada identificador generado. La longitud de la cuerda no debe exceder `SSL_MAX_SSL_SESSION_ID_LENGTH`. Este parámetro siempre se recomienda ya que ayuda a evitar problemas tanto si el servidor almacena en caché la sesión como si el cliente solicita el almacenamiento en caché. Valor predeterminado: `${application.name}`.
- sessionCacheSize: el número máximo de sesiones que el servidor almacena en caché. Valor predeterminado: 1024\*20. 0 – Sesiones ilimitadas.
@ -824,7 +824,7 @@ Esta sección contiene los siguientes parámetros:
Método de almacenamiento para encabezados de parte de datos en ZooKeeper.
Esta configuración sólo se aplica a `MergeTree` familia. Se puede especificar:
Esta configuración sólo se aplica a `MergeTree` Familia. Se puede especificar:
- A nivel mundial en el [merge\_tree](#server_settings-merge_tree) sección de la `config.xml` file.

6
docs/es/operations/settings/permissions_for_queries.md
View File

@ -5,7 +5,7 @@ Las consultas en ClickHouse se pueden dividir en varios tipos:
1. Leer consultas de datos: `SELECT`, `SHOW`, `DESCRIBE`, `EXISTS`.
2. Escribir consultas de datos: `INSERT`, `OPTIMIZE`.
3. Cambiar la consulta de configuración: `SET`, `USE`.
4. [DDL](https://en.wikipedia.org/wiki/Data_definition_language) consulta: `CREATE`, `ALTER`, `RENAME`, `ATTACH`, `DETACH`, `DROP` `TRUNCATE`.
4. [DDL](https://en.wikipedia.org/wiki/Data_definition_language) Consulta: `CREATE`, `ALTER`, `RENAME`, `ATTACH`, `DETACH`, `DROP` `TRUNCATE`.
5. `KILL QUERY`.
La siguiente configuración regula los permisos de usuario según el tipo de consulta:
@ -19,7 +19,7 @@ La siguiente configuración regula los permisos de usuario según el tipo de con
Restringe los permisos para leer datos, escribir datos y cambiar las consultas de configuración.
Vea cómo las consultas se dividen en tipos [arriba](#permissions_for_queries).
Vea cómo las consultas se dividen en tipos [Arriba](#permissions_for_queries).
Valores posibles:
@ -40,7 +40,7 @@ Valor predeterminado: 0
Permite o niega [DDL](https://en.wikipedia.org/wiki/Data_definition_language) consulta.
Vea cómo las consultas se dividen en tipos [arriba](#permissions_for_queries).
Vea cómo las consultas se dividen en tipos [Arriba](#permissions_for_queries).
Valores posibles:

20
docs/es/operations/settings/query_complexity.md
View File

@ -62,7 +62,7 @@ Un número máximo de bytes (datos sin comprimir) que se pueden leer de una tabl
## Método de codificación de datos: {#read-overflow-mode}
Qué hacer cuando el volumen de datos leídos excede uno de los límites: ‘throw’ o ‘break’. Por defecto, throw.
Qué hacer cuando el volumen de datos leídos excede uno de los límites: ‘throw’ o ‘break’. Por defecto, tirar.
## Método de codificación de datos: {#settings-max-rows-to-group-by}
@ -70,12 +70,12 @@ Un número máximo de claves únicas recibidas de la agregación. Esta configura
## Grupo\_by\_overflow\_mode {#group-by-overflow-mode}
Qué hacer cuando el número de claves únicas para la agregación excede el límite: ‘throw’, ‘break’, o ‘any’. Por defecto, throw.
Qué hacer cuando el número de claves únicas para la agregación excede el límite: ‘throw’, ‘break’, o ‘any’. Por defecto, tirar.
Uso de la ‘any’ valor le permite ejecutar una aproximación de GROUP BY. La calidad de esta aproximación depende de la naturaleza estadística de los datos.
## max\_bytes\_before\_external\_group\_by {#settings-max-bytes-before-external-group-by}
Habilita o deshabilita la ejecución de `GROUP BY` en la memoria externa. Ver [GROUP BY en memoria externa](../../query_language/select.md#select-group-by-in-external-memory).
Habilita o deshabilita la ejecución de `GROUP BY` en la memoria externa. Ver [GRUPO POR en memoria externa](../../query_language/select.md#select-group-by-in-external-memory).
Valores posibles:
@ -94,7 +94,7 @@ Un número máximo de bytes antes de ordenar.
## sort\_overflow\_mode {#sort-overflow-mode}
Qué hacer si el número de filas recibidas antes de ordenar excede uno de los límites: ‘throw’ o ‘break’. Por defecto, throw.
Qué hacer si el número de filas recibidas antes de ordenar excede uno de los límites: ‘throw’ o ‘break’. Por defecto, tirar.
## max\_result\_rows {#setting-max-result-rows}
@ -106,9 +106,9 @@ Límite en el número de bytes en el resultado. Lo mismo que el ajuste anterior.
## result\_overflow\_mode {#result-overflow-mode}
Qué hacer si el volumen del resultado excede uno de los límites: ‘throw’ o ‘break’. Por defecto, throw.
Qué hacer si el volumen del resultado excede uno de los límites: ‘throw’ o ‘break’. Por defecto, tirar.
Utilizar ‘break’ es similar a usar LIMIT. `Break` interrumpe la ejecución sólo en el nivel de bloque. Esto significa que la cantidad de filas devueltas es mayor que [max\_result\_rows](#setting-max_result_rows), múltiplo de [max\_block\_size](settings.md#setting-max_block_size) y depende de [max\_threads](settings.md#settings-max_threads).
Utilizar ‘break’ es similar a un límite de usar. `Break` interrumpe la ejecución sólo en el nivel de bloque. Esto significa que la cantidad de filas devueltas es mayor que [max\_result\_rows](#setting-max_result_rows), múltiplo de [max\_block\_size](settings.md#setting-max_block_size) y depende de [max\_threads](settings.md#settings-max_threads).
Ejemplo:
@ -134,7 +134,7 @@ En este momento, no se comprueba una de las etapas de clasificación, o al fusio
## timeout\_overflow\_mode {#timeout-overflow-mode}
Qué hacer si la consulta se ejecuta más de ‘max\_execution\_time’: ‘throw’ o ‘break’. Por defecto, throw.
Qué hacer si la consulta se ejecuta más de ‘max\_execution\_time’: ‘throw’ o ‘break’. Por defecto, tirar.
## Método de codificación de datos: {#min-execution-speed}
@ -197,7 +197,7 @@ Número máximo de bytes (datos sin comprimir) utilizados por un conjunto en la
## set\_overflow\_mode {#set-overflow-mode}
Qué hacer cuando la cantidad de datos excede uno de los límites: ‘throw’ o ‘break’. Por defecto, throw.
Qué hacer cuando la cantidad de datos excede uno de los límites: ‘throw’ o ‘break’. Por defecto, tirar.
## Método de codificación de datos: {#max-rows-in-distinct}
@ -209,7 +209,7 @@ Un número máximo de bytes utilizados por una tabla hash cuando se utiliza DIST
## distinct\_overflow\_mode {#distinct-overflow-mode}
Qué hacer cuando la cantidad de datos excede uno de los límites: ‘throw’ o ‘break’. Por defecto, throw.
Qué hacer cuando la cantidad de datos excede uno de los límites: ‘throw’ o ‘break’. Por defecto, tirar.
## max\_rows\_to\_transfer {#max-rows-to-transfer}
@ -221,7 +221,7 @@ Un número máximo de bytes (datos sin comprimir) que se pueden pasar a un servi
## transfer\_overflow\_mode {#transfer-overflow-mode}
Qué hacer cuando la cantidad de datos excede uno de los límites: ‘throw’ o ‘break’. Por defecto, throw.
Qué hacer cuando la cantidad de datos excede uno de los límites: ‘throw’ o ‘break’. Por defecto, tirar.
## Método de codificación de datos: {#settings-max-rows-in-join}

42
docs/es/operations/settings/settings.md
View File

@ -15,9 +15,9 @@ Restricción:
Valores posibles:
- `deny` — Valor predeterminado. Prohíbe el uso de estos tipos de subconsultas (devuelve el “Double-distributed in/JOIN subqueries is denied” salvedad).
- `deny` — Valor predeterminado. Prohíbe el uso de estos tipos de subconsultas (devuelve el “Double-distributed in/JOIN subqueries is denied” Salvedad).
- `local` — Sustituye la base de datos y la tabla de la subconsulta por locales para el servidor de destino (fragmento), dejando `IN`/`JOIN.`
- `global` — Sustituye el `IN`/`JOIN` consulta con `GLOBAL IN`/`GLOBAL JOIN.`
- `global` — Sustituye el `IN`/`JOIN` Consulta con `GLOBAL IN`/`GLOBAL JOIN.`
- `allow` — Permite la utilización de este tipo de subconsultas.
## enable\_optimize\_predicate\_expression {#enable-optimize-predicate-expression}
@ -72,7 +72,7 @@ Si `force_primary_key=1`, ClickHouse comprueba si la consulta tiene una condici
## Formato\_esquema {#format-schema}
Este parámetro es útil cuando se utilizan formatos que requieren una definición de esquema, como [Cap’n Proto](https://capnproto.org/) o [Protobuf](https://developers.google.com/protocol-buffers/). El valor depende del formato.
Este parámetro es útil cuando se utilizan formatos que requieren una definición de esquema, como [Cap'n Proto](https://capnproto.org/) o [Protobuf](https://developers.google.com/protocol-buffers/). El valor depende del formato.
## fsync\_metadata {#fsync-metadata}
@ -129,7 +129,7 @@ Valor predeterminado: 0.
## Nombre de la red inalámbrica (SSID): {#setting-max-http-get-redirects}
Limita el número máximo de saltos de redirección HTTP GET para [URL](../table_engines/url.md)-mesas de motor. La configuración se aplica a ambos tipos de tablas: las creadas por [CREAR TABLA](../../query_language/create/#create-table-query) consulta y por el [URL](../../query_language/table_functions/url.md) función de la tabla.
Limita el número máximo de saltos de redirección HTTP GET para [URL](../table_engines/url.md)-mesas de motor. La configuración se aplica a ambos tipos de tablas: las creadas por [CREAR TABLA](../../query_language/create/#create-table-query) Consulta y por el [URL](../../query_language/table_functions/url.md) función de la tabla.
Valores posibles:
@ -238,7 +238,7 @@ Esta configuración sólo se utiliza cuando `input_format_values_deduce_template
```
Cuando esta configuración está habilitada, ClickHouse comprobará el tipo real de literal y utilizará una plantilla de expresión del tipo correspondiente. En algunos casos, puede ralentizar significativamente la evaluación de expresiones en `Values`.
Cuando está deshabilitado, ClickHouse puede usar un tipo más general para algunos literales (por ejemplo, `Float64` o `Int64` en lugar de `UInt64` para `42`), pero puede causar problemas de desbordamiento y precisión.
Cuando está deshabilitado, ClickHouse puede usar un tipo más general para algunos literales (por ejemplo, `Float64` o `Int64` es lugar de `UInt64` para `42`), pero puede causar problemas de desbordamiento y precisión.
Habilitado de forma predeterminada.
## Entrada\_format\_defaults\_for\_omitted\_fields {#session-settings-input-format-defaults-for-omitted-fields}
@ -352,7 +352,7 @@ Establece el rigor predeterminado para [Cláusulas JOIN](../../query_language/se
Valores posibles:
- `ALL` — Si la tabla correcta tiene varias filas coincidentes, ClickHouse crea un [Producto cartesiano](https://en.wikipedia.org/wiki/Cartesian_product) de filas coincidentes. Esta es la normal `JOIN` comportamiento de SQL estándar.
- `ANY` — Si la tabla correcta tiene varias filas coincidentes, solo se une la primera encontrada. Si la tabla correcta solo tiene una fila coincidente, los resultados de `ANY` y `ALL` son los mismos.
- `ANY` — Si la tabla correcta tiene varias filas coincidentes, solo se une la primera encontrada. Si la tabla correcta solo tiene una fila coincidente, los resultados de `ANY` y `ALL` hijo de los mismos.
- `ASOF` — Para unir secuencias con una coincidencia incierta.
- `Empty string` — Si `ALL` o `ANY` no se especifica en la consulta, ClickHouse produce una excepción.
@ -385,7 +385,7 @@ Establece el tipo de [UNIR](../../query_language/select.md) comportamiento. Al f
Valores posibles:
- 0 — Las celdas vacías se rellenan con el valor predeterminado del tipo de campo correspondiente.
- Uno — `JOIN` se comporta de la misma manera que en SQL estándar. El tipo del campo correspondiente se convierte en [NULL](../../data_types/nullable.md#data_type-nullable), y las celdas vacías se llenan con [NULO](../../query_language/syntax.md).
- Uno — `JOIN` se comporta de la misma manera que en SQL estándar. El tipo del campo correspondiente se convierte en [NULO](../../data_types/nullable.md#data_type-nullable), y las celdas vacías se llenan con [NULO](../../query_language/syntax.md).
Valor predeterminado: 0.
@ -400,12 +400,12 @@ Bloquea el tamaño de `max_block_size` no siempre se cargan desde la tabla. Si e
## preferred\_block\_size\_bytes {#preferred-block-size-bytes}
Utilizado para el mismo propósito que `max_block_size`, pero establece el tamaño de bloque recomendado en bytes adaptándolo al número de filas en el bloque.
Sin embargo, el tamaño del bloque no puede ser más que `max_block_size` filas.
Por defecto: 1,000,000. Solo funciona cuando se lee desde los motores MergeTree.
Sin embargo, el tamaño del bloque no puede ser más que `max_block_size` películas.
Por defecto: 1.000.000. Solo funciona cuando se lee desde los motores MergeTree.
## merge\_tree\_min\_rows\_for\_concurrent\_read {#setting-merge-tree-min-rows-for-concurrent-read}
Si el número de filas que se leerán de un fichero [Método de codificación de datos:](../table_engines/mergetree.md) mesa excede `merge_tree_min_rows_for_concurrent_read` luego ClickHouse intenta realizar una lectura simultánea de este archivo en varios hilos.
Si el número de filas que se leerán de un fichero [Método de codificación de datos:](../table_engines/mergetree.md) más caliente `merge_tree_min_rows_for_concurrent_read` luego ClickHouse intenta realizar una lectura simultánea de este archivo en varios hilos.
Valores posibles:
@ -481,7 +481,7 @@ Valor predeterminado: 2013265920.
El volumen de datos mínimo necesario para utilizar el acceso directo de E/S al disco de almacenamiento.
ClickHouse usa esta configuración al leer datos de tablas. Si el volumen total de almacenamiento de todos los datos a leer excede `min_bytes_to_use_direct_io` luego ClickHouse lee los datos del disco de almacenamiento con el `O_DIRECT` opcion.
ClickHouse usa esta configuración al leer datos de tablas. Si el volumen total de almacenamiento de todos los datos a leer excede `min_bytes_to_use_direct_io` luego ClickHouse lee los datos del disco de almacenamiento con el `O_DIRECT` opción.
Valores posibles:
@ -549,7 +549,7 @@ Si normalmente se ejecuta menos de una consulta SELECT en un servidor a la vez,
Para las consultas que se completan rápidamente debido a un LIMIT, puede establecer un ‘max\_threads’. Por ejemplo, si el número necesario de entradas se encuentra en cada bloque y max\_threads = 8, entonces se recuperan 8 bloques, aunque hubiera sido suficiente leer solo uno.
Cuanto menor sea el `max_threads` valor, menos memoria se consume.
Cuanto menor sea el `max_threads` valor, menos memoria se consumen.
## Método de codificación de datos: {#settings-max-insert-threads}
@ -668,7 +668,7 @@ El Yandex.Metrica utiliza este parámetro establecido en 1 para implementar suge
## Nombre de la red inalámbrica (SSID): {#stream-flush-interval-ms}
Funciona para tablas con streaming en el caso de un tiempo de espera, o cuando un subproceso genera [Max\_insert\_block\_size](#settings-max_insert_block_size) filas.
Funciona para tablas con streaming en el caso de un tiempo de espera, o cuando un subproceso genera [Max\_insert\_block\_size](#settings-max_insert_block_size) películas.
El valor predeterminado es 7500.
@ -685,7 +685,7 @@ ClickHouse admite los siguientes algoritmos para elegir réplicas:
- [En orden](#load_balancing-in_order)
- [Primero o aleatorio](#load_balancing-first_or_random)
### Random (por defecto) {#load-balancing-random}
### Aleatorio (por defecto) {#load-balancing-random}
``` sql
load_balancing = random
@ -725,7 +725,7 @@ load_balancing = first_or_random
Este algoritmo elige la primera réplica del conjunto o una réplica aleatoria si la primera no está disponible. Es eficaz en configuraciones de topología de replicación cruzada, pero inútil en otras configuraciones.
El `first_or_random` resuelve el problema del algoritmo `in_order` algoritmo. Con `in_order`, si una réplica se cae, la siguiente obtiene una carga doble mientras que las réplicas restantes manejan la cantidad habitual de tráfico. Cuando se utiliza el `first_or_random` algoritmo, la carga se distribuye uniformemente entre las réplicas que todavía están disponibles.
El `first_or_random` Resuelve el problema del algoritmo `in_order` algoritmo. Desventaja `in_order`, si una réplica se cae, la siguiente obtiene una carga doble mientras que las réplicas restantes manejan la cantidad habitual de tráfico. Cuando se utiliza el `first_or_random` algoritmo, la carga se distribuye uniformemente entre las réplicas que todavía están disponibles.
## prefer\_localhost\_replica {#settings-prefer-localhost-replica}
@ -802,13 +802,13 @@ Habilita las escrituras de quórum.
Valor predeterminado: 0.
Quorum escribe
Quórum escribe
`INSERT` solo tiene éxito cuando ClickHouse logra escribir correctamente datos en el `insert_quorum` de réplicas durante el `insert_quorum_timeout`. Si por alguna razón el número de réplicas con escrituras exitosas no alcanza el `insert_quorum`, la escritura se considera fallida y ClickHouse eliminará el bloque insertado de todas las réplicas donde los datos ya se han escrito.
Todas las réplicas del quórum son consistentes, es decir, contienen datos de todas las réplicas anteriores `INSERT` consulta. El `INSERT` la secuencia está linealizada.
Al leer los datos escritos desde el `insert_quorum` usted puede utilizar el [select\_sequential\_consistency](#settings-select_sequential_consistency) opcion.
Al leer los datos escritos desde el `insert_quorum` Puede utilizar el [select\_sequential\_consistency](#settings-select_sequential_consistency) opción.
ClickHouse genera una excepción
@ -833,7 +833,7 @@ Ver también:
## select\_sequential\_consistency {#settings-select-sequential-consistency}
Habilita o deshabilita la coherencia secuencial para `SELECT` consulta:
Habilita o deshabilita la coherencia secuencial para `SELECT` Consulta:
Valores posibles:
@ -844,7 +844,7 @@ Valor predeterminado: 0.
Uso
Cuando se habilita la coherencia secuencial, ClickHouse permite al cliente ejecutar el `SELECT` consulta sólo para aquellas réplicas que contienen datos de todas las `INSERT` consultas ejecutadas con `insert_quorum`. Si el cliente hace referencia a una réplica parcial, ClickHouse generará una excepción. La consulta SELECT no incluirá datos que aún no se hayan escrito en el quórum de réplicas.
Cuando se habilita la coherencia secuencial, ClickHouse permite al cliente ejecutar el `SELECT` consulta sólo para aquellas réplicas que contienen datos de todas las `INSERT` Consultas ejecutadas con `insert_quorum`. Si el cliente hace referencia a una réplica parcial, ClickHouse generará una excepción. La consulta SELECT no incluirá datos que aún no se hayan escrito en el quórum de réplicas.
Ver también:
@ -879,7 +879,7 @@ Uso
De forma predeterminada, la desduplicación no se realiza para las vistas materializadas, sino que se realiza en sentido ascendente, en la tabla de origen.
Si se omite un bloque INSERTed debido a la desduplicación en la tabla de origen, no habrá inserción en las vistas materializadas adjuntas. Este comportamiento existe para permitir la inserción de datos altamente agregados en vistas materializadas, para los casos en que los bloques insertados son los mismos después de la agregación de vistas materializadas pero derivados de diferentes INSERT en la tabla de origen.
Al mismo tiempo, este comportamiento “breaks” `INSERT` idempotencia. Si una `INSERT` en la mesa principal fue exitoso y `INSERT` en una vista materializada falló (por ejemplo, debido a una falla de comunicación con Zookeeper), un cliente obtendrá un error y puede volver a intentar la operación. Sin embargo, la vista materializada no recibirá la segunda inserción porque se descartará mediante deduplicación en la tabla principal (fuente). Configuración `deduplicate_blocks_in_dependent_materialized_views` permite cambiar este comportamiento. Al reintentar, una vista materializada recibirá la inserción de repetición y realizará la comprobación de desduplicación por sí misma,
Al mismo tiempo, este comportamiento “breaks” `INSERT` empotencia. Si una `INSERT` en la mesa principal fue exitoso y `INSERT` en una vista materializada falló (por ejemplo, debido a una falla de comunicación con Zookeeper), un cliente obtendrá un error y puede volver a intentar la operación. Sin embargo, la vista materializada no recibirá la segunda inserción porque se descartará mediante deduplicación en la tabla principal (fuente). Configuración `deduplicate_blocks_in_dependent_materialized_views` permite cambiar este comportamiento. Al reintentar, una vista materializada recibirá la inserción de repetición y realizará la comprobación de desduplicación por sí misma,
ignorando el resultado de la comprobación para la tabla de origen, e insertará filas perdidas debido a la primera falla.
## Método de codificación de datos: {#settings-max-network-bytes}
@ -1175,7 +1175,7 @@ Valor predeterminado: 32768 (32 KiB)
## Todos los derechos reservados. {#settings-format-avro-schema-registry-url}
Establece la URL del Registro de esquemas confluentes para usar con [AvroConfluent](../../interfaces/formats.md#data-format-avro-confluent) formato
Establece la URL del Registro de esquemas confluentes para usar con [AvroConfluent](../../interfaces/formats.md#data-format-avro-confluent) Formato
Tipo: URL

8
docs/es/operations/settings/settings_users.md
View File

@ -63,7 +63,7 @@ La contraseña se puede especificar en texto sin formato o en SHA256 (formato he
La primera línea del resultado es la contraseña. La segunda línea es el hash SHA1 doble correspondiente.
### user\_name/redes {#user-namenetworks}
### Nombre\_usuario/redes {#user-namenetworks}
Lista de redes desde las que el usuario puede conectarse al servidor ClickHouse.
@ -105,11 +105,11 @@ Para abrir el acceso solo desde localhost, especifique:
<ip>127.0.0.1</ip>
```
### user\_name/perfil {#user-nameprofile}
### Nombre\_usuario/perfil {#user-nameprofile}
Puede asignar un perfil de configuración para el usuario. Los perfiles de configuración se configuran en una sección separada del `users.xml` file. Para obtener más información, consulte [Perfiles de configuración](settings_profiles.md).
### user\_name/cuota {#user-namequota}
### Nombre\_usuario/cuota {#user-namequota}
Las cuotas le permiten realizar un seguimiento o limitar el uso de recursos durante un período de tiempo. Las cuotas se configuran en el `quotas`
sección de la `users.xml` archivo de configuración.
@ -122,7 +122,7 @@ En esta sección, puede limitar las filas devueltas por ClickHouse para `SELECT`
**Ejemplo**
La siguiente configuración obliga a que el usuario `user1` sólo puede ver las filas de `table1` como resultado de `SELECT` consultas, donde el valor de la `id` campo es 1000.
La siguiente configuración obliga a que el usuario `user1` sólo puede ver las filas de `table1` como resultado de `SELECT` Consultas, donde el valor de la `id` campo es 1000.
``` xml
<user1>

32
docs/es/operations/system_tables.md
View File

@ -4,7 +4,7 @@ Las tablas del sistema se utilizan para implementar parte de la funcionalidad de
No puede eliminar una tabla del sistema (pero puede realizar DETACH).
Las tablas del sistema no tienen archivos con datos en el disco o archivos con metadatos. El servidor crea todas las tablas del sistema cuando se inicia.
Las tablas del sistema son de solo lectura.
Están ubicados en el ‘system’ base.
Están ubicados en el ‘system’ basar.
## sistema.asynchronous\_metrics {#system-tables-asynchronous-metrics}
@ -72,7 +72,7 @@ Tenga en cuenta que `errors_count` se actualiza una vez por consulta al clúster
Contiene información sobre las columnas de todas las tablas.
Puede utilizar esta tabla para obtener información similar a la [TABLA DE DESCRIBE](../query_language/misc.md#misc-describe-table) consulta, pero para varias tablas a la vez.
Puede utilizar esta tabla para obtener información similar a la [TABLA DE DESCRIBE](../query_language/misc.md#misc-describe-table) Consulta, pero para varias tablas a la vez.
El `system.columns` tabla contiene las siguientes columnas (el tipo de columna se muestra entre corchetes):
@ -132,7 +132,7 @@ SELECT * FROM system.contributors WHERE name='Olga Khvostikova'
└──────────────────┘
```
## sistema.base {#system-databases}
## sistema.basar {#system-databases}
Esta tabla contiene una sola columna String llamada ‘name’ – el nombre de una base de datos.
Cada base de datos que el servidor conoce tiene una entrada correspondiente en la tabla.
@ -142,7 +142,7 @@ Esta tabla del sistema se utiliza para implementar el `SHOW DATABASES` consulta.
Contiene información sobre piezas separadas de [Método de codificación de datos:](table_engines/mergetree.md) tabla. El `reason` columna especifica por qué se separó la pieza. Para las piezas separadas por el usuario, el motivo está vacío. Tales partes se pueden unir con [ALTER TABLE ATTACH PARTITION\|PARTE](../query_language/query_language/alter/#alter_attach-partition) comando. Para obtener la descripción de otras columnas, consulte [sistema.parte](#system_tables-parts). Si el nombre de la pieza no es válido, los valores de algunas columnas pueden ser `NULL`. Tales partes se pueden eliminar con [ALTER MESA GOTA PARTE DESMONTADA](../query_language/query_language/alter/#alter_drop-detached).
## sistema.diccionario {#system-dictionaries}
## sistema.Diccionario {#system-dictionaries}
Contiene información sobre diccionarios externos.
@ -222,7 +222,7 @@ Columna:
- `Tables.database` (Array(String)) - Matriz de nombres de tablas de base de datos que utilizan `config_name` parámetro.
- `Tables.table` (Array(String)) - Matriz de nombres de tablas que utilizan `config_name` parámetro.
## sistema.fusionar {#system-merges}
## sistema.Fusionar {#system-merges}
Contiene información sobre fusiones y mutaciones de piezas actualmente en proceso para tablas de la familia MergeTree.
@ -338,7 +338,7 @@ CurrentMetric_ReplicatedChecks: 0
- [sistema.métricas](#system_tables-metrics) - Contiene métricas calculadas al instante.
- [Monitoreo](monitoring.md) — Conceptos básicos de monitoreo ClickHouse.
## sistema.numero {#system-numbers}
## sistema.número {#system-numbers}
Esta tabla contiene una única columna UInt64 llamada ‘number’ que contiene casi todos los números naturales a partir de cero.
Puede usar esta tabla para pruebas, o si necesita hacer una búsqueda de fuerza bruta.
@ -440,7 +440,7 @@ Columna:
El `system.part_log` se crea sólo si el [part\_log](server_settings/settings.md#server_settings-part-log) se especifica la configuración del servidor.
Esta tabla contiene información sobre eventos que ocurrieron con [partes de datos](table_engines/custom_partitioning_key.md) en el [Método de codificación de datos:](table_engines/mergetree.md) tablas familiares, como agregar o fusionar datos.
Esta tabla contiene información sobre eventos que ocurrieron con [partes de datos](table_engines/custom_partitioning_key.md) es el [Método de codificación de datos:](table_engines/mergetree.md) tablas familiares, como agregar o fusionar datos.
El `system.part_log` contiene las siguientes columnas:
@ -469,7 +469,7 @@ El `system.part_log` contiene las siguientes columnas:
El `system.part_log` se crea después de la primera inserción de datos `MergeTree` tabla.
## sistema.procesa {#system-tables-processes}
## sistema.proceso {#system-tables-processes}
Esta tabla del sistema se utiliza para implementar el `SHOW PROCESSLIST` consulta.
@ -910,7 +910,7 @@ Esta tabla contiene las siguientes columnas (el tipo de columna se muestra entre
- `metadata_path` (String) - Ruta de acceso a los metadatos de la tabla en el sistema de archivos.
- `metadata_modification_time` (DateTime) - Hora de la última modificación de los metadatos de la tabla.
- `dependencies_database` (Array(String)) - Dependencias de base de datos.
- `dependencies_table` (Array(String)) - Dependencias de tabla ([Método de codificación de datos:](table_engines/materializedview.md) tablas basadas en la tabla actual).
- `dependencies_table` (Array(String)) - Dependencias de tabla ([Método de codificación de datos:](table_engines/materializedview.md) tablas basadas en la tabla real).
- `create_table_query` (String) - La consulta que se utilizó para crear la tabla.
- `engine_full` (String) - Parámetros del motor de tabla.
- `partition_key` (String) - La expresión de clave de partición especificada en la tabla.
@ -925,7 +925,7 @@ El `system.tables` se utiliza en `SHOW TABLES` implementación de consultas.
La tabla no existe si ZooKeeper no está configurado. Permite leer datos del clúster ZooKeeper definido en la configuración.
La consulta debe tener un ‘path’ condición de igualdad en la cláusula WHERE. Este es el camino en ZooKeeper para los niños para los que desea obtener datos.
Consulta `SELECT * FROM system.zookeeper WHERE path = '/clickhouse'` salidas de datos para todos los niños en el `/clickhouse` nodo.
Consulta `SELECT * FROM system.zookeeper WHERE path = '/clickhouse'` salidas de datos para todos los niños en el `/clickhouse` Nodo.
Para generar datos para todos los nodos raíz, escriba path = ‘/’.
Si la ruta especificada en ‘path’ no existe, se lanzará una excepción.
@ -933,7 +933,7 @@ Columna:
- `name` (String) — El nombre del nodo.
- `path` (String) — La ruta al nodo.
- `value` (Cadena) - Valor de nodo.
- `value` (Cadena) - el Valor de nodo.
- `dataLength` (Int32) — Tamaño del valor.
- `numChildren` (Int32) — Número de descendientes.
- `czxid` (Int64) — ID de la transacción que creó el nodo.
@ -995,15 +995,15 @@ path: /clickhouse/tables/01-08/visits/replicas
La tabla contiene información sobre [mutación](../query_language/alter.md#alter-mutations) de las tablas MergeTree y su progreso. Cada comando de mutación está representado por una sola fila. La tabla tiene las siguientes columnas:
**base**, **tabla** - El nombre de la base de datos y la tabla a la que se aplicó la mutación.
**basar**, **tabla** - El nombre de la base de datos y la tabla a la que se aplicó la mutación.
**mutation\_id** - La identificación de la mutación. Para las tablas replicadas, estos identificadores corresponden a los nombres de znode `<table_path_in_zookeeper>/mutations/` directorio en ZooKeeper. Para las tablas no duplicadas, los ID corresponden a los nombres de archivo en el directorio de datos de la tabla.
**mutation\_id** - La identificación de la mutación. Para las tablas replicadas, estos identificadores corresponden a los nombres de znode `<table_path_in_zookeeper>/mutations/` Directorio en ZooKeeper. Para las tablas no duplicadas, los ID corresponden a los nombres de archivo en el directorio de datos de la tabla.
**comando** - La cadena de comandos de mutación (la parte de la consulta después de `ALTER TABLE [db.]table`).
**create\_time** - Cuando este comando de mutación fue enviado para su ejecución.
**block\_numbers.partition\_id**, **block\_numbers.numero** - Una columna anidada. Para las mutaciones de tablas replicadas, contiene un registro para cada partición: el ID de partición y el número de bloque que fue adquirido por la mutación (en cada partición, solo se mutarán las partes que contienen bloques con números menores que el número de bloque adquirido por la mutación en esa partición). En tablas no replicadas, los números de bloque en todas las particiones forman una sola secuencia. Esto significa que para las mutaciones de tablas no replicadas, la columna contendrá un registro con un solo número de bloque adquirido por la mutación.
**block\_numbers.partition\_id**, **block\_numbers.número** - Una columna anidada. Para las mutaciones de tablas replicadas, contiene un registro para cada partición: el ID de partición y el número de bloque que fue adquirido por la mutación (en cada partición, solo se mutarán las partes que contienen bloques con números menores que el número de bloque adquirido por la mutación en esa partición). En tablas no replicadas, los números de bloque en todas las particiones forman una sola secuencia. Esto significa que para las mutaciones de tablas no replicadas, la columna contendrá un registro con un solo número de bloque adquirido por la mutación.
**partes\_a\_do** - El número de partes de datos que deben mutarse para que finalice la mutación.
@ -1017,7 +1017,7 @@ Si hubo problemas con la mutación de algunas partes, las siguientes columnas co
**Método de codificación de datos:** - El mensaje de excepción que causó el error de mutación de parte más reciente.
## sistema.disco {#system-tables-disks}
## sistema.Discoteca {#system-tables-disks}
Contiene información sobre los discos definidos en el [configuración del servidor](table_engines/mergetree.md#table_engine-mergetree-multiple-volumes_configure).
@ -1038,7 +1038,7 @@ Columna:
- `policy_name` ([Cadena](../data_types/string.md)) — Nombre de la política de almacenamiento.
- `volume_name` ([Cadena](../data_types/string.md)) — Nombre de volumen definido en la política de almacenamiento.
- `volume_priority` ([UInt64](../data_types/int_uint.md)) — Número de orden de volumen en la configuración.
- `disks` ([Array(Cadena)](../data_types/array.md)) — Nombres de disco, definidos en la directiva de almacenamiento.
- `disks` ([Matriz (Cadena)](../data_types/array.md)) — Nombres de disco, definidos en la directiva de almacenamiento.
- `max_data_part_size` ([UInt64](../data_types/int_uint.md)) — Tamaño máximo de una parte de datos que se puede almacenar en discos de volumen (0 — sin límite).
- `move_factor` ([Float64](../data_types/float.md)) — Relación de espacio libre en disco. Cuando la relación excede el valor del parámetro de configuración, ClickHouse comienza a mover los datos al siguiente volumen en orden.

4
docs/es/operations/table_engines/aggregatingmergetree.md
View File

@ -51,10 +51,10 @@ Todos los parámetros tienen el mismo significado que en `MergeTree`.
## SELECCIONAR e INSERTAR {#select-and-insert}
Para insertar datos, utilice [INSERTAR SELECCIONAR](../../query_language/insert_into.md) consulta con funciones agregadas -State-.
Para insertar datos, utilice [INSERTAR SELECCIONAR](../../query_language/insert_into.md) Consulta con funciones agregadas -State-.
Al seleccionar datos de `AggregatingMergeTree` mesa, uso `GROUP BY` cláusula y las mismas funciones agregadas que al insertar datos, pero usando `-Merge` sufijo.
En los resultados de `SELECT` consulta, los valores de `AggregateFunction` tipo tiene representación binaria específica de la implementación para todos los formatos de salida de ClickHouse. Si volcar datos en, por ejemplo, `TabSeparated` formato con `SELECT` consulta entonces este volcado se puede cargar de nuevo usando `INSERT` consulta.
En los resultados de `SELECT` consulta, los valores de `AggregateFunction` tipo tiene representación binaria específica de la implementación para todos los formatos de salida de ClickHouse. Si volcar datos en, por ejemplo, `TabSeparated` Formato con `SELECT` Consulta entonces este volcado se puede cargar de nuevo usando `INSERT` consulta.
## Ejemplo de una vista materializada agregada {#example-of-an-aggregated-materialized-view}

2
docs/es/operations/table_engines/buffer.md
View File

@ -38,7 +38,7 @@ Puede establecer cadenas vacías entre comillas simples para la base de datos y
Al leer desde una tabla de búfer, los datos se procesan tanto desde el búfer como desde la tabla de destino (si hay uno).
Tenga en cuenta que las tablas Buffer no admiten un índice. En otras palabras, los datos del búfer se analizan por completo, lo que puede ser lento para los búferes grandes. (Para los datos de una tabla subordinada, se utilizará el índice que admite.)
Si el conjunto de columnas de la tabla Buffer no coincide con el conjunto de columnas de una tabla subordinada, se inserta un subconjunto de columnas que existen en ambas tablas.
Si el conjunto de columnas de la tabla Buffer no coinciden con el conjunto de columnas de una tabla subordinada, se inserta un subconjunto de columnas que existen en ambas tablas.
Si los tipos no coinciden con una de las columnas de la tabla Búfer y una tabla subordinada, se escribe un mensaje de error en el registro del servidor y se borra el búfer.
Lo mismo sucede si la tabla subordinada no existe cuando se vacía el búfer.

20
docs/es/operations/table_engines/collapsingmergetree.md
View File

@ -25,7 +25,7 @@ Para obtener una descripción de los parámetros de consulta, consulte [descripc
**CollapsingMergeTree Parámetros**
- `sign` — Nombre de la columna con el tipo de fila: `1` es una “state” fila, `-1` es una “cancel” fila.
- `sign` — Nombre de la columna con el tipo de fila: `1` es una “state” fila, `-1` es una “cancel” Fila.
Tipo de datos de columna — `Int8`.
@ -51,7 +51,7 @@ CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
Todos los parámetros excepto `sign` el mismo significado que en `MergeTree`.
- `sign` — Nombre de la columna con el tipo de fila: `1` — “state” fila, `-1` — “cancel” fila.
- `sign` — Nombre de la columna con el tipo de fila: `1` — “state” fila, `-1` — “cancel” Fila.
Tipo de datos de columna — `Int8`.
@ -63,7 +63,7 @@ Todos los parámetros excepto `sign` el mismo significado que en `MergeTree`.
Considere la situación en la que necesita guardar datos que cambian continuamente para algún objeto. Parece lógico tener una fila para un objeto y actualizarla en cualquier cambio, pero la operación de actualización es costosa y lenta para DBMS porque requiere la reescritura de los datos en el almacenamiento. Si necesita escribir datos rápidamente, la actualización no es aceptable, pero puede escribir los cambios de un objeto secuencialmente de la siguiente manera.
Utilice la columna en particular `Sign`. Si `Sign = 1` significa que la fila es un estado de un objeto, llamémoslo “state” fila. Si `Sign = -1` significa la cancelación del estado de un objeto con los mismos atributos, llamémoslo “cancel” fila.
Utilice la columna en particular `Sign`. Si `Sign = 1` significa que la fila es un estado de un objeto, llamémoslo “state” Fila. Si `Sign = -1` significa la cancelación del estado de un objeto con los mismos atributos, llamémoslo “cancel” Fila.
Por ejemplo, queremos calcular cuántas páginas revisaron los usuarios en algún sitio y cuánto tiempo estuvieron allí. En algún momento escribimos la siguiente fila con el estado de la actividad del usuario:
@ -111,22 +111,22 @@ Cuando ClickHouse combina partes de datos, cada grupo de filas consecutivas tien
Para cada parte de datos resultante, ClickHouse guarda:
1. El primero “cancel” y el último “state” si el número de “state” y “cancel” y la última fila es una “state” fila.
1. El primero “cancel” y el último “state” si el número de “state” y “cancel” y la última fila es una “state” Fila.
2. El último “state” fila, si hay más “state” filas que “cancel” filas.
2. El último “state” fila, si hay más “state” películas que “cancel” películas.
3. El primero “cancel” fila, si hay más “cancel” filas que “state” filas.
3. El primero “cancel” fila, si hay más “cancel” películas que “state” películas.
4. Ninguna de las filas, en todos los demás casos.
También cuando hay al menos 2 más “state” filas que “cancel” filas, o al menos 2 más “cancel” filas entonces “state” fila, la fusión continúa, pero ClickHouse trata esta situación como un error lógico y la registra en el registro del servidor. Este error puede producirse si se insertan los mismos datos más de una vez.
También cuando hay al menos 2 más “state” películas que “cancel” filas, o al menos 2 más “cancel” películas entonces “state” fila, la fusión continúa, pero ClickHouse trata esta situación como un error lógico y la registra en el registro del servidor. Este error puede producirse si se insertan los mismos datos más de una vez.
Por lo tanto, el colapso no debe cambiar los resultados del cálculo de las estadísticas.
Los cambios colapsaron gradualmente para que al final solo quedara el último estado de casi todos los objetos.
El `Sign` se requiere porque el algoritmo de fusión no garantiza que todas las filas con la misma clave de ordenación estarán en la misma parte de datos resultante e incluso en el mismo servidor físico. Proceso de ClickHouse `SELECT` consultas con múltiples hilos, y no puede predecir el orden de las filas en el resultado. La agregación es necesaria si hay una necesidad de obtener completamente “collapsed” datos de `CollapsingMergeTree` tabla.
Para finalizar el colapso, escriba una consulta con `GROUP BY` cláusula y funciones agregadas que representan el signo. Por ejemplo, para calcular la cantidad, use `sum(Sign)` en lugar de `count()`. Para calcular la suma de algo, use `sum(Sign * x)` en lugar de `sum(x)` y así sucesivamente, y también añadir `HAVING sum(Sign) > 0`.
Para finalizar el colapso, escriba una consulta con `GROUP BY` cláusula y funciones agregadas que representan el signo. Por ejemplo, para calcular la cantidad, use `sum(Sign)` es lugar de `count()`. Para calcular la suma de algo, use `sum(Sign * x)` es lugar de `sum(x)` y así sucesivamente, y también añadir `HAVING sum(Sign) > 0`.
Los agregados `count`, `sum` y `avg` podría calcularse de esta manera. El agregado `uniq` podría calcularse si un objeto tiene al menos un estado no colapsado. Los agregados `min` y `max` no se pudo calcular porque `CollapsingMergeTree` no guarda el historial de valores de los estados colapsados.
@ -188,7 +188,7 @@ SELECT * FROM UAct
¿Qué vemos y dónde está colapsando?
Con dos `INSERT` consultas, hemos creado 2 partes de datos. El `SELECT` la consulta se realizó en 2 hilos, y obtuvimos un orden aleatorio de filas. No se ha producido un colapso porque todavía no se había fusionado las partes de datos. ClickHouse fusiona parte de datos en un momento desconocido que no podemos predecir.
Con dos `INSERT` Consultas, hemos creado 2 partes de datos. El `SELECT` la consulta se realizó en 2 hilos, y obtuvimos un orden aleatorio de filas. No se ha producido un colapso porque todavía no se había fusionado las partes de datos. ClickHouse fusiona parte de datos en un momento desconocido que no podemos predecir.
Por lo tanto, necesitamos agregación:
@ -208,7 +208,7 @@ HAVING sum(Sign) > 0
└─────────────────────┴───────────┴──────────┘
```
Si no necesitamos agregación y queremos forzar el colapso, podemos usar `FINAL` modificador para `FROM` clausula.
Si no necesitamos agregación y queremos forzar el colapso, podemos usar `FINAL` Modificador para `FROM` clausula.
``` sql
SELECT * FROM UAct FINAL

6
docs/es/operations/table_engines/custom_partitioning_key.md
View File

@ -4,7 +4,7 @@ La partición está disponible para el [Método de codificación de datos:](merg
Una partición es una combinación lógica de registros en una tabla por un criterio especificado. Puede establecer una partición por un criterio arbitrario, como por mes, por día o por tipo de evento. Cada partición se almacena por separado para simplificar las manipulaciones de estos datos. Al acceder a los datos, ClickHouse utiliza el subconjunto más pequeño de particiones posible.
La partición se especifica en el `PARTITION BY expr` cláusula cuando [creando una tabla](mergetree.md#table_engine-mergetree-creating-a-table). La clave de partición puede ser cualquier expresión de las columnas de la tabla. Por ejemplo, para especificar la partición por mes, utilice la expresión `toYYYYMM(date_column)`:
La partición se especifica en el `PARTITION BY expr` cláusula cuando [Creando una tabla](mergetree.md#table_engine-mergetree-creating-a-table). La clave de partición puede ser cualquier expresión de las columnas de la tabla. Por ejemplo, para especificar la partición por mes, utilice la expresión `toYYYYMM(date_column)`:
``` sql
CREATE TABLE visits
@ -18,7 +18,7 @@ PARTITION BY toYYYYMM(VisitDate)
ORDER BY Hour;
```
La clave de partición también puede ser una tupla de expresiones (similar a la [clave primaria](mergetree.md#primary-keys-and-indexes-in-queries)). Por ejemplo:
La clave de partición también puede ser una tupla de expresiones (similar a la [Clave primaria](mergetree.md#primary-keys-and-indexes-in-queries)). Por ejemplo:
``` sql
ENGINE = ReplicatedCollapsingMergeTree('/clickhouse/tables/name', 'replica1', Sign)
@ -33,7 +33,7 @@ Al insertar datos nuevos en una tabla, estos datos se almacenan como una parte s
!!! info "INFO"
Una combinación solo funciona para partes de datos que tienen el mismo valor para la expresión de partición. Esto significa **no debe hacer particiones demasiado granulares** (más de un millar de particiones). De lo contrario, el `SELECT` consulta funciona mal debido a un número excesivamente grande de archivos en el sistema de archivos y descriptores de archivos abiertos.
Utilice el [sistema.parte](../system_tables.md#system_tables-parts) tabla para ver las partes y particiones de la tabla. Por ejemplo, supongamos que tenemos un `visits` tabla con partición por mes. Vamos a realizar el `SELECT` consulta para el `system.parts` tabla:
Descripción [sistema.parte](../system_tables.md#system_tables-parts) tabla para ver las partes y particiones de la tabla. Por ejemplo, supongamos que tenemos un `visits` tabla con partición por mes. Vamos a realizar el `SELECT` Consulta para el `system.parts` tabla:
``` sql
SELECT

2
docs/es/operations/table_engines/dictionary.md
View File

@ -1,6 +1,6 @@
# Diccionario {#dictionary}
El `Dictionary` el motor muestra el [diccionario](../../query_language/dicts/external_dicts.md) datos como una tabla ClickHouse.
El `Dictionary` el motor muestra el [Diccionario](../../query_language/dicts/external_dicts.md) datos como una tabla ClickHouse.
Como ejemplo, considere un diccionario de `products` con la siguiente configuración:

8
docs/es/operations/table_engines/distributed.md
View File

@ -76,7 +76,7 @@ Las réplicas están duplicando servidores (para leer todos los datos, puede acc
Los nombres de clúster no deben contener puntos.
Los parámetros `host`, `port`, y opcionalmente `user`, `password`, `secure`, `compression` se especifican para cada servidor:
Los parámetros `host`, `port`, y opcionalmente `user`, `password`, `secure`, `compression` Se especifican para cada servidor:
- `host` – La dirección del servidor remoto. Puede utilizar el dominio o la dirección IPv4 o IPv6. Si especifica el dominio, el servidor realiza una solicitud DNS cuando se inicia y el resultado se almacena mientras el servidor se esté ejecutando. Si la solicitud DNS falla, el servidor no se inicia. Si cambia el registro DNS, reinicie el servidor.
- `port` – El puerto TCP para la actividad de mensajería (‘tcp\_port’ en la configuración, generalmente establecido en 9000). No lo confundas con http\_port.
- `user` – Nombre del usuario para conectarse a un servidor remoto. Valor predeterminado: predeterminado. Este usuario debe tener acceso para conectarse al servidor especificado. El acceso se configura en los usuarios.archivo xml. Para obtener más información, consulte la sección [Derechos de acceso](../../operations/access_rights.md).
@ -114,7 +114,7 @@ Si este parámetro se establece en ‘true’, la operación de escritura selecc
Si se establece en ‘false’ (el valor predeterminado), los datos se escriben en todas las réplicas. En esencia, esto significa que la tabla distribuida replica los datos en sí. Esto es peor que usar tablas replicadas, porque no se verifica la consistencia de las réplicas y, con el tiempo, contendrán datos ligeramente diferentes.
Para seleccionar el fragmento al que se envía una fila de datos, se analiza la expresión de fragmentación y su resto se toma de dividirlo por el peso total de los fragmentos. La fila se envía al fragmento que corresponde al medio intervalo de los restos de ‘prev\_weight’ a ‘prev\_weights + weight’, donde ‘prev\_weights’ es el peso total de los fragmentos con el número más pequeño, y ‘weight’ es el peso de este fragmento. Por ejemplo, si hay dos fragmentos, y el primero tiene un peso de 9 mientras que el segundo tiene un peso de 10, la fila se enviará al primer fragmento para los restos del rango \[0, 9), y al segundo para los restos del rango \[9, 19).
Para seleccionar el fragmento al que se envía una fila de datos, se analiza la expresión de fragmentación y su resto se toma de dividirlo por el peso total de los fragmentos. La fila se envía al fragmento que corresponde al medio intervalo de los restos de ‘prev\_weight’ Naciones ‘prev\_weights + weight’, donde ‘prev\_weights’ es el peso total de los fragmentos con el número más pequeño, y ‘weight’ es el peso de este fragmento. Por ejemplo, si hay dos fragmentos, y el primero tiene un peso de 9 mientras que el segundo tiene un peso de 10, la fila se enviará al primer fragmento para los restos del rango \[0, 9), y al segundo para los restos del rango \[9, 19).
La expresión de fragmentación puede ser cualquier expresión de constantes y columnas de tabla que devuelva un entero. Por ejemplo, puede usar la expresión ‘rand()’ para la distribución aleatoria de datos, o ‘UserID’ para la distribución por el resto de dividir el ID del usuario (entonces los datos de un solo usuario residirán en un solo fragmento, lo que simplifica la ejecución de IN y JOIN por los usuarios). Si una de las columnas no se distribuye lo suficientemente uniformemente, puede envolverla en una función hash: intHash64(UserID) .
@ -133,7 +133,7 @@ Si el servidor dejó de existir o tuvo un reinicio aproximado (por ejemplo, desp
Cuando la opción max\_parallel\_replicas está habilitada, el procesamiento de consultas se paralela en todas las réplicas dentro de un solo fragmento. Para obtener más información, consulte la sección [max\_parallel\_replicas](../settings/settings.md#settings-max_parallel_replicas).
## Virtual Columnas {#virtual-columns}
## Columnas virtuales {#virtual-columns}
- `_shard_num` — Contiene el `shard_num` (de `system.clusters`). Tipo: [UInt32](../../data_types/int_uint.md).
@ -142,6 +142,6 @@ Cuando la opción max\_parallel\_replicas está habilitada, el procesamiento de
**Ver también**
- [Virtual columnas](index.md#table_engines-virtual_columns)
- [Columnas virtuales](index.md#table_engines-virtual_columns)
[Artículo Original](https://clickhouse.tech/docs/es/operations/table_engines/distributed/) <!--hide-->

2
docs/es/operations/table_engines/external_data.md
View File

@ -24,7 +24,7 @@ Los siguientes parámetros son opcionales: **–nombre**– Nombre de la tabla.
**–formato** – Formato de datos en el archivo. Si se omite, se utiliza TabSeparated.
Se requiere uno de los siguientes parámetros:**–tipo** – Una lista de tipos de columnas separadas por comas. Por ejemplo: `UInt64,String`. Las columnas se llamarán \_1, \_2, …
**–estructura**– La estructura de la tabla en el formato`UserID UInt64`, `URL String`. Define los nombres y tipos de columna.
**–estructura**– La estructura de la tabla en el formato`UserID UInt64`, `URL String`. Definir los nombres y tipos de columna.
Los archivos especificados en ‘file’ se analizará mediante el formato especificado en ‘format’ utilizando los tipos de datos especificados en ‘types’ o ‘structure’. La mesa será cargado en el servidor y accesibles, como una tabla temporal con el nombre de ‘name’.

4
docs/es/operations/table_engines/file.md
View File

@ -1,7 +1,7 @@
# File {#table-engines-file}
El motor de tabla de archivos mantiene los datos en un archivo en uno de los [file
formato](../../interfaces/formats.md#formats) (TabSeparated, Native, etc.).
Formato](../../interfaces/formats.md#formats) (TabSeparated, Native, etc.).
Ejemplos de uso:
@ -60,7 +60,7 @@ SELECT * FROM file_engine_table
└──────┴───────┘
```
## Uso en Clickhouse-local {#usage-in-clickhouse-local}
## Uso es Clickhouse-local {#usage-in-clickhouse-local}
En [Sistema abierto.](../utils/clickhouse-local.md) El motor de archivos acepta la ruta del archivo además de `Format`. Los flujos de entrada / salida predeterminados se pueden especificar utilizando nombres numéricos o legibles por humanos como `0` o `stdin`, `1` o `stdout`.
**Ejemplo:**

2
docs/es/operations/table_engines/graphitemergetree.md
View File

@ -2,7 +2,7 @@
Este motor está diseñado para el adelgazamiento y la agregación / promedio (rollup) [Grafito](http://graphite.readthedocs.io/en/latest/index.html) datos. Puede ser útil para los desarrolladores que desean usar ClickHouse como almacén de datos para Graphite.
Puede utilizar cualquier motor de tabla ClickHouse para almacenar los datos de grafito si no necesita un paquete acumulativo, pero si necesita un paquete acumulativo, use `GraphiteMergeTree`. El motor reduce el volumen de almacenamiento y aumenta la eficiencia de las consultas de Graphite.
Puede utilizar cualquier motor de tabla ClickHouse para almacenar los datos de grafito si no necesita un paquete acumulativo, pero si necesita un paquete acumulativo, use `GraphiteMergeTree`. El motor reduce el volumen de almacenamiento y aumenta la eficiencia de las consultas de Grafito.
El motor hereda propiedades de [Método de codificación de datos:](mergetree.md).

8
docs/es/operations/table_engines/hdfs.md
View File

@ -1,7 +1,7 @@
# HDFS {#table-engines-hdfs}
Este motor proporciona integración con [Acerca de nosotros](https://en.wikipedia.org/wiki/Apache_Hadoop) permitiendo gestionar datos sobre [HDFS](https://hadoop.apache.org/docs/current/hadoop-project-dist/hadoop-hdfs/HdfsDesign.html)a través de ClickHouse. Este motor es similar
a la [File](file.md) y [URL](url.md) motores, pero proporciona características específicas de Hadoop.
Angeles [File](file.md) y [URL](url.md) motores, pero proporciona características específicas de Hadoop.
## Uso {#usage}
@ -60,7 +60,7 @@ Múltiples componentes de ruta de acceso pueden tener globs. Para ser procesado,
- `{some_string,another_string,yet_another_one}` — Sustituye cualquiera de las cadenas `'some_string', 'another_string', 'yet_another_one'`.
- `{N..M}` — Sustituye cualquier número en el intervalo de N a M, incluidas ambas fronteras.
Construcciones con `{}` son similares a la [remoto](../../query_language/table_functions/remote.md) función de la tabla.
Construcciones con `{}` hijo similares a la [remoto](../../query_language/table_functions/remote.md) función de la tabla.
**Ejemplo**
@ -104,13 +104,13 @@ Crear tabla con archivos llamados `file000`, `file001`, … , `file999`:
CREARE TABLE big_table (name String, value UInt32) ENGINE = HDFS('hdfs://hdfs1:9000/big_dir/file{0..9}{0..9}{0..9}', 'CSV')
```
## Virtual Columnas {#virtual-columns}
## Columnas virtuales {#virtual-columns}
- `_path` — Ruta de acceso al archivo.
- `_file` — Nombre del expediente.
**Ver también**
- [Virtual columnas](https://clickhouse.tech/docs/es/operations/table_engines/#table_engines-virtual_columns)
- [Columnas virtuales](https://clickhouse.tech/docs/es/operations/table_engines/#table_engines-virtual_columns)
[Artículo Original](https://clickhouse.tech/docs/es/operations/table_engines/hdfs/) <!--hide-->

2
docs/es/operations/table_engines/index.md
View File

@ -64,7 +64,7 @@ Motores en la familia:
- [Memoria](memory.md)
- [Búfer](buffer.md)
## Virtual columnas {#table-engines-virtual-columns}
## Columnas virtuales {#table-engines-virtual-columns}
La columna virtual es un atributo de motor de tabla integral que se define en el código fuente del motor.

2
docs/es/operations/table_engines/jdbc.md
View File

@ -4,7 +4,7 @@ Permite que ClickHouse se conecte a bases de datos externas a través de [JDBC](
Para implementar la conexión JDBC, ClickHouse utiliza el programa independiente [Sistema abierto.](https://github.com/alex-krash/clickhouse-jdbc-bridge) que debería ejecutarse como un demonio.
Este motor soporta el [NULL](../../data_types/nullable.md) tipo de datos.
Este motor soporta el [NULO](../../data_types/nullable.md) tipo de datos.
## Creación de una tabla {#creating-a-table}

4
docs/es/operations/table_engines/join.md
View File

@ -74,7 +74,7 @@ SELECT joinGet('id_val_join', 'val', toUInt32(1))
### Selección e inserción de datos {#selecting-and-inserting-data}
Usted puede utilizar `INSERT` consultas para agregar datos al `Join`-mesas de motor. Si la tabla se creó con el `ANY` estricta, se ignoran los datos de las claves duplicadas. Con el `ALL` estricta, se agregan todas las filas.
Usted puede utilizar `INSERT` Consultas para agregar datos al `Join`-mesas de motor. Si la tabla se creó con el `ANY` estricta, se ignoran los datos de las claves duplicadas. Con el `ALL` estricta, se agregan todas las filas.
No se puede realizar una `SELECT` consulta directamente desde la tabla. En su lugar, use uno de los siguientes métodos:
@ -93,7 +93,7 @@ Al crear una tabla, se aplican los siguientes valores:
El `Join`-las tablas del motor no se pueden utilizar adentro `GLOBAL JOIN` operación.
El `Join`-motor permite el uso [Sistema abierto.](../settings/settings.md#join_use_nulls) ajuste en el `CREATE TABLE` instrucción. Y [SELECCIONAR](../../query_language/select.md) consulta permite el uso `join_use_nulls` demasiado. Si tienes diferentes `join_use_nulls` configuración, puede obtener un error al unirse a la tabla. Depende del tipo de JOIN. Cuando se utiliza [joinGet](../../query_language/functions/other_functions.md#joinget) función, usted tiene que utilizar el mismo `join_use_nulls` ajuste en `CRATE TABLE` y `SELECT` instrucción.
El `Join`-motor permite el uso [Sistema abierto.](../settings/settings.md#join_use_nulls) ajuste en el `CREATE TABLE` instrucción. Y [SELECCIONAR](../../query_language/select.md) Consulta permite el uso `join_use_nulls` demasiado. Si tienes diferentes `join_use_nulls` configuración, puede obtener un error al unirse a la tabla. Depende del tipo de JOIN. Cuando se utiliza [joinGet](../../query_language/functions/other_functions.md#joinget) función, usted tiene que utilizar el mismo `join_use_nulls` ajuste en `CRATE TABLE` y `SELECT` instrucción.
## Almacenamiento de datos {#data-storage}

10
docs/es/operations/table_engines/kafka.md
View File

@ -38,9 +38,9 @@ Parámetros requeridos:
Parámetros opcionales:
- `kafka_row_delimiter` – Carácter delimitador, que termina el mensaje.
- `kafka_schema` – Parámetro que debe utilizarse si el formato requiere una definición de esquema. Por ejemplo, [Cap’n Proto](https://capnproto.org/) requiere la ruta de acceso al archivo de esquema y el nombre de la raíz `schema.capnp:Message` objeto.
- `kafka_schema` – Parámetro que debe utilizarse si el formato requiere una definición de esquema. Por ejemplo, [Cap'n Proto](https://capnproto.org/) requiere la ruta de acceso al archivo de esquema y el nombre de la raíz `schema.capnp:Message` objeto.
- `kafka_num_consumers` – El número de consumidores por tabla. Predeterminado: `1`. Especifique más consumidores si el rendimiento de un consumidor es insuficiente. El número total de consumidores no debe exceder el número de particiones en el tema, ya que solo se puede asignar un consumidor por partición.
- `kafka_skip_broken_messages` – Tolerancia analizador de mensajes Kafka a los mensajes incompatibles con el esquema por bloque. Predeterminado: `0`. Si `kafka_skip_broken_messages = N` entonces el motor salta *Y* Mensajes de Kafka que no se pueden analizar (un mensaje es igual a una fila de datos).
- `kafka_skip_broken_messages` – Tolerancia analizador de mensajes Kafka a los mensajes incompatibles con el esquema por bloque. Predeterminado: `0`. Si `kafka_skip_broken_messages = N` Entonces el motor salta *Y* Mensajes de Kafka que no se pueden analizar (un mensaje es igual a una fila de datos).
Ejemplos:
@ -86,7 +86,7 @@ Kafka(kafka_broker_list, kafka_topic_list, kafka_group_name, kafka_format
</details>
## Descripci {#description}
## Descripción {#description}
Los mensajes entregados se realizan un seguimiento automático, por lo que cada mensaje de un grupo solo se cuenta una vez. Si desea obtener los datos dos veces, cree una copia de la tabla con otro nombre de grupo.
@ -154,7 +154,7 @@ Similar a GraphiteMergeTree, el motor Kafka admite una configuración extendida
Para obtener una lista de posibles opciones de configuración, consulte [referencia de configuración librdkafka](https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md). Usa el guión bajo (`_`) en lugar de un punto en la configuración de ClickHouse. Por ejemplo, `check.crcs=true` será `<check_crcs>true</check_crcs>`.
## Virtual Columnas {#virtual-columns}
## Columnas virtuales {#virtual-columns}
- `_topic` — El tema de Kafka.
- `_key` — Clave del mensaje.
@ -164,6 +164,6 @@ Para obtener una lista de posibles opciones de configuración, consulte [referen
**Ver también**
- [Virtual columnas](index.md#table_engines-virtual_columns)
- [Columnas virtuales](index.md#table_engines-virtual_columns)
[Artículo Original](https://clickhouse.tech/docs/es/operations/table_engines/kafka/) <!--hide-->

6
docs/es/operations/table_engines/merge.md
View File

@ -50,14 +50,14 @@ FROM WatchLog
└────────────┴────────┴───────────┴─────┘
```
## Virtual Columnas {#virtual-columns}
## Columnas virtuales {#virtual-columns}
- `_table` — Contiene el nombre de la tabla de la que se leyeron los datos. Tipo: [Cadena](../../data_types/string.md).
Puede establecer las condiciones constantes en `_table` en el `WHERE/PREWHERE` cláusula (por ejemplo, `WHERE _table='xyz'`). En este caso, la operación de lectura se realiza sólo para las tablas donde la condición en `_table` está satisfecho, por lo que el `_table` columna actúa como un índice.
Puede establecer las condiciones constantes en `_table` es el `WHERE/PREWHERE` cláusula (por ejemplo, `WHERE _table='xyz'`). En este caso, la operación de lectura se realiza sólo para las tablas donde la condición en `_table` está satisfecho, por lo que el `_table` columna actúa como un índice.
**Ver también**
- [Virtual columnas](index.md#table_engines-virtual_columns)
- [Columnas virtuales](index.md#table_engines-virtual_columns)
[Artículo Original](https://clickhouse.tech/docs/es/operations/table_engines/merge/) <!--hide-->

30
docs/es/operations/table_engines/mergetree.md
View File

@ -23,7 +23,7 @@ Principales características:
Si es necesario, puede establecer el método de muestreo de datos en la tabla.
!!! info "INFO"
El [Fusionar](merge.md) el motor no pertenece al `*MergeTree` familia.
El [Fusionar](merge.md) el motor no pertenece al `*MergeTree` Familia.
## Creación de una tabla {#table-engine-mergetree-creating-a-table}
@ -83,8 +83,8 @@ Para obtener una descripción de los parámetros, consulte [Descripción de la c
- `index_granularity` — Número máximo de filas de datos entre las marcas de un índice. Valor predeterminado: 8192. Ver [Almacenamiento de datos](#mergetree-data-storage).
- `index_granularity_bytes` — Tamaño máximo de los gránulos de datos en bytes. Valor predeterminado: 10 MB. Para restringir el tamaño del gránulo solo por el número de filas, establezca en 0 (no recomendado). Ver [Almacenamiento de datos](#mergetree-data-storage).
- `enable_mixed_granularity_parts` — Habilita o deshabilita la transición para controlar el tamaño del gránulo `index_granularity_bytes` configuración. Antes de la versión 19.11, sólo existía el `index_granularity` ajuste para restringir el tamaño del gránulo. El `index_granularity_bytes` mejora el rendimiento de ClickHouse al seleccionar datos de tablas con filas grandes (decenas y cientos de megabytes). Si tiene tablas con filas grandes, puede habilitar esta configuración para que las tablas mejoren la eficiencia de `SELECT` consulta.
- `use_minimalistic_part_header_in_zookeeper` — Método de almacenamiento de los encabezados de partes de datos en ZooKeeper. Si `use_minimalistic_part_header_in_zookeeper=1`, entonces ZooKeeper almacena menos datos. Para obtener más información, consulte [descripción del ajuste](../server_settings/settings.md#server-settings-use_minimalistic_part_header_in_zookeeper) en “Server configuration parameters”.
- `min_merge_bytes_to_use_direct_io` — El volumen mínimo de datos para la operación de fusión que se necesita para utilizar el acceso directo de E/S al disco de almacenamiento. Al fusionar partes de datos, ClickHouse calcula el volumen total de almacenamiento de todos los datos que se van a fusionar. Si el volumen excede `min_merge_bytes_to_use_direct_io` bytes, ClickHouse lee y escribe los datos en el disco de almacenamiento utilizando la interfaz de E / S directa (`O_DIRECT` opcion). Si `min_merge_bytes_to_use_direct_io = 0`, entonces la E/S directa está deshabilitada. Valor predeterminado: `10 * 1024 * 1024 * 1024` byte.
- `use_minimalistic_part_header_in_zookeeper` — Método de almacenamiento de los encabezados de partes de datos en ZooKeeper. Si `use_minimalistic_part_header_in_zookeeper=1`, entonces ZooKeeper almacena menos datos. Para obtener más información, consulte [descripción del ajuste](../server_settings/settings.md#server-settings-use_minimalistic_part_header_in_zookeeper) es “Server configuration parameters”.
- `min_merge_bytes_to_use_direct_io` — El volumen mínimo de datos para la operación de fusión que se necesita para utilizar el acceso directo de E/S al disco de almacenamiento. Al fusionar partes de datos, ClickHouse calcula el volumen total de almacenamiento de todos los datos que se van a fusionar. Si el volumen excede `min_merge_bytes_to_use_direct_io` bytes, ClickHouse lee y escribe los datos en el disco de almacenamiento utilizando la interfaz de E / S directa (`O_DIRECT` opción). Si `min_merge_bytes_to_use_direct_io = 0`, entonces la E/S directa está deshabilitada. Valor predeterminado: `10 * 1024 * 1024 * 1024` byte.
<a name="mergetree_setting-merge_with_ttl_timeout"></a>
- `merge_with_ttl_timeout` — Retraso mínimo en segundos antes de repetir una fusión con TTL. Valor predeterminado: 86400 (1 día).
- `write_final_mark` — Habilita o deshabilita la escritura de la marca de índice final al final de la parte de datos (después del último byte). Valor predeterminado: 1. No lo apague.
@ -99,7 +99,7 @@ ENGINE MergeTree() PARTITION BY toYYYYMM(EventDate) ORDER BY (CounterID, EventDa
En el ejemplo, configuramos la partición por mes.
También establecemos una expresión para el muestreo como un hash por el ID de usuario. Esto le permite pseudoaleatorizar los datos en la tabla para cada `CounterID` y `EventDate`. Si define un [MUESTRA](../../query_language/select.md#select-sample-clause) cláusula al seleccionar los datos, ClickHouse devolverá una muestra de datos pseudoaleatoria uniforme para un subconjunto de usuarios.
También establecemos una expresión para el muestreo como un hash por el ID de usuario. Esto le permite pseudoaleatorizar los datos en la tabla para cada `CounterID` y `EventDate`. Si definir un [MUESTRA](../../query_language/select.md#select-sample-clause) cláusula al seleccionar los datos, ClickHouse devolverá una muestra de datos pseudoaleatoria uniforme para un subconjunto de usuarios.
El `index_granularity` se puede omitir porque 8192 es el valor predeterminado.
@ -181,7 +181,7 @@ El número de columnas en la clave principal no está explícitamente limitado.
Si la clave principal es `(a, b)`, a continuación, añadir otra columna `c` mejorará el rendimiento si se cumplen las siguientes condiciones:
- Hay consultas con una condición en la columna `c`.
- Rangos de datos largos (varias veces más `index_granularity`) con valores idénticos para `(a, b)` son comunes. En otras palabras, al agregar otra columna le permite omitir rangos de datos bastante largos.
- Rangos de datos largos (varias veces más `index_granularity`) con valores idénticos para `(a, b)` hijo comunes. En otras palabras, al agregar otra columna le permite omitir rangos de datos bastante largos.
- Mejorar la compresión de datos.
@ -286,7 +286,7 @@ SELECT count() FROM table WHERE u64 * i32 == 10 AND u64 * length(s) >= 1234
- `set(max_rows)`
Almacena valores únicos de la expresión especificada (no más de `max_rows` filas, `max_rows=0` medio “no limits”). Utiliza los valores para comprobar si `WHERE` expresión no es satisfactorio en un bloque de datos.
Almacena valores únicos de la expresión especificada (no más de `max_rows` películas, `max_rows=0` medio “no limits”). Utiliza los valores para comprobar si `WHERE` expresión no es satisfactorio en un bloque de datos.
- `ngrambf_v1(n, size_of_bloom_filter_in_bytes, number_of_hash_functions, random_seed)`
@ -307,7 +307,7 @@ SELECT count() FROM table WHERE u64 * i32 == 10 AND u64 * length(s) >= 1234
Tipos de datos admitidos: `Int*`, `UInt*`, `Float*`, `Enum`, `Date`, `DateTime`, `String`, `FixedString`, `Array`, `LowCardinality`, `Nullable`.
Las siguientes funciones pueden usarlo: [igual](../../query_language/functions/comparison_functions.md), [notEquals](../../query_language/functions/comparison_functions.md), [en](../../query_language/functions/in_functions.md), [noEn](../../query_language/functions/in_functions.md), [tener](../../query_language/functions/array_functions.md).
Las siguientes funciones pueden usarlo: [igual](../../query_language/functions/comparison_functions.md), [notEquals](../../query_language/functions/comparison_functions.md), [es](../../query_language/functions/in_functions.md), [noEn](../../query_language/functions/in_functions.md), [Tener](../../query_language/functions/array_functions.md).
<!-- -->
@ -323,22 +323,22 @@ Condiciones en el `WHERE` cláusula contiene llamadas de las funciones que opera
El `set` index se puede utilizar con todas las funciones. Subconjuntos de funciones para otros índices se muestran en la siguiente tabla.
| Función (operador) / Índice | clave primaria | minmax | Descripción | Sistema abierto. | bloom\_filter |
| Función (operador) / Índice | Clave primaria | minmax | Descripción | Sistema abierto. | bloom\_filter |
|--------------------------------------------------------------------------------------------------------|----------------|--------|-------------|------------------|---------------|
| [igual (=, ==)](../../query_language/functions/comparison_functions.md#function-equals) | ✔ | ✔ | ✔ | ✔ | ✔ |
| [¿Por qué?)](../../query_language/functions/comparison_functions.md#function-equals) | ✔ | ✔ | ✔ | ✔ | ✔ |
| [notEquals(!Número)](../../query_language/functions/comparison_functions.md#function-notequals) | ✔ | ✔ | ✔ | ✔ | ✔ |
| [como](../../query_language/functions/string_search_functions.md#function-like) | ✔ | ✔ | ✔ | ✗ | ✗ |
| [No como](../../query_language/functions/string_search_functions.md#function-notlike) | ✔ | ✔ | ✔ | ✗ | ✗ |
| [Comienza con](../../query_language/functions/string_functions.md#startswith) | ✔ | ✔ | ✔ | ✔ | ✗ |
| [Finaliza con](../../query_language/functions/string_functions.md#endswith) | ✗ | ✗ | ✔ | ✔ | ✗ |
| [multiSearchAny](../../query_language/functions/string_search_functions.md#function-multisearchany) | ✗ | ✗ | ✔ | ✗ | ✗ |
| [en](../../query_language/functions/in_functions.md#in-functions) | ✔ | ✔ | ✔ | ✔ | ✔ |
| [es](../../query_language/functions/in_functions.md#in-functions) | ✔ | ✔ | ✔ | ✔ | ✔ |
| [noEn](../../query_language/functions/in_functions.md#in-functions) | ✔ | ✔ | ✔ | ✔ | ✔ |
| [menos (\<)](../../query_language/functions/comparison_functions.md#function-less) | ✔ | ✔ | ✗ | ✗ | ✗ |
| [mayor (\>)](../../query_language/functions/comparison_functions.md#function-greater) | ✔ | ✔ | ✗ | ✗ | ✗ |
| [Alcalde (\>)](../../query_language/functions/comparison_functions.md#function-greater) | ✔ | ✔ | ✗ | ✗ | ✗ |
| [menosOrEquals (\<=)](../../query_language/functions/comparison_functions.md#function-lessorequals) | ✔ | ✔ | ✗ | ✗ | ✗ |
| [mayorOrEquals (\>=)](../../query_language/functions/comparison_functions.md#function-greaterorequals) | ✔ | ✔ | ✗ | ✗ | ✗ |
| [vaciar](../../query_language/functions/array_functions.md#function-empty) | ✔ | ✔ | ✗ | ✗ | ✗ |
| [Vaciar](../../query_language/functions/array_functions.md#function-empty) | ✔ | ✔ | ✗ | ✗ | ✗ |
| [notEmpty](../../query_language/functions/array_functions.md#function-notempty) | ✔ | ✔ | ✗ | ✗ | ✗ |
| hasToken | ✗ | ✗ | ✗ | ✔ | ✗ |
@ -471,7 +471,7 @@ Los datos con un TTL caducado se eliminan cuando ClickHouse fusiona partes de da
Cuando ClickHouse ve que los datos han caducado, realiza una combinación fuera de programación. Para controlar la frecuencia de tales fusiones, puede establecer [Método de codificación de datos:](#mergetree_setting-merge_with_ttl_timeout). Si el valor es demasiado bajo, realizará muchas fusiones fuera de horario que pueden consumir muchos recursos.
Si realiza el `SELECT` consulta entre fusiones, puede obtener datos caducados. Para evitarlo, use el [OPTIMIZAR](../../query_language/misc.md#misc_operations-optimize) consulta antes `SELECT`.
Si realiza el `SELECT` consulta entre fusiones, puede obtener datos caducados. Para evitarlo, use el [OPTIMIZAR](../../query_language/misc.md#misc_operations-optimize) Consulta antes `SELECT`.
[Artículo Original](https://clickhouse.tech/docs/es/operations/table_engines/mergetree/) <!--hide-->
@ -490,11 +490,11 @@ La parte de datos es la unidad móvil mínima para `MergeTree`-mesas de motor. L
- Volumen — Conjunto ordenado de discos iguales (similar a [JBOD](https://en.wikipedia.org/wiki/Non-RAID_drive_architectures)).
- Política de almacenamiento: conjunto de volúmenes y reglas para mover datos entre ellos.
Los nombres dados a las entidades descritas se pueden encontrar en las tablas del sistema, [sistema.almacenamiento\_policies](../system_tables.md#system_tables-storage_policies) y [sistema.disco](../system_tables.md#system_tables-disks). Para aplicar una de las directivas de almacenamiento configuradas para una tabla, `storage_policy` establecimiento de `MergeTree`-mesas de la familia del motor.
Los nombres dados a las entidades descritas se pueden encontrar en las tablas del sistema, [sistema.almacenamiento\_policies](../system_tables.md#system_tables-storage_policies) y [sistema.Discoteca](../system_tables.md#system_tables-disks). Para aplicar una de las directivas de almacenamiento configuradas para una tabla, `storage_policy` establecimiento de `MergeTree`-mesas de la familia del motor.
### Configuración {#table-engine-mergetree-multiple-volumes-configure}
Los discos, los volúmenes y las políticas de almacenamiento deben declararse `<storage_configuration>` etiqueta ya sea en el archivo principal `config.xml` o en un archivo distinto en el `config.d` directorio.
Los discos, los volúmenes y las políticas de almacenamiento deben declararse `<storage_configuration>` etiqueta ya sea en el archivo principal `config.xml` o en un archivo distinto en el `config.d` Directorio.
Estructura de configuración:

8
docs/es/operations/table_engines/mysql.md
View File

@ -1,6 +1,6 @@
# MySQL {#mysql}
El motor MySQL le permite realizar `SELECT` consultas sobre datos almacenados en un servidor MySQL remoto.
El motor MySQL le permite realizar `SELECT` Consultas sobre datos almacenados en un servidor MySQL remoto.
## Creación de una tabla {#creating-a-table}
@ -18,7 +18,7 @@ Vea una descripción detallada del [CREAR TABLA](../../query_language/create.md#
La estructura de la tabla puede diferir de la estructura de la tabla MySQL original:
- Los nombres de columna deben ser los mismos que en la tabla MySQL original, pero puede usar solo algunas de estas columnas y en cualquier orden.
- Los tipos de columna pueden diferir de los de la tabla MySQL original. ClickHouse intenta [elenco](../../query_language/functions/type_conversion_functions.md#type_conversion_function-cast) valores a los tipos de datos ClickHouse.
- Los tipos de columna pueden diferir de los de la tabla MySQL original. Haga clic en Casa intenta [elenco](../../query_language/functions/type_conversion_functions.md#type_conversion_function-cast) valores a los tipos de datos ClickHouse.
**Parámetros del motor**
@ -32,13 +32,13 @@ La estructura de la tabla puede diferir de la estructura de la tabla MySQL origi
- `password` — Contraseña de usuario.
- `replace_query` — Bandera que convierte `INSERT INTO` consultas a `REPLACE INTO`. Si `replace_query=1`, la consulta se sustituye.
- `replace_query` — Bandera que convierte `INSERT INTO` Consultas a `REPLACE INTO`. Si `replace_query=1`, la consulta se sustituye.
- `on_duplicate_clause` — El `ON DUPLICATE KEY on_duplicate_clause` expresión que se añade a la `INSERT` consulta.
Ejemplo: `INSERT INTO t (c1,c2) VALUES ('a', 2) ON DUPLICATE KEY UPDATE c2 = c2 + 1`, donde `on_duplicate_clause` ser `UPDATE c2 = c2 + 1`. Ver el [Documentación de MySQL](https://dev.mysql.com/doc/refman/8.0/en/insert-on-duplicate.html) para encontrar qué `on_duplicate_clause` se puede utilizar con el `ON DUPLICATE KEY` clausula.
Especificar `on_duplicate_clause` tienes que pasar `0` a la `replace_query` parámetro. Si pasa simultáneamente `replace_query = 1` y `on_duplicate_clause`, ClickHouse genera una excepción.
Especificar `on_duplicate_clause` tienes que pasar `0` Angeles `replace_query` parámetro. Si pasa simultáneamente `replace_query = 1` y `on_duplicate_clause`, ClickHouse genera una excepción.
Simple `WHERE` cláusulas tales como `=, !=, >, >=, <, <=` se ejecutan en el servidor MySQL.

4
docs/es/operations/table_engines/odbc.md
View File

@ -4,7 +4,7 @@ Permite que ClickHouse se conecte a bases de datos externas a través de [ODBC](
Para implementar con seguridad conexiones ODBC, ClickHouse usa un programa separado `clickhouse-odbc-bridge`. Si el controlador ODBC se carga directamente desde `clickhouse-server`, problemas de controlador pueden bloquear el servidor ClickHouse. ClickHouse se inicia automáticamente `clickhouse-odbc-bridge` cuando se requiere. El programa de puente ODBC se instala desde el mismo paquete que el `clickhouse-server`.
Este motor soporta el [NULL](../../data_types/nullable.md) tipo de datos.
Este motor soporta el [NULO](../../data_types/nullable.md) tipo de datos.
## Creación de una tabla {#creating-a-table}
@ -23,7 +23,7 @@ Vea una descripción detallada del [CREAR TABLA](../../query_language/create.md#
La estructura de la tabla puede diferir de la estructura de la tabla de origen:
- Los nombres de columna deben ser los mismos que en la tabla de origen, pero puede usar solo algunas de estas columnas y en cualquier orden.
- Los tipos de columna pueden diferir de los de la tabla de origen. ClickHouse intenta [elenco](../../query_language/functions/type_conversion_functions.md#type_conversion_function-cast) valores a los tipos de datos ClickHouse.
- Los tipos de columna pueden diferir de los de la tabla de origen. Haga clic en Casa intenta [elenco](../../query_language/functions/type_conversion_functions.md#type_conversion_function-cast) valores a los tipos de datos ClickHouse.
**Parámetros del motor**

4
docs/es/operations/table_engines/replacingmergetree.md
View File

@ -1,8 +1,8 @@
# ReplacingMergeTree {#replacingmergetree}
El motor difiere de [Método de codificación de datos:](mergetree.md#table_engines-mergetree) en que elimina las entradas duplicadas con el mismo valor de clave principal (o más exactamente, con el mismo [clave de clasificación](mergetree.md) valor).
El motor difiere de [Método de codificación de datos:](mergetree.md#table_engines-mergetree) en que elimina las entradas duplicadas con el mismo valor de clave principal (o más exactamente, con el mismo [clave de clasificación](mergetree.md) de valor).
La desduplicación de datos solo se produce durante una fusión. La fusión se produce en segundo plano en un momento desconocido, por lo que no se puede planificar para ello. Algunos de los datos pueden permanecer sin procesar. Aunque puede ejecutar una fusión no programada utilizando el `OPTIMIZE` consulta, no cuente con su uso, porque el `OPTIMIZE` consulta leerá y escribirá una gran cantidad de datos.
La desduplicación de datos solo se produce durante una fusión. La fusión se produce en segundo plano en un momento desconocido, por lo que no se puede planificar para ello. Algunos de los datos pueden permanecer sin procesar. Aunque puede ejecutar una fusión no programada utilizando el `OPTIMIZE` Consulta, no cuente con su uso, porque el `OPTIMIZE` consulta leerá y escribirá una gran cantidad de datos.
Así, `ReplacingMergeTree` es adecuado para borrar datos duplicados en segundo plano para ahorrar espacio, pero no garantiza la ausencia de duplicados.

6
docs/es/operations/table_engines/replication.md
View File

@ -60,9 +60,9 @@ Para clústeres muy grandes, puede usar diferentes clústeres de ZooKeeper para
La replicación es asíncrona y multi-master. `INSERT` consultas (así como `ALTER`) se puede enviar a cualquier servidor disponible. Los datos se insertan en el servidor donde se ejecuta la consulta y, a continuación, se copian a los demás servidores. Debido a que es asincrónico, los datos insertados recientemente aparecen en las otras réplicas con cierta latencia. Si parte de las réplicas no está disponible, los datos se escriben cuando estén disponibles. Si hay una réplica disponible, la latencia es la cantidad de tiempo que tarda en transferir el bloque de datos comprimidos a través de la red.
De forma predeterminada, una consulta INSERT espera la confirmación de la escritura de los datos de una sola réplica. Si los datos fue correctamente escrito a sólo una réplica y el servidor con esta réplica deja de existir, los datos almacenados se perderán. Para habilitar la confirmación de las escrituras de datos de varias réplicas, utilice `insert_quorum` opcion.
De forma predeterminada, una consulta INSERT espera la confirmación de la escritura de los datos de una sola réplica. Si los datos fue correctamente escrito a sólo una réplica y el servidor con esta réplica deja de existir, los datos almacenados se perderán. Para habilitar la confirmación de las escrituras de datos de varias réplicas, utilice `insert_quorum` opción.
Cada bloque de datos se escribe atómicamente. La consulta INSERT se divide en bloques hasta `max_insert_block_size = 1048576` filas. En otras palabras, si el `INSERT` consulta tiene menos de 1048576 filas, se hace atómicamente.
Cada bloque de datos se escribe atómicamente. La consulta INSERT se divide en bloques hasta `max_insert_block_size = 1048576` películas. En otras palabras, si el `INSERT` consulta tiene menos de 1048576 filas, se hace atómicamente.
Los bloques de datos se deduplican. Para varias escrituras del mismo bloque de datos (bloques de datos del mismo tamaño que contienen las mismas filas en el mismo orden), el bloque solo se escribe una vez. La razón de esto es en caso de errores de red cuando la aplicación cliente no sabe si los datos se escribieron en la base de datos, por lo que `INSERT` consulta simplemente se puede repetir. No importa a qué réplica se enviaron los INSERT con datos idénticos. `INSERTs` son idempotentes. Los parámetros de desduplicación son controlados por [merge\_tree](../server_settings/settings.md#server_settings-merge_tree) configuración del servidor.
@ -158,7 +158,7 @@ Cuando el servidor se inicia (o establece una nueva sesión con ZooKeeper), solo
Si el conjunto local de datos difiere demasiado del esperado, se activa un mecanismo de seguridad. El servidor ingresa esto en el registro y se niega a iniciarse. La razón de esto es que este caso puede indicar un error de configuración, como si una réplica en un fragmento se configurara accidentalmente como una réplica en un fragmento diferente. Sin embargo, los umbrales para este mecanismo se establecen bastante bajos, y esta situación puede ocurrir durante la recuperación de falla normal. En este caso, los datos se restauran semiautomáticamente, mediante “pushing a button”.
Para iniciar la recuperación, cree el nodo `/path_to_table/replica_name/flags/force_restore_data` en ZooKeeper con cualquier contenido, o ejecute el comando para restaurar todas las tablas replicadas:
Para iniciar la recuperación, cree el nodo `/path_to_table/replica_name/flags/force_restore_data` es ZooKeeper con cualquier contenido, o ejecute el comando para restaurar todas las tablas replicadas:
``` bash
sudo -u clickhouse touch /var/lib/clickhouse/flags/force_restore_data

6
docs/es/operations/table_engines/stripelog.md
View File

@ -19,7 +19,7 @@ Vea la descripción detallada del [CREAR TABLA](../../query_language/create.md#c
## Escribir los datos {#table-engines-stripelog-writing-the-data}
El `StripeLog` el motor almacena todas las columnas en un archivo. Para cada `INSERT` consulta, ClickHouse agrega el bloque de datos al final de un archivo de tabla, escribiendo columnas una por una.
El `StripeLog` el motor almacena todas las columnas en un archivo. Para cada `INSERT` ClickHouse agrega el bloque de datos al final de un archivo de tabla, escribiendo columnas una por una.
Para cada tabla, ClickHouse escribe los archivos:
@ -30,7 +30,7 @@ El `StripeLog` el motor no soporta el `ALTER UPDATE` y `ALTER DELETE` operación
## Lectura de los datos {#table-engines-stripelog-reading-the-data}
El archivo con marcas permite ClickHouse paralelizar la lectura de datos. Esto significa que un `SELECT` query devuelve filas en un orden impredecible. Utilice el `ORDER BY` cláusula para ordenar filas.
El archivo con marcas permite ClickHouse paralelizar la lectura de datos. Esto significa que un `SELECT` consulta devuelve filas en un orden impredecible. Descripción `ORDER BY` cláusula para ordenar filas.
## Ejemplo de uso {#table-engines-stripelog-example-of-use}
@ -46,7 +46,7 @@ CREATE TABLE stripe_log_table
ENGINE = StripeLog
```
Insertar datos:
Inserte datos:
``` sql
INSERT INTO stripe_log_table VALUES (now(),'REGULAR','The first regular message')

6
docs/es/operations/table_engines/summingmergetree.md
View File

@ -68,7 +68,7 @@ ENGINE = SummingMergeTree()
ORDER BY key
```
Insertar datos:
Inserte datos:
``` sql
INSERT INTO summtt Values(1,1),(1,2),(2,1)
@ -113,7 +113,7 @@ La tabla puede tener estructuras de datos anidadas que se procesan de una manera
Si el nombre de una tabla anidada termina con `Map` y contiene al menos dos columnas que cumplen los siguientes criterios:
- la primera columna es numérica `(*Int*, Date, DateTime)` o una cadena `(String, FixedString)`, vamos a llamarlo `key`,
- la primera columna es numérica `(*Int*, Date, DateTime)` O una cadena `(String, FixedString)`, vamos a llamarlo `key`,
- las otras columnas son aritméticas `(*Int*, Float32/64)`, vamos a llamarlo `(values...)`,
entonces esta tabla anidada se interpreta como una asignación de `key => (values...)`, y al fusionar sus filas, los elementos de dos conjuntos de datos se fusionan por `key` con una suma de los correspondientes `(values...)`.
@ -127,7 +127,7 @@ Ejemplos:
[(1, 100), (2, 150)] + [(1, -100)] -> [(2, 150)]
```
Al solicitar datos, utilice el [sumMap(clave, valor)](../../query_language/agg_functions/reference.md) función para la agregación de `Map`.
Al solicitar datos, utilice el [SumMap (clave, valor)](../../query_language/agg_functions/reference.md) función para la agregación de `Map`.
Para la estructura de datos anidados, no necesita especificar sus columnas en la tupla de columnas para la suma.

2
docs/es/operations/table_engines/tinylog.md
View File

@ -4,6 +4,6 @@ El motor pertenece a la familia de motores de registro. Ver [Familia del motor d
Este motor de tablas se usa normalmente con el método write-once: escribir datos una vez, luego leerlos tantas veces como sea necesario. Por ejemplo, puede usar `TinyLog`-type tablas para datos intermedios que se procesan en pequeños lotes. Tenga en cuenta que el almacenamiento de datos en un gran número de tablas pequeñas es ineficiente.
Las consultas se ejecutan en una sola secuencia. En otras palabras, este motor está diseñado para tablas relativamente pequeñas (hasta aproximadamente 1,000,000 filas). Tiene sentido utilizar este motor de tablas si tiene muchas tablas pequeñas, ya que es más simple que el [Registro](log.md) motor (menos archivos necesitan ser abiertos).
Las consultas se ejecutan en una sola secuencia. En otras palabras, este motor está diseñado para tablas relativamente pequeñas (hasta aproximadamente 1,000,000 filas). Tiene sentido utilizar este motor de tablas si tiene muchas tablas pequeñas, ya que es más simple que el [Registro](log.md) motor (menos archivos necesitan ser abiertos.
[Artículo Original](https://clickhouse.tech/docs/es/operations/table_engines/tinylog/) <!--hide-->

8
docs/es/operations/table_engines/url.md
View File

@ -1,7 +1,7 @@
# URL(URL, Formato) {#table-engines-url}
# Nombre de la red inalámbrica (SSID):) {#table-engines-url}
Administra datos en un servidor HTTP/HTTPS remoto. Este motor es similar
a la [File](file.md) motor.
Angeles [File](file.md) motor.
## Uso del motor en el servidor ClickHouse {#using-the-engine-in-the-clickhouse-server}
@ -13,8 +13,8 @@ El `URL` debe ajustarse a la estructura de un localizador uniforme de recursos.
que utiliza HTTP o HTTPS. Esto no requiere ningún
encabezados adicionales para obtener una respuesta del servidor.
`INSERT` y `SELECT` las consultas se transforman en `POST` y `GET` peticiones,
respectivamente. Para el procesamiento `POST` solicitudes, el servidor remoto debe admitir
`INSERT` y `SELECT` las consultas se transforman en `POST` y `GET` Peticiones,
Respectivamente. Para el procesamiento `POST` solicitudes, el servidor remoto debe admitir
[Codificación de transferencia fragmentada](https://en.wikipedia.org/wiki/Chunked_transfer_encoding).
Puede limitar el número máximo de saltos de redirección HTTP GET utilizando el [Nombre de la red inalámbrica (SSID):](../settings/settings.md#setting-max_http_get_redirects) configuración.

10
docs/es/operations/table_engines/versionedcollapsingmergetree.md
View File

@ -32,7 +32,7 @@ Para obtener una descripción de los parámetros de consulta, consulte [descripc
VersionedCollapsingMergeTree(sign, version)
```
- `sign` — Nombre de la columna con el tipo de fila: `1` es una “state” fila, `-1` es una “cancel” fila.
- `sign` — Nombre de la columna con el tipo de fila: `1` es una “state” fila, `-1` es una “cancel” Fila.
El tipo de datos de columna debe ser `Int8`.
@ -62,7 +62,7 @@ CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
Todos los parámetros excepto `sign` y `version` el mismo significado que en `MergeTree`.
- `sign` — Nombre de la columna con el tipo de fila: `1` es una “state” fila, `-1` es una “cancel” fila.
- `sign` — Nombre de la columna con el tipo de fila: `1` es una “state” fila, `-1` es una “cancel” Fila.
Tipo de datos de columna — `Int8`.
@ -78,7 +78,7 @@ Todos los parámetros excepto `sign` y `version` el mismo significado que en `Me
Considere una situación en la que necesite guardar datos que cambien continuamente para algún objeto. Es razonable tener una fila para un objeto y actualizar la fila siempre que haya cambios. Sin embargo, la operación de actualización es costosa y lenta para un DBMS porque requiere volver a escribir los datos en el almacenamiento. La actualización no es aceptable si necesita escribir datos rápidamente, pero puede escribir los cambios en un objeto secuencialmente de la siguiente manera.
Utilice el `Sign` columna al escribir la fila. Si `Sign = 1` significa que la fila es un estado de un objeto (llamémoslo el “state” fila). Si `Sign = -1` indica la cancelación del estado de un objeto con los mismos atributos (llamémoslo el “cancel” fila). También use el `Version` columna, que debe identificar cada estado de un objeto con un número separado.
Descripción `Sign` columna al escribir la fila. Si `Sign = 1` significa que la fila es un estado de un objeto (llamémoslo el “state” fila). Si `Sign = -1` indica la cancelación del estado de un objeto con los mismos atributos (llamémoslo el “cancel” fila). También use el `Version` columna, que debe identificar cada estado de un objeto con un número separado.
Por ejemplo, queremos calcular cuántas páginas visitaron los usuarios en algún sitio y cuánto tiempo estuvieron allí. En algún momento escribimos la siguiente fila con el estado de la actividad del usuario:
@ -116,7 +116,7 @@ Para averiguar por qué necesitamos dos filas para cada cambio, vea [Algoritmo](
**Notas sobre el uso**
1. El programa que escribe los datos debe recordar el estado de un objeto para cancelarlo. El “cancel” cadena debe ser una copia de la “state” con lo opuesto `Sign`. Esto aumenta el tamaño inicial de almacenamiento, pero permite escribir los datos rápidamente.
1. El programa que escribe los datos debe recordar el estado de un objeto para cancelarlo. El “cancel” Cadena debe ser una copia de la “state” con lo opuesto `Sign`. Esto aumenta el tamaño inicial de almacenamiento, pero permite escribir los datos rápidamente.
2. Las matrices de largo crecimiento en columnas reducen la eficiencia del motor debido a la carga para escribir. Cuanto más sencillos sean los datos, mejor será la eficiencia.
3. `SELECT` Los resultados dependen en gran medida de la coherencia del historial de cambios de objetos. Sea preciso al preparar los datos para insertarlos. Puede obtener resultados impredecibles con datos incoherentes, como valores negativos para métricas no negativas, como la profundidad de la sesión.
@ -130,7 +130,7 @@ Cuando ClickHouse inserta datos, ordena filas por la clave principal. Si el `Ver
ClickHouse no garantiza que todas las filas con la misma clave principal estarán en la misma parte de datos resultante o incluso en el mismo servidor físico. Esto es cierto tanto para escribir los datos como para la posterior fusión de las partes de datos. Además, ClickHouse procesa `SELECT` consultas con múltiples subprocesos, y no puede predecir el orden de las filas en el resultado. Esto significa que la agregación es necesaria si hay una necesidad de obtener completamente “collapsed” datos de un `VersionedCollapsingMergeTree` tabla.
Para finalizar el colapso, escriba una consulta con un `GROUP BY` cláusula y funciones agregadas que representan el signo. Por ejemplo, para calcular la cantidad, use `sum(Sign)` en lugar de `count()`. Para calcular la suma de algo, use `sum(Sign * x)` en lugar de `sum(x)` y agregar `HAVING sum(Sign) > 0`.
Para finalizar el colapso, escriba una consulta con un `GROUP BY` cláusula y funciones agregadas que representan el signo. Por ejemplo, para calcular la cantidad, use `sum(Sign)` es lugar de `count()`. Para calcular la suma de algo, use `sum(Sign * x)` es lugar de `sum(x)` y agregar `HAVING sum(Sign) > 0`.
Los agregados `count`, `sum` y `avg` se puede calcular de esta manera. El agregado `uniq` se puede calcular si un objeto tiene al menos un estado no colapsado. Los agregados `min` y `max` no se puede calcular porque `VersionedCollapsingMergeTree` no guarda el historial de valores de estados colapsados.

Some files were not shown because too many files have changed in this diff Show More