MENU
  1. Inicio
  2. SQL
  3. Generación de datos de prueba y creación de casos de prueba en SQL

Generación de datos de prueba y creación de casos de prueba en SQL

SQL

En el desarrollo y prueba de bases de datos, es esencial crear datos de prueba confiables y casos de prueba. Los datos de prueba precisos garantizan la calidad del sistema y ayudan a detectar errores temprano. Además, los casos de prueba adecuados son herramientas cruciales para verificar si el sistema funciona como se espera. En este artículo, explicaremos en detalle cómo generar datos de prueba utilizando SQL y cómo crear casos de prueba, presentando enfoques prácticos.

Índice

Métodos básicos para la generación de datos de prueba

Un método básico para generar datos de prueba utilizando SQL es insertar manualmente los datos con sentencias INSERT. A continuación se muestra un ejemplo básico de generación de datos de prueba.

Inserción de datos de prueba simples

El método más básico para generar datos de prueba es insertar manualmente los datos utilizando la sentencia INSERT. Por ejemplo, el siguiente SQL inserta datos de prueba en una tabla de clientes.

INSERT INTO customers (customer_id, customer_name, contact_email)
VALUES (1, '山田 太郎', 'taro.yamada@example.com'),
       (2, '鈴木 一郎', 'ichiro.suzuki@example.com'),
       (3, '佐藤 花子', 'hanako.sato@example.com');

Inserción de grandes cantidades de datos

Cuando se necesita una gran cantidad de datos de prueba, en lugar de ejecutar múltiples sentencias INSERT, se puede utilizar un script para generarlos automáticamente. A continuación se muestra un ejemplo usando un bucle simple.

DO $$
BEGIN
   FOR i IN 1..1000 LOOP
      INSERT INTO customers (customer_id, customer_name, contact_email)
      VALUES (i, 'テストユーザー' || i, 'test' || i || '@example.com');
   END LOOP;
END $$;

Este script inserta 1000 registros de datos de prueba en la tabla de clientes.

Uso de datos de plantilla

También es posible generar datos de prueba más realistas utilizando datos de plantilla previamente preparados. Por ejemplo, puede tener una lista de nombres y direcciones de correo electrónico y combinarlos aleatoriamente para generar los datos.

WITH names AS (
    SELECT unnest(ARRAY['山田', '鈴木', '佐藤', '高橋', '田中']) AS last_name,
           unnest(ARRAY['太郎', '一郎', '花子', '二郎', '三郎']) AS first_name
)
INSERT INTO customers (customer_id, customer_name, contact_email)
SELECT row_number() OVER (), 
       last_name || ' ' || first_name, 
       lower(first_name || '.' || last_name || '@example.com')
FROM names;

Este método permite generar datos de manera eficiente mediante la combinación aleatoria de nombres.

Introducción de herramientas para la generación de datos de prueba

Existen muchas herramientas que facilitan la generación de datos de prueba. A continuación, presentamos algunas de las herramientas más populares y explicamos sus características y usos.

Mockaroo

Mockaroo es una herramienta web para la generación de datos de prueba que se destaca por su facilidad de uso y por soportar una amplia variedad de formatos de datos.

Características principales

  • Soporta cientos de tipos de campos de datos
  • Permite exportar datos en varios formatos como CSV, JSON, SQL, entre otros
  • Permite construir modelos de datos fácilmente usando una interfaz web

Ejemplo de uso

  1. Accede al sitio web de Mockaroo.
  2. Haz clic en el botón “Add Another Field” y agrega los campos que deseas generar.
  3. Selecciona el tipo de datos para cada campo (por ejemplo, nombre, dirección de correo, fecha, etc.).
  4. Especifica el número de filas que necesitas y haz clic en el botón “Download Data” para exportar los datos.

Faker

Faker es una poderosa herramienta para la generación de datos de prueba que se ofrece como una biblioteca de Python, permitiendo generar datos de prueba fácilmente dentro de un programa.

Características principales

  • Soporte para múltiples idiomas
  • Generación de diversos tipos de datos como nombres, direcciones y textos
  • Generación de datos personalizables

Ejemplo de uso

El siguiente código muestra un ejemplo de cómo generar datos de clientes usando Faker.

from faker import Faker
import psycopg2

fake = Faker('ja_JP')

# Conectar a la base de datos PostgreSQL
conn = psycopg2.connect("dbname=test user=postgres password=secret")
cur = conn.cursor()

# Generar e insertar datos de prueba
for _ in range(100):
    customer_id = _
    customer_name = fake.name()
    contact_email = fake.email()
    cur.execute("INSERT INTO customers (customer_id, customer_name, contact_email) VALUES (%s, %s, %s)",
                (customer_id, customer_name, contact_email))

conn.commit()
cur.close()
conn.close()

Redgate SQL Data Generator

Redgate SQL Data Generator es una herramienta comercial para la generación de datos de prueba en SQL Server, adecuada para generar rápidamente grandes conjuntos de datos.

Características principales

  • Integración con SQL Server Management Studio
  • Interfaz gráfica intuitiva
  • Generación automática de datos basada en el esquema de la base de datos

Ejemplo de uso

  1. Instala y abre Redgate SQL Data Generator.
  2. Conéctate a la base de datos en la que deseas generar datos de prueba.
  3. Selecciona las tablas y campos, y establece las reglas para los datos que se van a generar.
  4. Haz clic en el botón “Generate Data” para generar los datos e insertarlos en la base de datos.

Ventajas y desventajas de crear datos de prueba manualmente

La creación manual de datos de prueba tiene varias ventajas y desventajas. Comprenderlas te ayudará a elegir el método adecuado según las necesidades del proyecto.

Ventajas

Alta precisión y personalización

La creación manual de datos de prueba permite un control detallado sobre el contenido de los datos. Esto es útil para preparar datos personalizados que cubran escenarios específicos o casos límite.

Depuración y solución de problemas sencilla

Los datos creados manualmente son claros y fáciles de entender, lo que facilita la depuración y solución de problemas. En caso de un problema, es más sencillo identificar qué datos lo causaron.

Bajo costo inicial

No es necesario preparar herramientas o scripts especiales, lo que reduce los costos iniciales. Es adecuado para proyectos pequeños o pruebas puntuales.

Desventajas

Requiere tiempo y esfuerzo

Crear grandes cantidades de datos manualmente requiere tiempo y esfuerzo, lo que puede ser ineficiente al preparar conjuntos de datos de prueba de gran tamaño.

Riesgo de errores humanos

Existe el riesgo de cometer errores o inconsistencias al ingresar datos manualmente, lo que puede dar lugar a resultados de prueba inexactos.

Falta de escalabilidad

A medida que aumenta el volumen de datos, es más difícil gestionarlos manualmente. En escenarios que requieren generación escalable de datos de prueba, la automatización es esencial.

Estudio de caso

Por ejemplo, al agregar una nueva función y crear manualmente una pequeña cantidad de datos de prueba para verificar su funcionamiento, es fácil generar datos que reflejen condiciones o escenarios específicos. Sin embargo, para pruebas de rendimiento de sistemas a gran escala, es necesario utilizar métodos automatizados.

Métodos automatizados para la generación de datos de prueba

La generación automatizada de datos de prueba es un método eficaz para crear rápidamente datos de prueba consistentes y eficientes. A continuación, se describen los beneficios de la automatización y cómo generar datos de prueba con scripts SQL.

Ventajas de la automatización

Mejora de la eficiencia

Generar grandes volúmenes de datos rápidamente ahorra mucho tiempo en comparación con la creación manual de datos, lo que acorta el tiempo de preparación para las pruebas y acelera el ciclo de desarrollo.

Garantía de consistencia

Los procesos automatizados aseguran la consistencia de los datos generados. Al eliminar los errores humanos en la entrada de datos, se obtienen datos de prueba confiables.

Escalabilidad

Los métodos automatizados permiten ajustar fácilmente el volumen de datos según sea necesario, facilitando la generación de grandes conjuntos de datos de prueba y la realización de pruebas de rendimiento.

Automatización mediante scripts SQL

A continuación se muestra un ejemplo de cómo generar automáticamente datos de prueba utilizando un script SQL.

Ejemplo básico de script

El siguiente script utiliza una estructura de bucle para insertar automáticamente datos en la tabla de clientes.

DO $$
BEGIN
   FOR i IN 1..1000 LOOP
      INSERT INTO customers (customer_id, customer_name, contact_email)
      VALUES (i, 'テストユーザー' || i, 'test' || i || '@example.com');
   END LOOP;
END $$;

Este script genera automáticamente 1,000 datos de prueba e inserta en la tabla de clientes.

Generación de datos aleatorios

Para generar datos de prueba más realistas, es útil utilizar datos aleatorios. A continuación se muestra un ejemplo de cómo generar nombres y direcciones de correo electrónico aleatorios.

DO $$
DECLARE
   names TEXT[] := ARRAY['山田', '鈴木', '佐藤', '高橋', '田中'];
   first_names TEXT[] := ARRAY['太郎', '一郎', '花子', '二郎', '三郎'];
BEGIN
   FOR i IN 1..1000 LOOP
      INSERT INTO customers (customer_id, customer_name, contact_email)
      VALUES (
         i,
         (SELECT first_names[floor(random() * array_length(first_names, 1) + 1)] || ' ' || 
                 names[floor(random() * array_length(names, 1) + 1)]),
         (SELECT lower(first_names[floor(random() * array_length(first_names, 1) + 1)]) || 
                 '.' || lower(names[floor(random() * array_length(names, 1) + 1)]) || '@example.com')
      );
   END LOOP;
END $$;

Este script genera 1,000 datos de prueba combinando aleatoriamente nombres y direcciones de correo electrónico.

Uso de datos externos

También es posible utilizar fuentes de datos externas para generar datos más variados y realistas. A continuación se muestra un ejemplo de cómo leer datos desde un archivo CSV y utilizarlos para generar datos de prueba.

COPY customers (customer_id, customer_name, contact_email)
FROM '/path/to/your/data.csv'
DELIMITER ','
CSV HEADER;

Este método permite insertar en bloque los datos almacenados en un archivo CSV a la tabla.

Cómo crear casos de prueba

Los casos de prueba son herramientas clave para verificar si un sistema funciona como se espera bajo condiciones específicas. A continuación, explicaremos en detalle los pasos para crear casos de prueba utilizando consultas SQL.

Estructura básica de un caso de prueba

Un caso de prueba consta de los datos de entrada, la operación a ejecutar y el resultado esperado. Es importante incluir los siguientes elementos.

1. Identificador del caso de prueba

Cada caso de prueba debe tener un identificador único. Ejemplo: TC_001

2. Propósito de la prueba

Describe brevemente el propósito del caso de prueba. Ejemplo: Probar la funcionalidad de agregar un nuevo cliente

3. Condiciones previas

Indica las condiciones previas necesarias para realizar la prueba. Ejemplo: La tabla de clientes debe existir y estar inicializada

4. Datos de entrada

Describe los datos específicos que se usarán en la prueba. Ejemplo: Nombre del cliente, dirección de correo, etc.

5. Procedimiento de ejecución

Detalla los pasos para ejecutar la prueba. Ejemplo: Ejecutar la sentencia INSERT

6. Resultado esperado

Define claramente el resultado esperado. Ejemplo: El nuevo cliente se agrega correctamente

Ejemplo de un caso de prueba

A continuación se muestra un ejemplo concreto de un caso de prueba utilizando una consulta SQL.

Caso de prueba: TC_001

1. Propósito de la prueba

Probar la funcionalidad de agregar un nuevo cliente en la tabla de clientes.

2. Condiciones previas

  • La tabla de clientes customers existe
  • La tabla de clientes está vacía

3. Datos de entrada

INSERT INTO customers (customer_id, customer_name, contact_email)
VALUES (1, '田中 太郎', 'taro.tanaka@example.com');

4. Procedimiento de ejecución

  1. Ejecutar la sentencia INSERT mencionada
  2. Ejecutar una sentencia SELECT para verificar si los datos se insertaron correctamente

5. Resultado esperado

SELECT * FROM customers WHERE customer_id = 1;

Resultado esperado:

customer_id | customer_name | contact_email
------------+---------------+--------------------------
1           | 田中 太郎     | taro.tanaka@example.com

Ejemplo de un caso de prueba complejo

Los casos de prueba complejos pueden incluir múltiples pasos. A continuación se muestra un ejemplo de un caso de prueba que incluye operaciones de actualización y eliminación.

Caso de prueba: TC_002

1. Propósito de la prueba

Probar la funcionalidad de actualizar la información de un cliente existente y luego eliminarlo.

2. Condiciones previas

  • Existe al menos un registro en la tabla de clientes customers

3. Datos de entrada

UPDATE customers SET customer_name = '佐藤 花子' WHERE customer_id = 1;
DELETE FROM customers WHERE customer_id = 1;

4. Procedimiento de ejecución

  1. Ejecutar la sentencia UPDATE en la tabla de clientes
  2. Ejecutar una sentencia SELECT para verificar si los datos se actualizaron correctamente
  3. Ejecutar la sentencia DELETE en la tabla de clientes
  4. Ejecutar una sentencia SELECT para verificar si los datos se eliminaron correctamente

5. Resultado esperado

SELECT * FROM customers WHERE customer_id = 1;

Resultado esperado:

customer_id | customer_name | contact_email
------------+---------------+--------------------------
(0 rows)

Gestión y ejecución de casos de prueba

Para gestionar y ejecutar eficientemente los casos de prueba creados, es importante utilizar algunos métodos y herramientas. A continuación, explicamos en detalle cómo gestionar y ejecutar casos de prueba.

Métodos para la gestión de casos de prueba

1. Uso de un sistema de control de versiones

Utiliza un sistema de control de versiones como Git para rastrear los cambios en los casos de prueba y los datos de prueba. Esto permite verificar fácilmente quién hizo qué cambios y facilita el trabajo colaborativo entre varias personas.

2. Herramientas de gestión de casos de prueba

Usar herramientas dedicadas para la gestión de casos de prueba facilita la creación, gestión y ejecución de los casos de prueba. A continuación se presentan algunas herramientas representativas.

Jira

Jira es una herramienta de gestión de proyectos que, utilizando complementos para la gestión de pruebas, permite gestionar los casos de prueba como tickets, controlando su estado y responsables.

TestRail

TestRail es una herramienta especializada en la creación, gestión y ejecución de casos de prueba, que facilita el seguimiento de resultados y la generación de informes.

Procedimiento para la ejecución de casos de prueba

El procedimiento general para ejecutar un caso de prueba es el siguiente.

1. Preparación del entorno de prueba

Prepara el entorno necesario para ejecutar la prueba, lo que incluye la inicialización de la base de datos y la inserción de los datos de prueba necesarios.

-- Inicialización de la tabla de clientes
TRUNCATE TABLE customers;

-- Inserción de datos de prueba
INSERT INTO customers (customer_id, customer_name, contact_email)
VALUES (1, '田中 太郎', 'taro.tanaka@example.com');

2. Ejecución del caso de prueba

Ejecuta la consulta SQL según los pasos del caso de prueba y verifica el resultado.

-- Ejecución del caso de prueba TC_001
INSERT INTO customers (customer_id, customer_name, contact_email)
VALUES (2, '佐藤 花子', 'hanako.sato@example.com');

-- Verificación del resultado
SELECT * FROM customers WHERE customer_id = 2;

3. Registro del resultado

Registra los resultados de la ejecución y compáralos con el resultado esperado. Si hay una discrepancia, investiga la causa.

customer_id | customer_name | contact_email
------------+---------------+--------------------------
2           | 佐藤 花子     | hanako.sato@example.com

4. Creación de un informe

Elabora un informe con los resultados de la ejecución de las pruebas y compártelo con el equipo del proyecto. El informe debe incluir los casos de prueba exitosos, los fallidos y cualquier problema o área de mejora.

Uso de herramientas de automatización

Automatizar la ejecución de los casos de prueba puede mejorar aún más la eficiencia de las pruebas. A continuación se presentan algunas herramientas de automatización.

Selenium

Selenium es una herramienta para automatizar pruebas de aplicaciones web, que puede integrarse con bases de datos para ejecutar pruebas.

JUnit

JUnit es un marco de prueba para aplicaciones Java que puede automatizar casos de prueba que incluyan acceso a bases de datos.

Control de versiones de los datos de prueba y casos de prueba

El control de versiones de los datos y casos de prueba es crucial para la garantía de calidad. Mediante el control de versiones, se pueden rastrear los cambios y garantizar la consistencia entre diferentes versiones. A continuación se explica la importancia del control de versiones y cómo llevarlo a cabo.

Importancia del control de versiones

1. Seguimiento del historial de cambios

Los datos y casos de prueba suelen cambiar a medida que avanza el proyecto. Realizar un control de versiones permite rastrear quién realizó qué cambios, y clarificar las intenciones o razones de esos cambios.

2. Garantía de consistencia

El control de versiones asegura la consistencia de los datos y casos de prueba en diferentes entornos o puntos en el tiempo. Esto permite realizar pruebas reproducibles, mejorando la fiabilidad de los resultados.

3. Respaldo y restauración

Si se realizan cambios erróneos, se puede revertir fácilmente a una versión anterior, lo que proporciona tranquilidad al modificar los datos.

Métodos de control de versiones

1. Control de versiones con Git

Git se puede utilizar no solo para el código fuente, sino también para gestionar versiones de datos y casos de prueba. A continuación se describen los pasos básicos para gestionar datos y casos de prueba con Git.

Inicialización de un repositorio

# Crear un nuevo repositorio
git init test-data-repo
cd test-data-repo

# Primer commit
git add .
git commit -m "Initial commit of test data and test cases"

Realizar commits de los cambios

# Añadir los cambios a la zona de staging
git add test_cases.sql

# Commit de los cambios
git commit -m "Updated test cases for new feature X"

Verificación del historial

# Ver el historial de commits
git log

Restauración a una versión anterior

# Cambiar al commit especificado
git checkout <commit-hash>

2. Uso de snapshots de la base de datos

También es posible realizar un snapshot de la base de datos y gestionar versiones de estos snapshots, lo cual es útil cuando se manejan grandes volúmenes de datos de prueba.

Creación de un snapshot

-- Ejemplo en PostgreSQL
pg_dump -U username -h hostname -d database_name -F c -b -v -f /path/to/backup/file.backup

Restauración de un snapshot

-- Ejemplo en PostgreSQL
pg_restore -U username -h hostname -d database_name -v /path/to/backup/file.backup

Ejemplo práctico: combinación de Git y snapshots de base de datos

En proyectos reales, es común combinar la gestión de versiones de casos de prueba con Git y los snapshots de la base de datos. A continuación se muestra un ejemplo concreto.

1. Guardar los casos de prueba en un repositorio Git

# Añadir casos de prueba
git add test_cases.sql
git commit -m "Added new test cases for feature Y"

2. Crear un snapshot de los datos de prueba y guardarlo en el repositorio

# Crear un snapshot de la base de datos
pg_dump -U username -h hostname -d database_name -F c -b -v -f backup_20240601.backup

# Añadir el archivo snapshot al repositorio
git add backup_20240601.backup
git commit -m "Database snapshot for feature Y testing"

Resumen

Al realizar un control de versiones adecuado, puedes mantener la confiabilidad y consistencia de los datos de prueba y casos de prueba, mejorando la calidad del proyecto. Combina el uso de Git y snapshots de base de datos para crear un entorno de pruebas eficiente.

Ejemplo práctico: escenario de muestra

A continuación se muestra un ejemplo práctico de generación de datos de prueba y creación de casos de prueba basado en un escenario real. Con este ejemplo, comprenderás cómo aplicar estos métodos en proyectos reales.

Resumen del escenario

En el sistema de gestión de clientes de un sitio de comercio electrónico, se probará la funcionalidad de registro de nuevos clientes. La información del cliente incluye el ID del cliente, el nombre, la dirección de correo electrónico y la fecha de registro.

Paso 1: Generación de datos de prueba

Primero, se generarán los datos de cliente de prueba que se utilizarán para probar la funcionalidad de registro de nuevos clientes.

Generación de datos de prueba con un script SQL

El siguiente script genera datos de clientes aleatorios.

DO $$
DECLARE
   names TEXT[] := ARRAY['山田', '鈴木', '佐藤', '高橋', '田中'];
   first_names TEXT[] := ARRAY['太郎', '一郎', '花子', '二郎', '三郎'];
   email_domains TEXT[] := ARRAY['example.com', 'test.com', 'demo.com'];
BEGIN
   FOR i IN 1..100 LOOP
      INSERT INTO customers (customer_id, customer_name, contact_email, registration_date)
      VALUES (
         i,
         (SELECT first_names[floor(random() * array_length(first_names, 1) + 1)] || ' ' || 
                 names[floor(random() * array_length(names, 1) + 1)]),
         (SELECT lower(first_names[floor(random() * array_length(first_names, 1) + 1)]) || 
                 '.' || lower(names[floor(random() * array_length(names, 1) + 1)]) || '@' || email_domains[floor(random() * array_length(email_domains, 1) + 1)]),
         current_date - floor(random() * 365)
      );
   END LOOP;
END $$;

Este script genera 100 registros de clientes con nombres, direcciones de correo electrónico y fechas de registro aleatorias.

Paso 2: Creación de casos de prueba

A continuación, se creará un caso de prueba para probar la funcionalidad de registro de nuevos clientes.

Caso de prueba: TC_003

1. Propósito de la prueba

Probar la funcionalidad de agregar un nuevo cliente en la tabla de clientes.

2. Condiciones previas

  • La tabla de clientes customers existe
  • El ID del cliente no está duplicado

3. Datos de entrada

INSERT INTO customers (customer_id, customer_name, contact_email, registration_date)
VALUES (101, '木村 拓哉', 'takuya.kimura@example.com', '2023-06-01');

4. Procedimiento de ejecución

  1. Ejecutar la sentencia INSERT mencionada
  2. Ejecutar una sentencia SELECT para verificar si los datos se insertaron correctamente

5. Resultado esperado

SELECT * FROM customers WHERE customer_id = 101;

Resultado esperado:

customer_id | customer_name | contact_email                | registration_date
------------+---------------+------------------------------+------------------
101         | 木村 拓哉     | takuya.kimura@example.com    | 2023-06-01

Paso 3: Ejecución de la prueba

Sigue los pasos del caso de prueba y ejecuta la prueba, registrando los resultados.

Ejecución de la consulta SQL

-- Ejecución del caso de prueba TC_003
INSERT INTO customers (customer_id, customer_name, contact_email, registration_date)
VALUES (101, '木村 拓哉', 'takuya.kimura@example.com', '2023-06-01');

-- Verificación del resultado
SELECT * FROM customers WHERE customer_id = 101;

Registro del resultado de la ejecución

Registra los resultados de la prueba y compáralos con el resultado esperado. Si la prueba es exitosa, procede al siguiente caso de prueba. Si falla, identifica y corrige la causa del problema.

Resumen

A través de este ejemplo práctico, comprendiste los pasos específicos para generar datos de prueba y crear casos de prueba utilizando SQL. Al aplicar estos métodos, podrás realizar pruebas más confiables y mejorar la calidad del sistema.

Conclusión

La generación de datos de prueba y la creación de casos de prueba son elementos esenciales en la garantía de calidad de los sistemas de bases de datos. A continuación, resumimos los puntos clave presentados en este artículo.

Importancia y métodos para la generación de datos de prueba

Los datos de prueba ayudan a verificar el funcionamiento del sistema y a detectar errores. La generación manual tiene ventajas en términos de precisión y personalización, pero la automatización es eficaz para grandes volúmenes de datos. Al utilizar scripts SQL o herramientas dedicadas (Mockaroo, Faker, Redgate SQL Data Generator), se pueden generar datos de prueba de manera eficiente y consistente.

Creación y gestión de casos de prueba

Los casos de prueba son indicadores para verificar si el sistema funciona como se espera. Mantén la estructura básica y utiliza sistemas de control de versiones o herramientas dedicadas (Jira, TestRail) para asegurar la consistencia y eficiencia. Ejecuta casos de prueba con consultas SQL y compara los resultados.

Importancia del control de versiones

El control de versiones de los datos y casos de prueba es importante para rastrear los cambios, asegurar la consistencia y respaldar y restaurar versiones anteriores. Utiliza Git para el control de versiones y snapshots de base de datos para una gestión eficiente.

Aplicación del ejemplo práctico

El ejemplo práctico te ayudó a comprender los pasos específicos para la generación de datos de prueba y la creación de casos de prueba. Esto te permitirá seleccionar los métodos adecuados y realizar pruebas confiables en proyectos reales.

La generación de datos de prueba y la creación de casos de prueba son la base de la garantía de calidad en el desarrollo y operación de sistemas. Utiliza estos métodos para realizar pruebas eficientes y efectivas, mejorando la confiabilidad y estabilidad del sistema.

SQL
Automatización Control de versiones SQL Base de Datos Faker Creación de Casos de Prueba Mockaroo Generación de Datos de Prueba Redgate SQL Data Generator Datos de Prueba
Índice