Fixed error of calculation of possible values for generation of string template, updated usage.md, updated CHANGELOG, and improve and columns are sorted at the point of use.

Author: ReverseTM

CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [latest](https://github.com/tarantool/sdvg/compare/0.0.1..master)
 
+### Changed
+
+- String templates replaced with jinja like
+
+### Breaking changes
+
+- The old version of string template in `type_params` of `string` type is no longer supported,
+  instead you should use `{{ pattern('pattern_expression') }}`
+
 ## [0.0.1](https://github.com/tarantool/sdvg/compare/36d0930..0.0.1) - 2025-07-21
 
 ### Added
@@ -38,7 +47,3 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Data partitioning
 - Ability to continue generation
 - Availability to ignore some models for generation
-
-### Changed
-
-- String templates replaced with jinja like

config/models.yml

@@ -62,7 +62,7 @@ models:
       - name: passport
         type: string
         type_params:
-          template: AA 00 000 000
+          template: "{{ pattern('AA 00 000 000') }}"
         distinct_percentage: 1
         ordered: true
       - name: created

doc/ru/usage.md

@@ -161,8 +161,8 @@ open_ai:
 - `max_length`: Максимальная длина строки. По умолчанию 32.
 - `logical_type`: Логический тип строки. Поддерживаемые значения: `first_name`, `last_name`, `phone`, `text`.
 - `template`: Jinja-подобный шаблон для генерации строки. Позволяет использовать любые поля генерируемой модели и
-  задавать паттерн строки с помощью функции `pattern`, где символ `A` - любая большая буква, символ `a` - любая маленькая буква,
-  символ `0` - любая цифра, символ `#` - любой символ, а остальные символы остаются как есть.
+  задавать паттерн строки с помощью функции `pattern`. Информация о фильтрах и функциях, доступных в шаблонных
+  строках описана [здесь](#фильтры-и-функции-используемые-в-шаблонных-строках).
   Также поддерживается использование фильтров, таких как `upper` и `lower`.
 - `locale`: Локаль для генерации строк. Поддерживаемые значения: `ru`, `en`. По умолчанию `en`.
 - `without_large_letters`: Флаг, указывающий, исключать ли большие буквы из строки.
@@ -244,6 +244,18 @@ open_ai:
 Подобна структуре для формата `http`, за исключением того,
 что поле `format_template` неизменяемое и всегда равняется значению по умолчанию.
 
+#### Фильтры и функции, используемые в шаблонных строках
+
+Шаблонные строки реализованы с использованием библиотеки `pongo2`, ознакомиться
+со всеми доступными фильтрами и функциями можно в репозитории [pongo2](https://github.com/flosch/pongo2).
+
+Вдобавок к ним была добавлена 1 функция:
+
+- pattern: позволяет создать паттерн строки при помощи специальных символов.
+  Символ `A` - любая большая буква, символ `a` - любая маленькая буква,
+  символ `0` - любая цифра, символ `#` - любой символ, а остальные символы остаются как есть.
+  Функция доступна только в поле `template` типа данных `string`. 
+
 #### Примеры конфигурации генерации данных
 
 Пример конфигурации модели данных:

internal/generator/models/common.go

@@ -2,7 +2,6 @@ package models
 
 import (
 	"encoding/json"
-	"github.com/tarantool/sdvg/internal/generator/common"
 	"io"
 	"os"
 	"path/filepath"
@@ -12,6 +11,7 @@ import (
 	"github.com/ilyakaznacheev/cleanenv"
 	"github.com/otaviokr/topological-sort/toposort"
 	"github.com/pkg/errors"
+	"github.com/tarantool/sdvg/internal/generator/common"
 	"gopkg.in/yaml.v3"
 )
 
@@ -122,8 +122,8 @@ func parseErrsToString(errs []error) string {
 	return sb.String()
 }
 
-func topologicalSort(columns []*Column) ([]string, error) {
-	graph := make(map[string][]string)
+func TopologicalSort(columns []*Column) ([]string, error) {
+	graph := make(map[string][]string, len(columns))
 	for _, c := range columns {
 		graph[c.Name] = make([]string, 0)
 

internal/generator/models/common_test.go

@@ -106,7 +106,7 @@ func TestTopologicalSort(t *testing.T) {
 	testFunc := func(t *testing.T, tc testCase) {
 		t.Helper()
 
-		actual, err := topologicalSort(tc.columns)
+		actual, err := TopologicalSort(tc.columns)
 		require.Equal(t, tc.wantErr, err != nil)
 		require.Equal(t, tc.expected, actual)
 	}

internal/generator/models/generator_model.go

@@ -30,9 +30,8 @@ type Model struct {
 	RowsPerFile   uint64  `backup:"true"      json:"rows_per_file" yaml:"rows_per_file"`
 	ModelDir      string  `backup:"true"      json:"model_dir"     yaml:"model_dir"`
 	// The columns from the partitioning key with PartitionColumn.WriteToOutput == false, must be at the end of slice.
-	Columns                 []*Column `backup:"true" json:"columns" yaml:"columns"`
-	ColumnsTopologicalOrder []string
-	PartitionColumns        []*PartitionColumn `backup:"true" json:"partition_columns" yaml:"partition_columns"`
+	Columns          []*Column          `backup:"true" json:"columns"           yaml:"columns"`
+	PartitionColumns []*PartitionColumn `backup:"true" json:"partition_columns" yaml:"partition_columns"`
 }
 
 // PartitionColumn type is used to describe partition parameters for column.
@@ -81,13 +80,6 @@ func (m *Model) Parse() error {
 
 	m.shiftColumnsToEnd(nonWriteableColumns)
 
-	sortedColumns, err := topologicalSort(m.Columns)
-	if err != nil {
-		return errors.WithMessage(err, "failed to sorting columns by dependencies")
-	}
-
-	m.ColumnsTopologicalOrder = sortedColumns
-
 	return nil
 }
 

internal/generator/models/models_test.go

@@ -1197,9 +1197,6 @@ parquet params:
 			expectedModel := tc.expected.Models[modelName]
 			gotModel := cfg.Models[modelName]
 
-			// skip ColumnsTopologicalOrder check
-			expectedModel.ColumnsTopologicalOrder = gotModel.ColumnsTopologicalOrder
-
 			for columnName := range expectedModel.Columns {
 				expectedColumn := expectedModel.Columns[columnName]
 				gotColumn := gotModel.Columns[columnName]

internal/generator/usecase/general/generator/generator.go

@@ -11,13 +11,12 @@ import (
 )
 
 type rangeGenerator struct {
-	numFrom             uint64
-	numTo               uint64
-	distinctValuesCount uint64
-	sequencer           sequencer
-	dataRandomFactor    float64
-	generator           value.Generator
-	nullPercentage      float64
+	numFrom          uint64
+	numTo            uint64
+	sequencer        sequencer
+	dataRandomFactor float64
+	generator        value.Generator
+	nullPercentage   float64
 }
 
 type ColumnGenerator struct {
@@ -175,13 +174,12 @@ func newRangeGenerator(
 	dataRandomFactor := 1 - float64(distinctValuesCount)/generatorValuesCount
 
 	return &rangeGenerator{
-		numFrom:             rangeRowsOffset,
-		numTo:               rangeRowsOffset + rangeRowsCount,
-		distinctValuesCount: distinctValuesCount,
-		dataRandomFactor:    dataRandomFactor,
-		generator:           valueGenerator,
-		sequencer:           rangeSequencer,
-		nullPercentage:      dataRange.NullPercentage,
+		numFrom:          rangeRowsOffset,
+		numTo:            rangeRowsOffset + rangeRowsCount,
+		dataRandomFactor: dataRandomFactor,
+		generator:        valueGenerator,
+		sequencer:        rangeSequencer,
+		nullPercentage:   dataRange.NullPercentage,
 	}, nil
 }
 

internal/generator/usecase/general/task.go

@@ -84,9 +84,21 @@ func newGenerators(cfg *models.GenerationConfig) (map[string]*generator.ColumnGe
 	generators := make(map[string]*generator.ColumnGenerator)
 
 	for modelName, model := range cfg.Models {
-		distinctValuesCountByColumn := make(map[string]uint64)
+		distinctValuesCountByColumn := make(map[string]uint64, len(model.Columns))
+
+		sortedColumns, err := models.TopologicalSort(model.Columns)
+		if err != nil {
+			return nil, errors.WithMessagef(err, "failed to sorting columns by dependencies for model %q", modelName)
+		}
+
+		originIndexes := make(map[string]int, len(model.Columns))
+		for index, column := range model.Columns {
+			originIndexes[column.Name] = index
+		}
+
+		for _, columnName := range sortedColumns {
+			column := model.Columns[originIndexes[columnName]]
 
-		for _, column := range model.Columns {
 			dataModelName := modelName
 			dataModel := model
 			dataColumn := column
@@ -173,6 +185,8 @@ func (t *Task) WaitError() error {
 }
 
 // generateAndSaveValues function generates values for all model.
+//
+//nolint:cyclop
 func (t *Task) generateAndSaveValues(ctx context.Context) error {
 	var err error
 
@@ -203,6 +217,16 @@ func (t *Task) generateAndSaveValues(ctx context.Context) error {
 			continue
 		}
 
+		columnsTopologicalOrder, err := models.TopologicalSort(model.Columns)
+		if err != nil {
+			return errors.WithMessagef(err, "failed to sorting columns by dependencies for model %q", modelName)
+		}
+
+		originColumnsIndexes := make(map[string]int, len(model.Columns))
+		for index, column := range model.Columns {
+			originColumnsIndexes[column.Name] = index
+		}
+
 		pool.Add(1)
 
 		go func() {
@@ -223,7 +247,11 @@ func (t *Task) generateAndSaveValues(ctx context.Context) error {
 					generators = append(generators, t.generators[columnKey].NewBatchGenerator(rowsCount))
 				}
 
-				pool.Submit(ctx, outputSyncer.WorkerSyncer(), model, generators, rowsCount)
+				pool.Submit(
+					ctx, outputSyncer.WorkerSyncer(),
+					modelName, columnsTopologicalOrder, originColumnsIndexes,
+					generators, rowsCount,
+				)
 			}
 		}()
 	}
@@ -257,7 +285,8 @@ func (t *Task) skipRows() {
 // generateAndSaveBatch function generate batch of values for selected column and send it to output.
 func (t *Task) generateAndSaveBatch(
 	ctx context.Context, outputSync *common.WorkerSyncer,
-	model *models.Model, generators []*generator.BatchGenerator, count uint64,
+	modelName string, columnsTopologicalOrder []string, originColumnsIndexes map[string]int,
+	generators []*generator.BatchGenerator, count uint64,
 ) error {
 	defer outputSync.Done(ctx)
 
@@ -268,20 +297,15 @@ func (t *Task) generateAndSaveBatch(
 		}
 	}
 
-	originIndexes := make(map[string]int, len(model.Columns))
-	for index, column := range model.Columns {
-		originIndexes[column.Name] = index
-	}
-
 	for i := range count {
-		generatedValues := make(map[string]any)
+		generatedValues := make(map[string]any, len(originColumnsIndexes))
 
-		for _, columnName := range model.ColumnsTopologicalOrder {
+		for _, columnName := range columnsTopologicalOrder {
 			if common.CtxClosed(ctx) {
 				return &common.ContextCancelError{}
 			}
 
-			idx := originIndexes[columnName]
+			idx := originColumnsIndexes[columnName]
 
 			value, err := generators[idx].Value(generatedValues)
 			if err != nil {
@@ -295,12 +319,12 @@ func (t *Task) generateAndSaveBatch(
 
 	outputSync.WaitPrevious(ctx)
 
-	err := t.output.HandleRowsBatch(ctx, model.Name, batch)
+	err := t.output.HandleRowsBatch(ctx, modelName, batch)
 	if err != nil {
 		return errors.WithMessage(err, "failed to save batch to output")
 	}
 
-	t.progress.Add(model.Name, count)
+	t.progress.Add(modelName, count)
 
 	return nil
 }