Merge branch 'main' into feat/random-mac-address

docs/built_in_transformers/standard_transformers/index.md

@@ -31,9 +31,8 @@ Standard transformers are ready-to-use methods that require no customization and
 1. [RandomMacAddress](random_mac_address.md) — generates a random MAC address.
 1. [RandomDomainName](random_domain_name.md) — generates a random domain name.
 1. [RandomURL](random_url.md) — generates a random URL.
-1. [RandomIPv4](random_ipv4.md) — generates a random IPv4 address.
-1. [RandomIPv6](random_ipv6.md) — generates a random IPv6 address.
 1. [RandomMac](random_mac.md) — generates a random MAC addresses.
+1. [RandomIP](random_ip.md) — generates a random IPv4 or IPv6 addresses.
 1. [RandomWord](random_word.md) — generates a random word.
 1. [RandomSentence](random_sentence.md) — generates a random sentence.
 1. [RandomParagraph](random_paragraph.md) — generates a random paragraph.

docs/built_in_transformers/standard_transformers/random_ip.md

@@ -0,0 +1,75 @@
+The `RandomIp` transformer is designed to populate specified database columns with random IP v4 or V6 addresses. 
+This utility is essential for applications requiring the simulation of network data, testing systems that utilize IP 
+addresses, or anonymizing real IP addresses in datasets.
+
+## Parameters
+
+| Name      | Description                                        | Default  | Required | Supported DB types  |
+|-----------|----------------------------------------------------|----------|----------|---------------------|
+| column    | The name of the column to be affected              |          | Yes      | text, varchar, inet |
+| subnet | Subnet for generating random ip in V4 or V6 format | `false`  | No       | -                   |
+| engine | The engine used for generating the values [random, hash]. Use hash for deterministic generation | `random`         |No          |-                    |
+
+## Dynamic parameters
+
+| Name       | Supported types     |
+|------------|---------------------|
+| subnet     | cidr, text, varchar |
+
+## Description
+
+Utilizing a robust algorithm or library for generating IP addresses, the `RandomIp` transformer injects random IPv4 
+or IPv6 addresses into the designated database column, depending on the provided subnet. The transformer automatically 
+detects whether to generate an IPv4 or IPv6 address based on the subnet version specified.
+
+
+## Example: Generate a Random IPv4 Address for a 192.168.1.0/24 Subnet
+
+This example demonstrates how to configure the RandomIp transformer to inject a random IPv4 address into the 
+ip_address column for entries in the `192.168.1.0/24` subnet:
+
+```sql title="Create table ip_networks and insert data"
+CREATE TABLE ip_networks
+(
+    id         SERIAL PRIMARY KEY,
+    ip_address INET,
+    network    CIDR
+);
+
+INSERT INTO ip_networks (ip_address, network)
+VALUES ('192.168.1.10', '192.168.1.0/24'),
+       ('10.0.0.5', '10.0.0.0/16'),
+       ('172.16.254.3', '172.16.0.0/12'),
+       ('192.168.100.14', '192.168.100.0/24'),
+       ('2001:0db8:85a3:0000:0000:8a2e:0370:7334', '2001:0db8:85a3::/64'); -- An IPv6 address and network
+
+```
+
+```yaml title="RandomPerson transformer example"
+- schema: public
+  name: ip_networks
+  transformers:
+    - name: "RandomIp"
+      params: 
+        subnet: "192.168.1.0/24"
+        column: "ip_address"
+        engine: "random"
+```
+
+## Example: Generate a Random IP Based on the Dynamic Subnet Parameter
+
+This configuration illustrates how to use the RandomIp transformer dynamically, where it reads the subnet information 
+from the network column of the database and generates a corresponding random IP address:
+
+```yaml title="RandomPerson transformer example with dynamic mode"
+- schema: public
+  name: ip_networks
+  transformers:
+    - name: "RandomIp"
+      params:
+        column: "ip_address"
+        engine: "random"
+      dynamic_params:
+        subnet:
+          column: "network"
+```

docs/commands.md

@@ -522,8 +522,8 @@ their possible attributes. Below are the key parameters for each transformer:
         "default_value": "MC4x"
       },
       {
-        "name": "precision",
-        "description": "precision of noised float value (number of digits after coma)",
+        "name": "decimal",
+        "description": "decimal of noised float value (number of digits after coma)",
         "required": false,
         "is_column": false,
         "is_column_container": false,

internal/db/postgres/transformers/noise_date.go

@@ -47,13 +47,14 @@ var NoiseDateTransformerDefinition = utils.NewTransformerDefinition(
 
 	toolkit.MustNewParameterDefinition(
 		"min_ratio",
-		"min random duration for noise",
+		"min random duration for noise. Dy default 5% of the max_ratio",
 	).SetCastDbType("interval"),
 
 	toolkit.MustNewParameterDefinition(
 		"max_ratio",
-		"max random duration for noise. Dy default 5% of the max_ratio",
-	).SetCastDbType("interval"),
+		"max random duration for noise",
+	).SetRequired(true).
+		SetCastDbType("interval"),
 
 	toolkit.MustNewParameterDefinition(
 		"min",
@@ -170,7 +171,7 @@ func NewNoiseDateTransformerBase(ctx context.Context, driver *toolkit.Driver, pa
 	}
 
 	warn := validateIntervalValue(maxRatio)
-	if warns != nil {
+	if warn != nil {
 		warn.AddMeta("ParameterName", "max_ratio")
 		warns = append(warns, warn)
 	}
@@ -187,7 +188,7 @@ func NewNoiseDateTransformerBase(ctx context.Context, driver *toolkit.Driver, pa
 			return nil, nil, fmt.Errorf("unable to scan \"max_ratio\" param: %w", err)
 		}
 		warn = validateIntervalValue(minRatio)
-		if warns != nil {
+		if warn != nil {
 			warn.AddMeta("ParameterName", "min_ratio")
 			warns = append(warns, warn)
 		}

internal/db/postgres/transformers/noise_float.go

@@ -41,8 +41,8 @@ var NoiseFloatTransformerDefinition = utils.NewTransformerDefinition(
 	).SetRequired(true),
 
 	toolkit.MustNewParameterDefinition(
-		"precision",
-		"precision of noised float value (number of digits after coma)",
+		"decimal",
+		"Numbers of decimal",
 	).SetDefaultValue(toolkit.ParamsValue("4")),
 
 	toolkit.MustNewParameterDefinition(
@@ -74,18 +74,18 @@ type NoiseFloatTransformer struct {
 	t               *transformers.NoiseFloat64Transformer
 	columnName      string
 	columnIdx       int
-	precision       int
+	decimal         int
 	affectedColumns map[int]string
 	dynamicMode     bool
 	floatSize       int
 
-	columnParam    toolkit.Parameterizer
-	maxParam       toolkit.Parameterizer
-	minParam       toolkit.Parameterizer
-	engineParam    toolkit.Parameterizer
-	precisionParam toolkit.Parameterizer
-	maxRatioParam  toolkit.Parameterizer
-	minRatioParam  toolkit.Parameterizer
+	columnParam   toolkit.Parameterizer
+	maxParam      toolkit.Parameterizer
+	minParam      toolkit.Parameterizer
+	engineParam   toolkit.Parameterizer
+	decimalParam  toolkit.Parameterizer
+	maxRatioParam toolkit.Parameterizer
+	minRatioParam toolkit.Parameterizer
 
 	transform func(context.Context, float64) (float64, error)
 }
@@ -95,16 +95,15 @@ func NewNoiseFloatTransformer(ctx context.Context, driver *toolkit.Driver, param
 	var columnName, engine string
 	var dynamicMode bool
 	var minValueThreshold, maxValueThreshold, minRatio, maxRatio float64
-	var precision int
-	floatSize := 8
+	var decimal int
 
 	columnParam := parameters["column"]
 	minParam := parameters["min"]
 	maxParam := parameters["max"]
 	maxRatioParam := parameters["max_ratio"]
 	minRatioParam := parameters["min_ratio"]
 	engineParam := parameters["engine"]
-	precisionParam := parameters["precision"]
+	decimalParam := parameters["decimal"]
 
 	if err := engineParam.Scan(&engine); err != nil {
 		return nil, nil, fmt.Errorf(`unable to scan "engine" param: %w`, err)
@@ -124,9 +123,7 @@ func NewNoiseFloatTransformer(ctx context.Context, driver *toolkit.Driver, param
 	}
 	affectedColumns := make(map[int]string)
 	affectedColumns[idx] = columnName
-	if c.Length != -1 {
-		floatSize = c.Length
-	}
+	floatSize := c.GetColumnSize()
 
 	if !dynamicMode {
 		if err := minParam.Scan(&minValueThreshold); err != nil {
@@ -137,8 +134,8 @@ func NewNoiseFloatTransformer(ctx context.Context, driver *toolkit.Driver, param
 		}
 	}
 
-	if err := precisionParam.Scan(&precision); err != nil {
-		return nil, nil, fmt.Errorf(`unable to scan "precision" param: %w`, err)
+	if err := decimalParam.Scan(&decimal); err != nil {
+		return nil, nil, fmt.Errorf(`unable to scan "decimal" param: %w`, err)
 	}
 
 	if err := minRatioParam.Scan(&minRatio); err != nil {
@@ -149,7 +146,7 @@ func NewNoiseFloatTransformer(ctx context.Context, driver *toolkit.Driver, param
 		return nil, nil, fmt.Errorf("unable to scan \"max_ratio\" param: %w", err)
 	}
 
-	limiter, limitsWarnings, err := validateNoiseFloatTypeAndSetLimit(floatSize, minValueThreshold, maxValueThreshold, precision)
+	limiter, limitsWarnings, err := validateNoiseFloatTypeAndSetLimit(floatSize, minValueThreshold, maxValueThreshold, decimal)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -172,13 +169,13 @@ func NewNoiseFloatTransformer(ctx context.Context, driver *toolkit.Driver, param
 		columnName:      columnName,
 		affectedColumns: affectedColumns,
 		columnIdx:       idx,
-		precision:       precision,
+		decimal:         decimal,
 
-		columnParam:    columnParam,
-		minParam:       minParam,
-		maxParam:       maxParam,
-		engineParam:    engineParam,
-		precisionParam: precisionParam,
+		columnParam:  columnParam,
+		minParam:     minParam,
+		maxParam:     maxParam,
+		engineParam:  engineParam,
+		decimalParam: decimalParam,
 
 		dynamicMode: dynamicMode,
 		floatSize:   floatSize,
@@ -210,7 +207,7 @@ func (nft *NoiseFloatTransformer) dynamicTransform(ctx context.Context, v float6
 		return 0, fmt.Errorf("unable to get min and max values: %w", err)
 	}
 
-	limiter, err := transformers.NewNoiseFloat64Limiter(minVal, maxVal, nft.precision)
+	limiter, err := transformers.NewNoiseFloat64Limiter(minVal, maxVal, nft.decimal)
 	if err != nil {
 		return 0, fmt.Errorf("error creating limiter in dynamic mode: %w", err)
 	}
@@ -244,7 +241,7 @@ func (nft *NoiseFloatTransformer) Transform(ctx context.Context, r *toolkit.Reco
 }
 
 func validateNoiseFloatTypeAndSetLimit(
-	size int, requestedMinValue, requestedMaxValue float64, precision int,
+	size int, requestedMinValue, requestedMaxValue float64, decimal int,
 ) (limiter *transformers.NoiseFloat64Limiter, warns toolkit.ValidationWarnings, err error) {
 
 	minValue, maxValue, err := getFloatThresholds(size)
@@ -278,13 +275,13 @@ func validateNoiseFloatTypeAndSetLimit(
 		return nil, warns, nil
 	}
 
-	limiter, err = transformers.NewNoiseFloat64Limiter(-math.MaxFloat64, math.MaxFloat64, precision)
+	limiter, err = transformers.NewNoiseFloat64Limiter(-math.MaxFloat64, math.MaxFloat64, decimal)
 	if err != nil {
 		return nil, nil, err
 	}
 
 	if requestedMinValue != 0 || requestedMaxValue != 0 {
-		limiter, err = transformers.NewNoiseFloat64Limiter(requestedMinValue, requestedMaxValue, precision)
+		limiter, err = transformers.NewNoiseFloat64Limiter(requestedMinValue, requestedMaxValue, decimal)
 		if err != nil {
 			return nil, nil, err
 		}

internal/db/postgres/transformers/noise_float_test.go

@@ -66,29 +66,29 @@ func TestNoiseFloatTransformer_Transform(t *testing.T) {
 			params: map[string]toolkit.ParamsValue{
 				"min_ratio": toolkit.ParamsValue("0.2"),
 				"max_ratio": toolkit.ParamsValue("0.9"),
-				"precision": toolkit.ParamsValue("10"),
+				"decimal":   toolkit.ParamsValue("10"),
 			},
 			input:  "100",
 			result: result{min: 10, max: 190, regexp: `^-*\d+[.]*\d{0,10}$`},
 		},
 		{
-			name:       "float8 ranges 1 with precision",
+			name:       "float8 ranges 1 with decimal",
 			columnName: "col_float8",
 			params: map[string]toolkit.ParamsValue{
 				"min_ratio": toolkit.ParamsValue("0.2"),
 				"max_ratio": toolkit.ParamsValue("0.9"),
-				"precision": toolkit.ParamsValue("0"),
+				"decimal":   toolkit.ParamsValue("0"),
 			},
 			input:  "100",
 			result: result{min: 10, max: 190, regexp: `^-*\d+$`},
 		},
 		{
-			name:       "float8 ranges 1 with precision and hash engine",
+			name:       "float8 ranges 1 with decimal and hash engine",
 			columnName: "col_float8",
 			params: map[string]toolkit.ParamsValue{
 				"min_ratio": toolkit.ParamsValue("0.2"),
 				"max_ratio": toolkit.ParamsValue("0.9"),
-				"precision": toolkit.ParamsValue("0"),
+				"decimal":   toolkit.ParamsValue("0"),
 				"engine":    toolkit.ParamsValue("hash"),
 			},
 			input:  "100",
@@ -102,7 +102,7 @@ func TestNoiseFloatTransformer_Transform(t *testing.T) {
 				"max_ratio": toolkit.ParamsValue("0.9"),
 				"min":       toolkit.ParamsValue("90"),
 				"max":       toolkit.ParamsValue("110"),
-				"precision": toolkit.ParamsValue("0"),
+				"decimal":   toolkit.ParamsValue("0"),
 			},
 			input:  "100",
 			result: result{min: 90, max: 110, regexp: `^-*\d+$`},

internal/db/postgres/transformers/noise_int.go

@@ -85,7 +85,6 @@ func NewNoiseIntTransformer(ctx context.Context, driver *toolkit.Driver, paramet
 	var columnName, engine string
 	var minRatio, maxRatio float64
 	var maxValueThreshold, minValueThreshold int64
-	var intSize int
 	var dynamicMode bool
 
 	columnParam := parameters["column"]
@@ -110,9 +109,7 @@ func NewNoiseIntTransformer(ctx context.Context, driver *toolkit.Driver, paramet
 	affectedColumns := make(map[int]string)
 	affectedColumns[idx] = columnName
 
-	if c.Length != -1 {
-		intSize = c.Length
-	}
+	intSize := c.GetColumnSize()
 
 	if minParam.IsDynamic() || maxParam.IsDynamic() {
 		dynamicMode = true