Generator

Eсть таблица:

CREATE TABLE person(    id         uuid primary key,    name       text,    birth_date date)

и соотвтетствующий ей дата-класс:

data class Person(    val id: UUID,    val name: String,    val birthDate: LocalDate,)

Что если для того чтобы выполнить базовые CRUD операции:

• сохранить список Person-ов

• вычитать всё из таблицы

• удалить все записи в таблице

• найти по ID

• удалить по имени

будет достаточно создать интерфейс:

@SqliteRepositoryinterface PersonRepository : Repository<People> {    fun saveAll(people: List<Person>)    fun selectAll(): List<Person>    fun deleteAll()    fun selectBy(id: UUID): Person?    fun deleteBy(name: String)}

а имплеметнация будет сгенерирована автоматически.

Напоминает Spring Data? Но это не Spring, не Hibernate и даже не JPA.

TL;DR

• Kotlin-центричная библиотека (не фреймворк)

• Не ORM (не содержит JPA)

• Генерирует SQL и JDBC до этапа компиляции (Kotlin Annotation Precessing)

• Нет магии в рантайме

• Сгенерированный код отформатирован, можно дебажить, работает навигация, можноскопировать в проект и модифицировать

• Удобный DSL для работы с базой

• Есть 2 имплементации: под Postgres и Sqlite

Конфигурация

На данный момент есть 2 реализации этой библиотеки: для Postgresql и Sqlite. В данной статье примеры будут для Sqlite.

Для начала нужно сконфигурировать Gradle (да простят меня пользователи Maven):

build.gradle.kts

plugins {    kotlin("kapt") version "1.4.31" //(1)    kotlin("plugin.serialization") version "1.4.31"}dependencies {    implementation("com.github.mfarsikov:kotlite-core:0.5.0") //(2)    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.0.0") //(3)    implementation("org.xerial:sqlite-jdbc:3.34.0") //(4)    kapt("com.github.mfarsikov:kotlite-kapt:0.5.0") //(5)    }kapt {    arguments {        arg("kotlite.db.qualifiedName", "my.pkg.DB") //(6)    }}

Репозиторий

import kotlite.annotations.SqliteRepository@SqliteRepositoryinterface PersonRepository

От такого репозитория пользы немного, но уже для него Kotlite может сгенерировать имплементацию.

Команда ./gradlew kaptKotlin сгенерирует:

@Generatedinternal class PersonRepositoryImpl(    private val connection: Connection) : PersonRepository

Первый запрос

import kotlite.annotations.Queryimport kotlite.annotations.SqliteRepository@SqliteRepositoryinterface PersonRepository {    @Query("SELECT id, name, birth_date FROM person")    fun findPeople(): List<Person>}

Kotlite знает достаточно, чтобы сгенерировать код для этого запроса:

• Из возвращаемого типа List следует, что записей может быть от 0 до N

• Из возвращаемого типа Person следует, что каждый кортеж будет содержать три поля: id, name и birth_date.

• По конвенции, для поля в классе birthDate ожидается значение в кортеже birth_date

В результате сгенерируется метод:

public override fun findPeople(): List<Person> {    val query = "SELECT id, name, birth_date FROM person"    return connection.prepareStatement(query).use {        it.executeQuery().use {            val acc = mutableListOf<Person>()            while (it.next()) {                acc +=                    Person(                        birthDate = it.getObject("birth_date", LocalDate::class.java),                        id = it.getObject("id", java.util.UUID::class.java),                        name = it.getString("name"),                    )            }            acc        }    }}

Как выполнить этот запрос?

В конфигурации (build.gradle.kts) мы указывали, что нужно сгенерировать класс my.pkg.DB. Это главный объект, через который осуществляется доступ ко всем сгенерированным репозиториям. Для его создания нужен DataSource. Все объявленные нами репозитории доступны внутри транзакции:

main.kt

import my.pkg.DBimport org.sqlite.SQLiteDataSourcefun main() {    val datasource = SQLiteDataSource().apply {        url = "jdbc:sqlite:path/to/my/test.db"    }    val db = DB(datasource)    val people: List<Person> = db.transaction {        personRepository.findPeople()    }    println(people)}

Запрос с параметрами

@Query("SELECT id, name, birth_date FROM person WHERE name = :firstName")fun findPeopleBy(firstName: String): List<Person>

Параметры метода могут быть использованы в запросе. Перед именем параметра должно быть двоеточие.

public override fun findPeopleBy(firstName: String): List<Person> {    val query = "SELECT id, name, birth_date FROM person WHERE name = ?"    return connection.prepareStatement(query).use {        it.setString(1, firstName)        it.executeQuery().use {            val acc = mutableListOf<Person>()            while (it.next()) {                acc +=                    Person(                        birthDate = LocalDate.parse(it.getString("birth_date")),                        id = UUID.fromString(it.getString("id")),                        name = it.getString("name"),                    )            }            acc        }    }}

Возвращаемые типы

В зависимости от возвращаемого типа Kotlite генерирует различное поведение.

Список (List)

Cамый обычный тип. Полностью соответствует тому, что возвращает база от 0 до N элементов. Другие коллекции не поддерживаются.

Сущность (Entity)

На первый взгляд ничего особенного, но есть несколько нюансов:

• что если запрос не вернет ни одного значения

• что если запрос вернет больше одного значения

В обоих случаях сгенерированный код выбросит исключение. Для второго случая предусмотрена небольшая оптимизация в виде добавления LIMIT 2.

@Query("SELECT id, name, birth_date FROM person WHERE name = :name")fun findPersonBy(name: String): Person

public override fun findPersonBy(name: String): Person {    val query = """     |SELECT id, name, birth_date FROM person WHERE name = ?     |LIMIT 2     """.trimMargin()    return connection.prepareStatement(query).use {        it.setString(1, name)        it.executeQuery().use {            if (it.next()) {                val result =                    Person(                        birthDate = LocalDate.parse(it.getString("birth_date")),                        id = UUID.fromString(it.getString("id")),                        name = it.getString("name"),                    )                if (it.next()) {                    throw IllegalStateException("Query has returned more than one element")                }                result            } else {                throw NoSuchElementException()            }        }    }}

Для выбора первого значения можно пометить метод аннотацией kotlite.annotations.First

Скаляр

Возвращаемым типом может быть не только сущность, но и любое скалярное ("примитивное") значение. Например: Int, String, UUID LocalDateи т.п.

@Query("SELECT name FROM person WHERE id = :id")fun findPersonNameBy(id: UUID): String

Если запрос не вернул ни одного значения, или если вернул больше одного, то так-же как и для сущности будет выброшено исключение.

public override fun findPersonNameBy(id: UUID): String {    val query = """        |SELECT name FROM person WHERE id = ?        |LIMIT 2        """.trimMargin()    return connection.prepareStatement(query).use {        it.setObject(1, id)        it.executeQuery().use {            if (it.next()) {                val result =                    it.getString(1)                if (it.next()) {                    throw IllegalStateException("Query has returned more than one element")                }                result            } else {                throw NoSuchElementException()            }        }    }}

Для выбора первого значения можно пометить метод аннотацией kotlite.annotations.First

Nullable значения

Скаляр или сущность могут быть объявлены как Nullable. В таком случае вернется nullесли запрос не вернул ни одной записи.

@Query("SELECT name FROM person WHERE id = :id")fun findPersonNameBy(id: UUID): String?

public override fun findPersonNameBy(id: UUID): String? {    val query = """     |SELECT name FROM person WHERE id = ?     |LIMIT 2     """.trimMargin()    return connection.prepareStatement(query).use {        it.setObject(1, id)        it.executeQuery().use {            if (it.next()) {                val result =                    it.getString(1)                if (it.next()) {                    throw IllegalStateException("Query has returned more than one element")                }                result            } else {                null            }        }    }}

Постраничный вывод (Pagination)

Pageableопределяет сколько элементов размещается на странице, и какую страницу нужно выбрать

import kotlite.aux.page.Pageimport kotlite.aux.page.Pageable@SqliteRepositoryinterface PersonRepository : Repository<Person> {    @Query("SELECT name FROM person")    fun selectAll(pageable: Pageable): Page<String>}

public override fun selectAll(pageable: Pageable): Page<String> {    val query = """        |SELECT name FROM person        |LIMIT ? OFFSET ?        """.trimMargin()    return connection.prepareStatement(query).use {        it.setInt(1, pageable.pageSize)        it.setInt(2, pageable.offset)        it.executeQuery().use {            val acc = mutableListOf<String>()            while (it.next()) {                acc +=                    it.getString(1)            }            Page(pageable, acc)        }    }}

Генерация SQL

Все что мы рассмотрели до этого была в основном генерация JDBC кода. SQL запросы нужно было писать разработчику самостоятельно. Но во многих случаях запросы выглядят тривиально, и могут быть сгенерированы автоматически.

Для этого нужно дать библиотеке немного информации о том, с какой сущностью мы работаем. Делается это через переменную типа, интерфейса kotlite.aux.Repository

import kotlite.annotations.SqliteRepositoryimport kotlite.aux.Repository@SqliteRepositoryinterface PersonRepository : Repository<Person> 

Теперь библиотека знает достаточно о нашей сущности, чтобы можно было сгенерировать SQL автоматически.

Известно название таблицы. По конвенции это имя клaсса, сконвертированное из UpperCamelCaseв snake_case. Название таблицы может быть явно указано в аннотацииkotlite.annotations.Table.

Также известно количество, названия и типы колонок таблицы. Названия колонок конвертируются из camelCaseв snake_case Альтернативно, название может быть указано в аннотации kotlite.annotations.Column

Что это нам дает?

Сохранение и обновление

Для любого метода, имя которого начинается на save(либо который помечен аннотацией kotlite.annotations.Save) будет сгенерирован INSERT . Такой метод должен принимать в качестве параметро либо саму сущность, либо список сущностей. Возвращаемый тип должен быть Unit

fun save(person: Person)

public override fun save(person: Person): Unit {    val query = """        |INSERT INTO person        |("birth_date", "id", "name")        |VALUES (?, ?, ?)        """.trimMargin()    return connection.prepareStatement(query).use {        it.setObject(1, person.birthDate)        it.setObject(2, person.id)        it.setString(3, person.name)        it.executeUpdate()    }}

Если сущность имеет первичный ключ (как минимум одно из полей помечено аннотацией kotlite.annotations.ID) будет сгенерирован INSERT/UPDATE

public override fun save(person: Person): Unit {    val query = """    |INSERT INTO person    |("birth_date", "id", "name")    |VALUES (?, ?, ?)    |ON CONFLICT (id) DO     |UPDATE SET "birth_date" = EXCLUDED."birth_date", "id" = EXCLUDED."id", "name" = EXCLUDED."name"    |""".trimMargin()    return connection.prepareStatement(query).use {        it.setObject(1, person.birthDate)        it.setObject(2, person.id)        it.setString(3, person.name)        it.executeUpdate()    }}

Это поведение можно переопределить аннотацией:

import kotlite.annotations.OnConflictFail@OnConflictFailfun save(person: Person)

Оптимистическая блокировка

Если числовое поле класса помечено аннотацией kotlite.annotations.Versionдля такой сущности запросы обновления и удаления будут содержать проверку текущей версии

public override fun save(person: Person): Unit {    val query = """        |INSERT INTO person        |("birth_date", "id", "name", "version")        |VALUES (?, ?, ?, ? + 1)        |ON CONFLICT (id) DO         |UPDATE SET "birth_date" = EXCLUDED."birth_date", "id" = EXCLUDED."id", "name" = EXCLUDED."name", "version" = EXCLUDED."version"        |WHERE person.version = EXCLUDED.version - 1        """.trimMargin()    return connection.prepareStatement(query).use {        it.setObject(1, person.birthDate)        it.setObject(2, person.id)        it.setString(3, person.name)        it.setInt(4, person.version)        val rows = it.executeUpdate()        if (rows != 1) {            throw OptimisticLockFailException()        }    }}public override fun delete(person: Person): Unit {    val query = """        |DELETE         |FROM person        |WHERE "id" = ? AND "version" = ?        """.trimMargin()    return connection.prepareStatement(query).use {        it.setObject(1, person.id)        it.setInt(2, person.version)        val rows = it.executeUpdate()        if (rows != 1) {            throw OptimisticLockFailException()        }    }}

Удаление

Для любого метода, имя которого начинается на delete (или который помечен аннотацией kotlite.annotations.Delete) будет сгенерирован DELETE

fun deleteAll()

public override fun deleteAll(): Unit {    val query = """    |DELETE     |FROM person    """.trimMargin()    return connection.prepareStatement(query).use {        it.executeUpdate()    }}

Такой метод может принимать сущность в качестве параметра:

fun delete(person: Person)

Удаление будет происходить по всем полям сущности

public override fun delete(person: Person): Unit {    val query = """        |DELETE         |FROM person        |WHERE "birth_date" = ? AND "id" = ? AND "name" = ?        """.trimMargin()    return connection.prepareStatement(query).use {        it.setObject(1, person.birthDate)        it.setObject(2, person.id)        it.setString(3, person.name)        it.executeUpdate()    }}

Если сущность имеет первичный ключ (хотя бы одно поле помечено kotlite.annotations.Id) удаление будет по первичному ключу:

public override fun delete(person: Person): Unit {    val query = """    |DELETE     |FROM person    |WHERE "id" = ?    """.trimMargin()    return connection.prepareStatement(query).use {        it.setObject(1, person.id)        it.executeUpdate()    }}

Кроме этого метод удаления может так-же принимать и другие параметры, см. разделы "Метод с параметрами" и "Сложные условия" ниже.

Метод без параметров

Любой метод, объявленный в репозитории, считается запросом типа SELECT(кроме методов, названия которых начинаются со слов saveи delete).

fun selectAll(): List<Person>

public override fun selectAll(): List<Person> {    val query = """     |SELECT "birth_date", "id", "name"     |FROM person     """.trimMargin()    return connection.prepareStatement(query).use {        it.executeQuery().use {            val acc = mutableListOf<Person>()            while (it.next()) {                acc +=                    Person(                        birthDate = LocalDate.parse(it.getString("birth_date")),                        id = UUID.fromString(it.getString("id")),                        name = it.getString("name"),                    )            }            acc        }    }}

Функции fun selectAll(): List<Person>и fun blaBlaBla(): List<Person> ничем не отличаются друг от друга и для них будет сгенерирован абсолютно одинаковый код.

Метод с параметрами

Все параметры метода должны совпадать по названию с полями класса. Они будут использованы как условия равенства во WHEREи объединены через AND.

fun selectBy(name: String, birthDate: LocalDate): Person?

public override fun selectBy(name: String, birthDate: LocalDate): Person? {    val query = """     |SELECT "birth_date", "id", "name"     |FROM person     |WHERE "name" = ? AND "birth_date" = ?     |LIMIT 2     """.trimMargin()    return connection.prepareStatement(query).use {        it.setString(1, name)        it.setObject(2, birthDate)        it.executeQuery().use {            if (it.next()) {                val result =                    Person(                        birthDate = java.time.LocalDate.parse(it.getString("birth_date")),                        id = UUID.fromString(it.getString("id")),                        name = it.getString("name"),                    )                if (it.next()) {                    throw IllegalStateException("Query has returned more than one element")                }                result            } else {                null            }        }    }}

Сложные условия

Если вместо стандартного равенства нужно использовать >, <=, != и т.д., или условия должны быть объединены с помощьюOR с расстановкой скобок, для этого подойдет аннотация kotlite.annotations.Where:

@Where("name = :name OR birth_date < :birthDate")fun selectBy(name: String, birthDate: LocalDate): Person?

Её содержимое будет подставлено в запрос почти без изменений.

public override fun selectBy(name: String, birthDate: LocalDate): Person? {    val query = """        |SELECT "birth_date", "id", "name"        |FROM person        |WHERE name = ? OR birth_date < ?        |LIMIT 2        """.trimMargin()    return connection.prepareStatement(query).use {        it.setString(1, name)        it.setObject(2, birthDate)        it.executeQuery().use {            if (it.next()) {                val result =                    Person(                        birthDate = java.time.LocalDate.parse(it.getString("birth_date")),                        id = UUID.fromString(it.getString("id")),                        name = it.getString("name"),                    )                if (it.next()) {                    throw IllegalStateException("Query has returned more than one element")                }                result            } else {                null            }        }    }}

Сортировка

Часто вместе с постраничным выводом необходимо задать порядок:

@OrderBy("name DESC, birth_date")fun selectAll(): List<Person>

public override fun selectAll(): List<Person> {    val query = """    |SELECT "birth_date", "id", "name"    |FROM person    |ORDER BY name DESC, birth_date    """.trimMargin()    return connection.prepareStatement(query).use {        it.executeQuery().use {            val acc = mutableListOf<Person>()            while (it.next()) {                acc +=                    Person(                        birthDate = LocalDate.parse(it.getString("birth_date")),                        id = UUID.fromString(it.getString("id")),                        name = it.getString("name"),                    )            }            acc        }    }}

Вложенные объекты

Вложенные объекты не могут быть представлены как связь один-к-одному. Поля вложенных объектов должны быть представлены колонками в этой же таблице. Т.е. быть @Embeddableв терминах JPA.

data class Person(    val name: Name,)data class Name(    val firstName: String,    val lastName: String,)

CREATE TABLE person(    first_name text,    last_name text)

Альтернативно вложенные объекты могут быть сериализованы в JSON. Предмет для добавления в ближайшие версии.

Вложенные коллекции

Вложенные коллекции не могут быть представлены как связь один-ко-многим.Вместо этого они автоматически сериализуются в JSON.

data class Person(    val habits: List<String>)@SqliteRepositoryinterface PersonRepository: Repository<Person> {    fun save(person: Person)    fun select(): List<Person>}

public override fun select(): List<Person> {    val query = """    |SELECT "habits"    |FROM person    """.trimMargin()    return connection.prepareStatement(query).use {        it.executeQuery().use {            val acc = mutableListOf<Person>()            while (it.next()) {                acc +=                    Person(                        habits = Json.decodeFromString(it.getString("habits")),                    )            }            acc        }    }}public override fun save(person: Person): Unit {    val query = """    |INSERT INTO person    |("habits")    |VALUES (?)    """.trimMargin()    return connection.prepareStatement(query).use {        it.setString(1, Json.encodeToString(person.habits))        it.executeUpdate()    }}

Особенности (сравнительно с JPA/Hibernate)

• Из-за использования SQL, рефакторинг (например, переименование поля сущности) может потребовать изменения тех запросов, которые были написаны вручную.

• Поскольку во главу угла поставлена простота, нет возможности создавать связи `один-к-одному`, `один-ко-многим` (и нет N+1 проблемы).

• Нет ленивых загрузок (и нет `SessionClosedException`).

• Нет встроенного механизма конвертеров типов (не переусложнен API, библиотека решает только одну задачу).

• Нет возможности сохранения иерархий наследования (в основном из-за личной неприязни автора к наследованию. Возможно будет добавлено в будущем).

• Не питает иллюзий относительно легкой миграции на другую базу данных.

На этом наши полномочия всё

Спасибо за уделенное внимание.

Sqlite

Posgresql

На днях я наконец-то получила свой долгожданный сертификат по работе с сервисом для генерации тестовых данных GenRocket. И теперь как сертифицированный специалист готова рассказать об этом сервисе.

НО изначально необходимо очертить проблему, которую можно решить при помощи этого сервиса.

Проблема генерации тестовых данных

Генерация тестовых данных в достаточном количестве для покрытия минимально возможных необходимых вариантов сценариев становится проблемой для многих проектов.

Почему "минимально возможных"? Потому что тут вспоминаются "Классы эквивалентности", которые сокращают количество тестовых данных от бесконечности до полезного набора.

Почему "необходимых"? А тут вспоминаются "Тестовое покрытие", которое говорит, что тестовые данные должны вести к покрытию максимально возможных сценариев.

Но, даже учитывая "Классы эквивалентности", генерация тестовых данных сейчас стала отдельной задачей для таких сфер, где работа идет непосредственно с данными, их обработкой и/или трансформацией. Вариаций таких данных огромное количество, а еще необходимо тестировать не только конечный результат, но и промежуточные значения.

Функциональность идеального сервиса генерации данных

Идеальный сервис по генерации тестовых данных должен иметь возможность:

• генерировать данные в разных форматах (JSON, XML, CSV и т.д.)

• генерировать данные с зависимостями (parent, child)

• генерировать сложные зависиммые данные (if a then 1 or 2 else 3 or 5)

• генерировать большие обьемы данный за небольшой промежуток времени

Хотелось бы иметь возможность:

• загрузки данные в прямо в БД

• интерграции в CI/CD

• создавать модель данных автоматом из схем

GenRocket университет

Сервис GenRocket предоставяет тренинг-университет, пройдя который вы ознакомитесь с основным базовым функционалом, установкой и настройкой.

Изучить его я крайне рекомендую, первая половина - это чистая теория и немножно нудная, но вы узнаете все основные понятия, которыми оперирует сервис. Вторая же половина - это уже практические занятия с детализированным описание куда нажимать. Этот тернинг подойдет для любого уровня подготовки тестировщика, бизнес-аналитика или разработчика.

GenRocket сервис

GenRocket - это сервис для генерации данных, созданный в 2011 году Hycel Taylor и Garth Rose для решения проблемы создания реалистичных тестовых данных для любой модели данных. Сервис обладает функциональностью генерировать данные для автоматического тестирования, для тестирования нагрузки, тестирования безопасности и др.

Сервис состоит из двух частей: web часть и программная cli часть. В web части происходит создание сценария-инструкции для генерации данных, в программной cli части на самой машине происходит генерация данных.

Что бы начать работу с GenRocket пользователь должен быть авторизирован, затем что бы начать работу с GenRocket необходимо скачать архив для Runtime* для cli части, распаковать его и прописать в системных переменных путь к папке с GenRocket в переменную GEN_ROCKET_HOME и в переменно PATH прописать %GEN_ROCKET_HOME%\bin значение.

Затем открываем командную строку, набираем genrocket и видим картинку ниже.

GenRocket cli часть работает в двух режимах on-line и off-line, но для работы с off-line надо скачать сертификат, который будет валиден только 24 часа.

GenRocket домен и его атрибуты

Первые два из основных компонентов - это Домен и Атрибуты домена. Домен - это существительное, например, пользователь: адрес, кредитная карта и т.д. Каждый домен описывается атрибутами, например: имя, фамилия, e-mail, пароль и день рождения. На картинке ниже вы видите домент User (1), описанный атрибутами (2) и пример сгенерированных данных (3).

Атрибуты к домену могут добавляться вручную по одному (2), с помощью блокнота или импортируя DDL, CSV, JSON или другие форматы. Если мы говорим о табличных данных, то можно сказать, что домен - это таблица, а атрибуты - это клонки этой таблицы.

GenRocket генераторы

Следующий компонент - генератор (generator) - это функциональность, которая непосредственно отвечает за генерацию данных в различных форматах. Генераторов в GenRocket 150+ для различных типов данных. Например:

Каждому атрибуту домена GenRocket назначает свой генератор, опираясь на имя атрибута, автоматом. Например, для атрибута, который содержит слово Name, будет подобран генератор NameGen, а для атрибута с SSN будет подобран генератор SSNGen.

С свойствах генератора можно установить специфичные для проекта параметры: диапазон значений, формат, способ сортировки данных.

GenRocket получатель (receiver)

Следующий компонент - получатель (receiver) - это функциональность, которая отвечает за выгрузку данных в необходимом формате: XML, JSON, SQL, CSV, JDBC, REST, SOAP. В GenRocket 35+ подобных получателелей.

Так же получателем может быть база данных, для которой необходимо настроить JDBC соединение. Настройки для этого соединения настраивается в специальных properties файлах.

GenRocket сценарий (scenarios)

Следующий компонент - сценарий (scenarios) - это набор инструкций, которые определяют сколько и в каком порядке будут созданы данные. Сценарии бывают одиночные (2) и сценарии-цепочки (1), которые позволяют генерировать данные для несколько связанных доменов одновременно. За количество данных отвечает переменная loopCount в настройках домена. Причем у каждого домена значение этой переменной устаналивается отдельно, что позволяет генерировать разное количество данных для каждого домена в сценариях-цепочках.

Сценарий выгружается в виде grs файла (3) и должен быть исполнен на машине, где был установлен GenRocket. Открываем командную строку и выполняем сценарий при помощи команды genrocket -r UserInsertScenario.grs.

При выполнении сценария видим результат, в котором отображатеся время генерации данных. На изображении ниже 10 тыс записей были вставлены в таблицу за 26 сек:

Применение GenRocket на реальном проекте

Возьмем небольшую схему данных, в которой есть таблицы user, grantHistory и notificationSetting.

Используя импорт DDL создадим домен для user.

create table `user` ( id int(10) not null auto_increment,  external_id varchar(50) not null unique,  first_name varchar(25) not null,  last_name varchar(25) not null,  middle_initial char(1),  username varchar(100) not null,  ssn varchar(15) not null,  password varchar(255) not null,  activation_date date,  primary key (id));

После создания доменов GenRocket подбирает подходящие генераторы для каждого атрибута. При необходимости настраиваем специфичные генераторы или модифицируем существующие. Например, изменяем generationType на random и сохраняем изменения.

Аналогичные действия проделываем для grant_history и notification_setting. Сгенерированные данные будут сохраняться в базу данных, для которой настроено JBDC соединение.

driver=org.h2.Driveruser=sapassword=saurl=jdbc:h2:file:~/lms_course/lms_alpha;AUTO_SERVER=TRUE;batchCount=1000

И так же для этой базы настраивается специфичные получатели H2InsertV2Receiver для вставки и SQLUpdateV2Receiver для модификации.

После всех манипуляций с настройками получаем файлы сценарии InsertScenarioChain.grs для вставки и UpdateScenarioChain.grs для модификации, после выполнения которых получаем картинку ниже.

И вуаля, данные в таблицах:

Заключение

Проведя иследование существующих на рынке предложений по сервисам генерации данных, могу сказать, что можно встретить два варианта сервисов:

• бесплатный сервис, ограниченный в количестве генерируемых данных для несложных моделей данных

• платный сервис с неограниченным количеством генерируемых данных и подходящие для сложных моделей данных, который может предоставляет ограниченный бесплатный функционал

Если у вас небольшой короткий проект с несложными данными, то данные для него можно получить при помощи бесплатных сервисов или при помощи самописного генератора. Но если проект долгосрочный с постоянно расширяющейся моделью данных, но идея покупки платного сервиса становится все привлекательней и привлекательней, но конечно решать вам.

Ниже расценка на доступ для GenRocket

Для сравнения я приготовила несколько ссылок бесплатных сервисов:

https://www.datprof.com/solutions/test-data-generation/ - только 14 дней бесплатного использования, похоже что цена договорная

http://generatedata.com/ - бесплатно, но возможна генерация только 100 записей

https://www.mockaroo.com/ - бесплатна возможна генерация только 1000 записей, остальное платно - для самого дорогого доступа $5000/year