# Generador de datos sintéticos

En muchas circunstancias, es necesario tener un conjunto de datos de prueba para evaluar enfoques de implementación alternativos o realizar evaluaciones comparativas. A menudo se requiere que tal conjunto de datos tenga requisitos particulares en tamaño o en las características intrínsecas de sus datos. Incluso si un conjunto de datos del mundo real pudiera estar disponible, puede que no sea ideal para tales experimentos por múltiples razones. Por lo tanto, un generador de datos sintéticos que pueda personalizarse para producir datos de acuerdo con los requisitos dados suele ser la mejor solución. Obviamente, los experimentos con datos sintéticos deben complementarse con experimentos con datos del mundo real para tener una comprensión profunda del problema en cuestión.

MobilityDB proporciona un generador simple de datos sintéticos que se puede utilizar para tales fines. En particular, se utilizó este generador de datos para generar la base de datos utilizada para las pruebas de regresión en MobilityDB. El generador de datos está programado en PL/pgSQL para que se pueda personalizar fácilmente. Se encuentra en el directorio `datagen` en el repositorio. En este apéndice, presentamos brevemente la funcionalidad básica del generador. Primero enumeramos las funciones que generan valores aleatorios para varios tipos de datos de PostgreSQL, PostGIS y MobilityDB y luego damos ejemplos de cómo se usan estas funciones para generar tablas de dichos valores. Los parámetros de las funciones no están especificados, consulte los archivos fuente donde se pueden encontrar explicaciones detalladas sobre los distintos parámetros.

## Generador para tipos PostgreSQL

- `random_bool`: Generar un booleano aleatorio

- `random_int`: Generar un entero aleatorio

- `random_int_array`: Generar una matriz de enteros aleatorios

- `random_int4range`: Generar un rango aleatorio de enteros

- `random_float`: Generar un número flotante aleatorio

- `random_float_array`: Generar una matriz de números flotantes aleatorios

- `random_text`: Generar un texto aleatorio

- `random_timestamptz`: Generar una marca de tiempo con zona horaria aleatoria

- `random_timestamptz_array`: Generar una matriz de marcas de tiempo con zona horaria aleatorias

- `random_minutes`: Generar un intervalo de minutos aleatorio

- `random_tstzrange`: Generar rango aleatorio de marcas de tiempo con zona horaria

- `random_tstzrange_array`: Generar una matriz de rangos aleatorios de marcas de tiempo con zona horaria

## Generador para tipos PostGIS

- `random_geom_point`: Generar un punto geométrico 2D aleatorio

- `random_geom_point3D`: Generar un punto geométrico 3D aleatorio

- `random_geog_point`: Generar un punto geográfico 2D aleatorio

- `random_geog_point3D`: Generar un punto geográfico 3D aleatorio

- `random_geom_point_array`: Generar una matriz de puntos geométricos 2D aleatorios

- `random_geom_point3D_array`: Generar una matriz de puntos geométricos 3D aleatorios

- `random_geog_point_array`: Generar una matriz puntos geográficos 2D aleatorios

- `random_geog_point3D_array`: Generar una matriz de puntos geográficos 3D aleatorios

- `random_geom_linestring`: Generar una cadena lineal geométrica 2D aleatoria

- `random_geom_linestring3D`: Generar una cadena lineal geométrica 3D aleatoria

- `random_geog_linestring`: Generar una cadena lineal geográfica 2D aleatoria

- `random_geog_linestring3D`: Generar una cadena lineal geográfica 3D aleatoria

- `random_geom_polygon`: Generar un polígono geométrico 2D sin agujeros aleatorio

- `random_geom_polygon3D`: Generar un polígono geométrico 3D sin agujeros aleatorio

- `random_geog_polygon`: Generar un polígono geográfico 2D sin agujeros aleatorio

- `random_geog_polygon3D`: Generar un polígono geográfico 3D sin agujeros aleatorio

- `random_geom_multipoint`: Generar un multipunto geométrico 2D aleatorio

- `random_geom_multipoint3D`: Generar un multipunto geométrico 3D aleatorio

- `random_geog_multipoint`: Generar un multipunto geográfico 2D aleatorio

- `random_geog_multipoint3D`: Generar un multipunto geográfico 3D aleatorio

- `random_geom_multilinestring`: Generar una multicadena lineal geométrica 2D aleatoria

- `random_geom_multilinestring3D`: Generar una multicadena lineal geométrica 3D aleatoria

- `random_geog_multilinestring`: Generar una multicadena lineal geográfica 2D aleatoria

- `random_geog_multilinestring3D`: Generar una multicadena lineal geográfica 3D aleatoria

- `random_geom_multipolygon`: Generar un multipolígono geométrico 2D sin agujeros aleatorio

- `random_geom_multipolygon3D`: Generar un multipolígono geométrico 3D sin agujeros aleatorio

- `random_geog_multipolygon`: Generar un multipolígono geográfico 2D sin agujeros aleatorio

- `random_geog_multipolygon3D`: Generar un multipolígono geográfico 3D sin agujeros aleatorio

## Generador para tipos de rango, de tiempo y de cuadro delimitador MobilityDB

- `random_intspan`: Generar un rango aleatorio de enteros

- `random_floatspan`: Generar un rango aleatorio de números flotantes

- `random_tstzspan`: Generar un `tstzspan` aleatorio

- `random_tstzspan_array`: Generar una matriz de valores `tstzspan` aleatorios

- `random_tstzset`: Generar un `tstzset` aleatorio

- `random_tstzspanset`: Generar un `tstzspanset` aleatorio

- `random_tbox`: Generar un `tbox` aleatorio

- `random_stbox`: Generar un `stbox` 2D aleatorio

- `random_stbox3D`: Generar un `stbox` 3D aleatorio

- `random_geodstbox`: Generar un `stbox` geodético 2D aleatorio

- `random_geodstbox3D`: Generar un `stbox` geodético 3D aleatorio

## Generador para tipos temporales MobilityDB

- `random_tbool_inst`: Generar un booleano temporal aleatorio de subtipo instante

- `random_tint_inst`: Generar un entero temporal aleatorio de subtipo instante

- `random_tfloat_inst`: Generar un flotante temporal aleatorio de subtipo instante

- `random_ttext_inst`: Generar un texto temporal aleatorio de subtipo instante

- `random_tgeompoint_inst`: Generar un punto geométrico temporal 2D aleatorio de subtipo instante

- `random_tgeompoint3D_inst`: Generar un punto geométrico temporal 3D aleatorio de subtipo instante

- `random_tgeogpoint_inst`: Generar un punto geográfico temporal 2D aleatorio de subtipo instante

- `random_tgeogpoint3D_inst`: Generar un punto geográfico temporal 3D aleatorio de subtipo instante

- `random_tbool_discseq`: Generar un booleano temporal aleatorio de subtipo secuencia con interpolación discreta

- `random_tint_discseq`: Generar un entero temporal aleatorio de subtipo secuencia con interpolación discreta

- `random_tfloat_discseq`: Generar un flotante temporal aleatorio de subtipo secuencia con interpolación discreta

- `random_ttext_discseq`: Generar un texto temporal aleatorio de subtipo secuencia con interpolación discreta

- `random_tgeompoint_discseq`: Generar un punto temporal geométrico 2D aleatorio de subtipo secuencia con interpolación discreta

- `random_tgeompoint3D_discseq`: Generar un punto geométrico temporal 3D aleatorio de subtipo secuencia con interpolación discreta

- `random_tgeogpoint_discseq`: Generar un punto geográfico temporal 2D aleatorio de subtipo secuencia con interpolación discreta

- `random_tgeogpoint3D_discseq`: Generar un punto geográfico temporal 3D aleatorio de subtipo secuencia con interpolación discreta

- `random_tbool_seq`: Generar un booleano temporal aleatorio de subtipo secuencia

- `random_tint_seq`: Generar un entero temporal aleatorio de subtipo secuencia

- `random_tfloat_seq`: Generar un flotante temporal aleatorio de subtipo secuencia

- `random_ttext_seq`: Generar un texto temporal aleatorio de subtipo secuencia

- `random_tgeompoint_seq`: Generar un punto geométrico temporal 2D aleatorio de subtipo secuencia

- `random_tgeompoint3D_seq`: Generar un punto geométrico temporal 3D aleatorio de subtipo secuencia

- `random_tgeogpoint_seq`: Generar un punto geográfico temporal 2D aleatorio de subtipo secuencia

- `random_tgeogpoint3D_seq`: Generar un punto geográfico temporal 3D aleatorio de subtipo secuencia

- `random_tbool_seqset`: Generar un booleano temporal aleatorio de subtipo conjunto de secuencias

- `random_tint_seqset`: Generar un entero temporal aleatorio de subtipo conjunto de secuencias

- `random_tfloat_seqset`: Generar un flotante temporal aleatorio de subtipo conjunto de secuencias

- `random_ttext_seqset`: Generar un texto temporal aleatorio de subtipo conjunto de secuencias

- `random_tgeompoint_seqset`: Generar un punto geométrico temporal 2D aleatorio de subtipo conjunto de secuencias

- `random_tgeompoint3D_seqset`: Generar un punto geométrico temporal 3D aleatorio de subtipo conjunto de secuencias

- `random_tgeogpoint_seqset`: Generar un punto geográfico temporal 2D aleatorio de subtipo conjunto de secuencias

- `random_tgeogpoint3D_seqset`: Generar un punto geográfico temporal 3D aleatorio de subtipo conjunto de secuencias

## Generación de tablas con valores aleatorios

Los archivos `create_test_tables_temporal.sql` y `create_test_tables_tpoint.sql` dan ejemplos de utilización de las funciones que generan valores aleatorios listadas arriba. Por ejemplo, el primer archivo define la función siguiente.

    CREATE OR REPLACE FUNCTION create_test_tables_temporal(size integer DEFAULT 100)
    RETURNS text AS $$
    DECLARE
      perc integer;
    BEGIN
    perc := size * 0.01;
    IF perc < 1 THEN perc := 1; END IF;

    -- ... Table generation ...

    RETURN 'The End';
    END;
    $$ LANGUAGE 'plpgsql';

La función tiene un parámetro `size` que define el número de filas en las tablas. Si no se proporciona, crea por defecto tablas de 100 filas. La función define una variable `perc` que calcula el 1% del tamaño de las tablas. Este parámetro se utiliza, por ejemplo, para generar tablas con un 1% de valores nulos. A continuación ilustramos algunos de los comandos que generan tablas.

La creación de una tabla `tbl_float` que contiene valores aleatorios `float` en el rango [0,100] con 1% de valores nulos se da a continuación.

    CREATE TABLE tbl_float AS
    /* Add perc NULL valores */
    SELECT k, NULL AS f
    FROM generate_series(1, perc) AS k UNION
    SELECT k, random_float(0, 100)
    FROM generate_series(perc+1, size) AS k;

La creación de una tabla `tbl_tbox` que contiene valores aleatorios `tbox` donde los límites de los valores están en el rango [0,100] y los límites de las marcas de tiempo están en el rango [2001-01-01, 2001-12-31] se da a continuación.

    CREATE TABLE tbl_tbox AS
    /* Add perc NULL valores */
    SELECT k, NULL AS b
    FROM generate_series(1, perc) AS k UNION
    SELECT k, random_tbox(0, 100, '2001-01-01', '2001-12-31', 10, 10)
    FROM generate_series(perc+1, size) AS k;

La creación de una tabla `tbl_floatspan` que contiene valores aleatorios `floatspan` donde los límites de los valores están en el rango [0,100] y la máxima diferencia entre los límites inferiores y superiores es 10 se da a continuación.

    CREATE TABLE tbl_floatspan AS
    /* Add perc NULL valores */
    SELECT k, NULL AS f
    FROM generate_series(1, perc) AS k UNION
    SELECT k, random_floatspan(0, 100, 10)
    FROM generate_series(perc+1, size) AS k;

La creación de una tabla `tbl_tstzset` que contiene valores aleatorios `tstzset` que tienen entre 5 y 10 marcas de tiempo donde las marcas de tiempo están en el rango [2001-01-01, 2001-12-31] y el máximo intervalo entre marcas de tiempo consecutivas es 10 minutos se da a continuación.

    CREATE TABLE tbl_tstzset AS
    /* Add perc NULL valores */
    SELECT k, NULL AS ts
    FROM generate_series(1, perc) AS k UNION
    SELECT k, random_tstzset('2001-01-01', '2001-12-31', 10, 5, 10)
    FROM generate_series(perc+1, size) AS k;

La creación de una tabla `tbl_tstzspan` que contiene valores aleatorios `tstzspan` donde las marcas de tiempo están en el rango [2001-01-01, 2001-12-31] y la máxima diferencia entre los límites inferiores y superiores es 10 minutos se da a continuación.

    CREATE TABLE tbl_tstzspan AS
    /* Add perc NULL valores */
    SELECT k, NULL AS p
    FROM generate_series(1, perc) AS k UNION
    SELECT k, random_tstzspan('2001-01-01', '2001-12-31', 10)
    FROM generate_series(perc+1, size) AS k;

La creación de una tabla `tbl_geom_point` que contiene valores aleatorios `geometry` 2D point valores, donde las coordenadas x e y están en el rango [0, 100] y en SRID 3812 se da a continuación.

    CREATE TABLE tbl_geom_point AS
    SELECT 1 AS k, geometry 'SRID=3812;point empty' AS g UNION
    SELECT k, random_geom_point(0, 100, 0, 100, 3812)
    FROM generate_series(2, size) k;

Observe que la tabla contiene un valor de punto vacío. Si no se proporciona el SRID, se establece de forma predeterminada en 0.

La creación de una tabla `tbl_geog_point3D` que contiene valores aleatorios `geography` 3D point valores, donde las coordenadas x, y, y z están, respectivament, en los rangos [-10, 32], [35, 72] y [0, 1000] y en SRID 7844 se da a continuación.

    CREATE TABLE tbl_geog_point3D AS
    SELECT 1 AS k, geography 'SRID=7844;pointZ empty' AS g UNION
    SELECT k, random_geog_point3D(-10, 32, 35, 72, 0, 1000, 7844)
    FROM generate_series(2, size) k;

Nótese que los valores de latitud y longitud se eligen para cubrir aproximadamente la Europa continental. Si no se proporciona el SRID, se establece de forma predeterminada en 4326.

La creación de una tabla `tbl_geom_linestring` que contiene valores aleatorios `geometry` 2D linestring valores que tienen entre 5 y 10 vértices, donde las coordenadas x e y están en el rango [0, 100] y en SRID 3812 y la máxima diferencia entre valores de coordenadas consecutivos es 10 unidades en el SRID subyacente se da a continuación.

    CREATE TABLE tbl_geom_linestring AS
    SELECT 1 AS k, geometry 'linestring empty' AS g UNION
    SELECT k, random_geom_linestring(0, 100, 0, 100, 10, 5, 10, 3812)
    FROM generate_series(2, size) k;

La creación de una tabla `tbl_geom_linestring` que contiene valores aleatorios `geometry` 2D linestring valores que tienen entre 5 y 10 vértices, donde las coordenadas x e y están en el rango [0, 100] y la máxima diferencia entre valores de coordenadas consecutivos es 10 unidades en el SRID subyacente se da a continuación.

    CREATE TABLE tbl_geom_linestring AS
    SELECT 1 AS k, geometry 'linestring empty' AS g UNION
    SELECT k, random_geom_linestring(0, 100, 0, 100, 10, 5, 10)
    FROM generate_series(2, size) k;

La creación de una tabla `tbl_geom_polygon3D` que contiene valores aleatorios `geometry` 3D polygon valores sin agujeros, que tienen entre 5 y 10 vértices, donde las coordenadas x, y, y z están en el rango [0, 100] y la máxima diferencia entre valores de coordenadas consecutivos es 10 unidades en el SRID subyacente se da a continuación.

    CREATE TABLE tbl_geom_polygon3D AS
    SELECT 1 AS k, geometry 'polygon Z empty' AS g UNION
    SELECT k, random_geom_polygon3D(0, 100, 0, 100, 0, 100, 10, 5, 10)
    FROM generate_series(2, size) k;

La creación de una tabla `tbl_geom_multipoint` que contiene valores aleatorios `geometry` 2D multipunto valores que tienen entre 5 y 10 points, donde las coordenadas x e y están en el rango [0, 100] y la máxima diferencia entre valores de coordenadas consecutivos es 10 unidades en el SRID subyacente se da a continuación.

    CREATE TABLE tbl_geom_multipoint AS
    SELECT 1 AS k, geometry 'multipunto empty' AS g UNION
    SELECT k, random_geom_multipoint(0, 100, 0, 100, 10, 5, 10)
    FROM generate_series(2, size) k;

La creación de una tabla `tbl_geog_multilinestring` que contiene valores aleatorios `geography` 2D multilinestring valores que tienen entre 5 y 10 linestrings, cada una teniendo entre 5 y 10 vértices, donde las coordenadas x e y estan, respectivamente, en el rangos [-10, 32] y [35, 72] y la máxima diferencia entre valores de coordenadas consecutivos es 10 se da a continuación.

    CREATE TABLE tbl_geog_multilinestring AS
    SELECT 1 AS k, geography 'multilinestring empty' AS g UNION
    SELECT k, random_geog_multilinestring(-10, 32, 35, 72, 10, 5, 10, 5, 10)
    FROM generate_series(2, size) k;

La creación de una tabla `tbl_geometry3D` que contiene valores aleatorios `geometry` 3D de varios tipos se da a continuación. Esta función requiere que las tablas para los diversos tipos de geometría se hayan creado previamente.

    CREATE TABLE tbl_geometry3D (
      k serial PRIMARY KEY,
      g geometry);
    INSERT INTO tbl_geometry3D(g)
    (SELECT g FROM tbl_geom_point3D ORDER BY k LIMIT (size * 0.1)) UNION ALL
    (SELECT g FROM tbl_geom_linestring3D ORDER BY k LIMIT (size * 0.1)) UNION ALL
    (SELECT g FROM tbl_geom_polygon3D ORDER BY k LIMIT (size * 0.2)) UNION ALL
    (SELECT g FROM tbl_geom_multipoint3D ORDER BY k LIMIT (size * 0.2)) UNION ALL
    (SELECT g FROM tbl_geom_multilinestring3D ORDER BY k LIMIT (size * 0.2)) UNION ALL
    (SELECT g FROM tbl_geom_multipolygon3D ORDER BY k LIMIT (size * 0.2));

La creación de una tabla `tbl_tbool_inst` que contiene valores aleatorios `tbool` valores de subtipo instante donde las marcas de tiempo están en el rango [2001-01-01, 2001-12-31] se da a continuación.

    CREATE TABLE tbl_tbool_inst AS
    /* Add perc NULL valores */
    SELECT k, NULL AS inst
    FROM generate_series(1, perc) AS k UNION
    SELECT k, random_tbool_inst('2001-01-01', '2001-12-31')
    FROM generate_series(perc+1, size) k;
    /* Add perc duplicates */
    UPDATE tbl_tbool_inst t1
    SET inst = (SELECT inst FROM tbl_tbool_inst t2 WHERE t2.k = t1.k+perc)
    WHERE k in (SELECT i FROM generate_series(1 + 2*perc, 3*perc) i);
    /* Add perc rows con the same timestamp */
    UPDATE tbl_tbool_inst t1
    SET inst = (SELECT tboolinst(random_bool(), getTimestamp(inst))
      FROM tbl_tbool_inst t2 WHERE t2.k = t1.k+perc)
    WHERE k in (SELECT i FROM generate_series(1 + 4*perc, 5*perc) i);

Como se puede ver arriba, la tabla tiene un porcentaje de valores nulos, de duplicados y de filas con la misma marca de tiempo.

La creación de una tabla `tbl_tint_discseq` que contiene valores aleatorios `tint` valores de subtipo secuencia con interpolación discreta que tienen entre 5 y 10 marcas de tiempo donde the integer valores están en el rango [0, 100], las marcas de tiempo están en el rango [2001-01-01, 2001-12-31], la máxima diferencia entre dos valores consecutivos es 10 y el máximo intervalo entre dos instantes consecutivos es 10 minutos se da a continuación.

    CREATE TABLE tbl_tint_discseq AS
    /* Add perc NULL valores */
    SELECT k, NULL AS ti
    FROM generate_series(1, perc) AS k UNION
    SELECT k, random_tint_discseq(0, 100, '2001-01-01', '2001-12-31', 10, 10, 5, 10) AS ti
    FROM generate_series(perc+1, size) k;
    /* Add perc duplicates */
    UPDATE tbl_tint_discseq t1
    SET ti = (SELECT ti FROM tbl_tint_discseq t2 WHERE t2.k = t1.k+perc)
    WHERE k in (SELECT i FROM generate_series(1 + 2*perc, 3*perc) i);
    /* Add perc rows con the same timestamp */
    UPDATE tbl_tint_discseq t1
    SET ti = (SELECT ti + random_int(1, 2) FROM tbl_tint_discseq t2 WHERE t2.k = t1.k+perc)
    WHERE k in (SELECT i FROM generate_series(1 + 4*perc, 5*perc) i);
    /* Add perc rows that meet */
    UPDATE tbl_tint_discseq t1
    SET ti = (SELECT shift(ti, endTimestamp(ti)-startTimestamp(ti))
      FROM tbl_tint_discseq t2 WHERE t2.k = t1.k+perc)
    WHERE t1.k in (SELECT i FROM generate_series(1 + 6*perc, 7*perc) i);
    /* Add perc rows that overlap */
    UPDATE tbl_tint_discseq t1
    SET ti = (SELECT shift(ti, date_trunc('minute',(endTimestamp(ti)-startTimestamp(ti))/2))
      FROM tbl_tint_discseq t2 WHERE t2.k = t1.k+2)
    WHERE t1.k in (SELECT i FROM generate_series(1 + 8*perc, 9*perc) i);

Como se puede ver arriba, la tabla tiene un porcentaje de valores nulos, de duplicados, de filas con la misma marca de tiempo, de filas que se encuentran y de filas que se superponen.

La creación de una tabla `tbl_tfloat_seq` que contiene valores aleatorios `tfloat` valores de subtipo secuencia que tienen entre 5 y 10 marcas de tiempo donde los valores `float` están en el rango [0, 100], las marcas de tiempo están en el rango [2001-01-01, 2001-12-31], la máxima diferencia entre dos valores consecutivos es 10 y el máximo intervalo entre dos instantes consecutivos es 10 minutos se da a continuación.

    CREATE TABLE tbl_tfloat_seq AS
    /* Add perc NULL valores */
    SELECT k, NULL AS seq
    FROM generate_series(1, perc) AS k UNION
    SELECT k, random_tfloat_contseq(0, 100, '2001-01-01', '2001-12-31', 10, 10, 5, 10) AS seq
    FROM generate_series(perc+1, size) k;
    /* Add perc duplicates */
    UPDATE tbl_tfloat_seq t1
    SET seq = (SELECT seq FROM tbl_tfloat_seq t2 WHERE t2.k = t1.k+perc)
    WHERE k in (SELECT i FROM generate_series(1 + 2*perc, 3*perc) i);
    /* Add perc tuples with the same timestamp */
    UPDATE tbl_tfloat_seq t1
    SET seq = (SELECT seq + random_int(1, 2) FROM tbl_tfloat_seq t2 WHERE t2.k = t1.k+perc)
    WHERE k in (SELECT i FROM generate_series(1 + 4*perc, 5*perc) i);
    /* Add perc tuples that meet */
    UPDATE tbl_tfloat_seq t1
    SET seq = (SELECT shift(seq, timespan(seq)) FROM tbl_tfloat_seq t2 WHERE t2.k = t1.k+perc)
    WHERE t1.k in (SELECT i FROM generate_series(1 + 6*perc, 7*perc) i);
    /* Add perc tuples that overlap */
    UPDATE tbl_tfloat_seq t1
    SET seq = (SELECT shift(seq, date_trunc('minute',timespan(seq)/2))
      FROM tbl_tfloat_seq t2 WHERE t2.k = t1.k+perc)
    WHERE t1.k in (SELECT i FROM generate_series(1 + 8*perc, 9*perc) i);

La creación de una tabla `tbl_ttext_seqset` que contiene valores aleatorios `ttext` de subtipo conjunto de secuencias que tienen entre 5 y 10 sequences, cada una teniendo entre 5 y 10 marcas de tiempo, donde los valores de texto tienen máximo 10 caracteres, las marcas de tiempo están en el rango [2001-01-01, 2001-12-31] y el máximo intervalo entre dos instantes consecutivos es 10 minutos se da a continuación.

    CREATE TABLE tbl_ttext_seqset AS
    /* Add perc NULL valores */
    SELECT k, NULL AS ts
    FROM generate_series(1, perc) AS k UNION
    SELECT k, random_ttext_seqset('2001-01-01', '2001-12-31', 10, 10, 5, 10, 5, 10) AS ts
    FROM generate_series(perc+1, size) AS k;
    /* Add perc duplicates */
    UPDATE tbl_ttext_seqset t1
    SET ts = (SELECT ts FROM tbl_ttext_seqset t2 WHERE t2.k = t1.k+perc)
    WHERE k in (SELECT i FROM generate_series(1 + 2*perc, 3*perc) i);
    /* Add perc tuples con the same timestamp */
    UPDATE tbl_ttext_seqset t1
    SET ts = (SELECT ts || text 'A' FROM tbl_ttext_seqset t2 WHERE t2.k = t1.k+perc)
    WHERE k in (SELECT i FROM generate_series(1 + 4*perc, 5*perc) i);
    /* Add perc tuples that meet */
    UPDATE tbl_ttext_seqset t1
    SET ts = (SELECT shift(ts, timespan(ts)) FROM tbl_ttext_seqset t2 WHERE t2.k = t1.k+perc)
    WHERE t1.k in (SELECT i FROM generate_series(1 + 6*perc, 7*perc) i);
    /* Add perc tuples that overlap */
    UPDATE tbl_ttext_seqset t1
    SET ts = (SELECT shift(ts, date_trunc('minute', timespan(ts)/2))
      FROM tbl_ttext_seqset t2 WHERE t2.k = t1.k+perc)
    WHERE t1.k in (SELECT i FROM generate_series(1 + 8*perc, 9*perc) i);

La creación de una tabla `tbl_tgeompoint_discseq` que contiene valores aleatorios `tgeompoint` 2D valores de subtipo secuencia con interpolación discreta que tienen entre 5 y 10 instantes, donde the x e y coordenadas están en el rango [0, 100] y en SRID 3812, las marcas de tiempo están en el rango [2001-01-01, 2001-12-31], la máxima diferencia entre coordenadas successivas máximo 10 unidades en el SRID subyacente y el máximo intervalo entre dos instantes consecutivos es 10 minutos se da a continuación.

    CREATE TABLE tbl_tgeompoint_discseq AS
    SELECT k, random_tgeompoint_discseq(0, 100, 0, 100, '2001-01-01', '2001-12-31',
      10, 10, 5, 10, 3812) AS ti
    FROM generate_series(1, size) k;
    /* Add perc duplicates */
    UPDATE tbl_tgeompoint_discseq t1
    SET ti = (SELECT ti FROM tbl_tgeompoint_discseq t2 WHERE t2.k = t1.k+perc)
    WHERE k IN (SELECT i FROM generate_series(1, perc) i);
    /* Add perc tuples con the same timestamp */
    UPDATE tbl_tgeompoint_discseq t1
    SET ti = (SELECT round(ti,6) FROM tbl_tgeompoint_discseq t2 WHERE t2.k = t1.k+perc)
    WHERE k IN (SELECT i FROM generate_series(1 + 2*perc, 3*perc) i);
    /* Add perc tuples that meet */
    UPDATE tbl_tgeompoint_discseq t1
    SET ti = (SELECT shift(ti, endTimestamp(ti)-startTimestamp(ti))
      FROM tbl_tgeompoint_discseq t2 WHERE t2.k = t1.k+perc)
    WHERE t1.k IN (SELECT i FROM generate_series(1 + 4*perc, 5*perc) i);
    /* Add perc tuples that overlap */
    UPDATE tbl_tgeompoint_discseq t1
    SET ti = (SELECT shift(ti, date_trunc('minute',(endTimestamp(ti)-startTimestamp(ti))/2))
      FROM tbl_tgeompoint_discseq t2 WHERE t2.k = t1.k+2)
    WHERE t1.k IN (SELECT i FROM generate_series(1 + 6*perc, 7*perc) i);

Finalmente, la creación de una tabla `tbl_tgeompoint3D_seqset` que contiene valores aleatorios `tgeompoint` 3D valores de subtipo conjunto de secuencias que tienen entre 5 y 10 sequences, cada una teniendo entre 5 y 10 marcas de tiempo, donde las coordenadas x, y, y z están en el rango [0, 100] y en SRID 3812, las marcas de tiempo están en el rango [2001-01-01, 2001-12-31], la máxima diferencia entre coordenadas successivas máximo 10 unidades en el SRID subyacente y el máximo intervalo entre dos instantes consecutivos es 10 minutos se da a continuación.

    DROP TABLE IF EXISTS tbl_tgeompoint3D_seqset;
    CREATE TABLE tbl_tgeompoint3D_seqset AS
    SELECT k, random_tgeompoint3D_seqset(0, 100, 0, 100, 0, 100, '2001-01-01', '2001-12-31',
      10, 10, 5, 10, 5, 10, 3812) AS ts
    FROM generate_series(1, size) AS k;
    /* Add perc duplicates */
    UPDATE tbl_tgeompoint3D_seqset t1
    SET ts = (SELECT ts FROM tbl_tgeompoint3D_seqset t2 WHERE t2.k = t1.k+perc)
    WHERE k IN (SELECT i FROM generate_series(1, perc) i);
    /* Add perc tuples con the same timestamp */
    UPDATE tbl_tgeompoint3D_seqset t1
    SET ts = (SELECT round(ts,3) FROM tbl_tgeompoint3D_seqset t2 WHERE t2.k = t1.k+perc)
    WHERE k IN (SELECT i FROM generate_series(1 + 2*perc, 3*perc) i);
    /* Add perc tuples that meet */
    UPDATE tbl_tgeompoint3D_seqset t1
    SET ts = (SELECT shift(ts, timespan(ts)) FROM tbl_tgeompoint3D_seqset t2 WHERE t2.k = t1.k+perc)
    WHERE t1.k IN (SELECT i FROM generate_series(1 + 4*perc, 5*perc) i);
    /* Add perc tuples that overlap */
    UPDATE tbl_tgeompoint3D_seqset t1
    SET ts = (SELECT shift(ts, date_trunc('minute', timespan(ts)/2))
      FROM tbl_tgeompoint3D_seqset t2 WHERE t2.k = t1.k+perc)
    WHERE t1.k IN (SELECT i FROM generate_series(1 + 6*perc, 7*perc) i);

## Generador para tipos de red temporales

- `random_fraction`: Generar una fracción aleatoria en el rango [0,1]

- `random_npoint`: Genera un punto de red aleatorio

- `random_nsegment`: Genera un segmento de red aleatorio

- `random_tnpoint_inst`: Generar un punto de red temporal aleatorio de subtipo instant

- `random_tnpoint_discseq`: Generar un punto de red temporal aleatorio de subtipo secuencia e interpolación discreta

- `random_tnpoint_seq`: Generar un punto de red temporal aleatorio de subtipo secuencia e interpolación linear o escalonada

- `random_tnpoint_seqset`: Generar un punto de red temporal aleatorio de subtipo conjunto de secuencias

El archivo `/datagen/npoint/create_test_tables_tnpoint.sql` da ejemplos de utilización de las funciones que generan valores aleatorios listadas arriba.