Initial comit

Author: percona-csalguero

README.md

@@ -0,0 +1,140 @@
+# Random data generator for MySQL
+
+Many times in my job i need to generate random data for a specific table in order to reproduce an issue.  
+After writing many random generators for every table, I decided to write a random data generator, able to get the table structure and generate random data for it.  
+Plase take into consideration that this is the first version and it doesn't support all field types yet!  
+
+**NOTICE**  
+This is an early stage project.  
+
+## Supported fields:
+
+|Field type|Generated values|
+|----------|----------------|
+|tinyint|0 ~ 0xFF|
+|smallint|0 ~ 0XFFFF|
+|mediumint|0 ~ 0xFFFFFF|
+|int - integer|0 ~ 0xFFFFFFFF|
+|bigint|0 ~ 0xFFFFFFFFFFFFFFFF|
+|float|0 ~ 1e8|
+|decimal(m,n)|0 ~ 10^(m-n)|
+|double|0 ~ 1000|
+|char(n)|up to n random chars|
+|varchar(n)|up to n random chars|
+|date|NOW() - 1 year ~ NOW()|
+|datetime|NOW() - 1 year ~ NOW()|
+|timestamp|NOW() - 1 year ~ NOW()|
+|time|00:00:00 ~ 23:59:59|
+|year|Current year - 1 ~ current year|
+|blob|up to 100 chars random paragraph|
+|text|up to 100 chars random paragraph|
+|mediumblob|up to 100 chars random paragraph|
+|mediumtext|up to 100 chars random paragraph|
+|longblob|up to 100 chars random paragraph|
+|longtext|up to 100 chars random paragraph|
+|varbinary|up to 100 chars random paragraph|
+|enum|A random item from the valid items list|
+|set|A random item from the valid items list|
+
+### How strings are generated
+
+- If field size < 10 the program generates a random "first name"
+- If the field size > 10 and < 30 the program generates a random "full name"
+- If the field size > 30 the program generates a "lorem ipsum" paragraph having up to 100 chars.
+ 
+The program can detect if a field accepts NULLs and if it does, it will generate NULLs ramdomly (~ 10 % of the values).
+
+## Usage
+`random-data-generator <database> <table> <number of rows> [options...]`
+
+## Options
+|Option|Description|
+|------|-----------|
+|--host|Host name/ip|
+|--port|Port number|
+|--user|Username|
+|--password|Password|
+|--bulk-size|Number of rows per INSERT statement (Default: 1000)|
+|--debug|Show some debug information|
+
+### Example
+```
+CREATE DATABASE IF NOT EXISTS test;
+
+CREATE TABLE `test`.`t3` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `tcol01` tinyint(4) DEFAULT NULL,
+  `tcol02` smallint(6) DEFAULT NULL,
+  `tcol03` mediumint(9) DEFAULT NULL,
+  `tcol04` int(11) DEFAULT NULL,
+  `tcol05` bigint(20) DEFAULT NULL,
+  `tcol06` float DEFAULT NULL,
+  `tcol07` double DEFAULT NULL,
+  `tcol08` decimal(10,2) DEFAULT NULL,
+  `tcol09` date DEFAULT NULL,
+  `tcol10` datetime DEFAULT NULL,
+  `tcol11` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  `tcol12` time DEFAULT NULL,
+  `tcol13` year(4) DEFAULT NULL,
+  `tcol14` varchar(100) DEFAULT NULL,
+  `tcol15` char(2) DEFAULT NULL,
+  `tcol16` blob,
+  `tcol17` text,
+  `tcol18` mediumtext,
+  `tcol19` mediumblob,
+  `tcol20` longblob,
+  `tcol21` longtext,
+  `tcol22` mediumtext,
+  `tcol23` varchar(3) DEFAULT NULL,
+  `tcol24` varbinary(10) DEFAULT NULL,
+  `tcol25` enum('a','b','c') DEFAULT NULL,
+  `tcol26` set('red','green','blue') DEFAULT NULL,
+  `tcol27` float(5,3) DEFAULT NULL,
+  `tcol28` double(4,2) DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB;
+```
+To generate 10K random rows, just run:
+```
+random-data-load test t3 100000 --max-threads=8 --user=root --password=root
+```
+```
+mysql> select * from t3 limit 1\G
+*************************** 1. row ***************************
+    id: 1
+tcol01: 10
+tcol02: 173
+tcol03: 1700
+tcol04: 13498
+tcol05: 33239373
+tcol06: 44846.4
+tcol07: 5300.23
+tcol08: 11360967.75
+tcol09: 2017-09-04
+tcol10: 2016-11-02 23:11:25
+tcol11: 2017-03-03 08:11:40
+tcol12: 03:19:39
+tcol13: 2017
+tcol14: repellat maxime nostrum provident maiores ut quo voluptas.
+tcol15: Th
+tcol16: Walter
+tcol17: quo repellat accusamus quidem odi
+tcol18: esse laboriosam nobis libero aut dolores e
+tcol19: Carlos Willia
+tcol20: et nostrum iusto ipsa sunt recusa
+tcol21: a accusantium laboriosam voluptas facilis.
+tcol22: laudantium quo unde molestiae consequatur magnam.
+tcol23: Pet
+tcol24: Richard
+tcol25: c
+tcol26: green
+tcol27: 47.430
+tcol28: 6.12
+1 row in set (0.00 sec)
+```
+
+## To do
+- [ ] Add suport for all data types.
+- [ ] Add supporrt for foreign keys.
+- [ ] Support config files to override default values/ranges.
+- [ ] Support custom functions via LUA plugins.

internal/getters/getters.go

@@ -0,0 +1,205 @@
+package getters
+
+import (
+	"fmt"
+	"math"
+	"math/rand"
+	"time"
+
+	"github.com/icrowley/fake"
+)
+
+const (
+	nilFrequency = 10
+	oneYear      = 60 * 60 * 24 * 365 * time.Second
+)
+
+type Getter interface {
+	Value() interface{}
+}
+
+type RandomInt struct {
+	mask      uint64
+	allowNull bool
+}
+
+func (r *RandomInt) Value() interface{} {
+	rand.Seed(time.Now().UnixNano())
+	return uint64(rand.Int63n(10e8)) & r.mask
+}
+
+func NewRandomInt(mask uint64, allowNull bool) Getter {
+	return &RandomInt{mask, allowNull}
+}
+
+type RandomIntRange struct {
+	min       int64
+	max       int64
+	allowNull bool
+}
+
+func (r *RandomIntRange) Value() interface{} {
+	rand.Seed(time.Now().UnixNano())
+	limit := r.max - r.min + 1
+	return r.min + rand.Int63n(limit)
+}
+
+func NewRandomIntRange(min, max int64, allowNull bool) Getter {
+	return &RandomIntRange{min, max, allowNull}
+}
+
+type RandomDecimal struct {
+	size      float64
+	allowNull bool
+}
+
+func (r *RandomDecimal) Value() interface{} {
+	rand.Seed(time.Now().UnixNano())
+	f := rand.Float64() * float64(rand.Int63n(int64(math.Pow10(int(r.size)))))
+	format := fmt.Sprintf("%%%0.1ff", r.size)
+	return fmt.Sprintf(format, f)
+}
+
+func NewRandomDecimal(size float64, allowNull bool) Getter {
+	if size == 0 {
+		size = 5.2
+	}
+	return &RandomDecimal{size, allowNull}
+}
+
+type RandomString struct {
+	maxSize   float64
+	allowNull bool
+}
+
+func (r *RandomString) Value() interface{} {
+	rand.Seed(time.Now().UnixNano())
+	if r.allowNull && rand.Int63n(100) < nilFrequency {
+		return nil
+	}
+	var s string
+	maxSize := uint64(r.maxSize)
+	if maxSize == 0 {
+		maxSize = uint64(rand.Int63n(100))
+	}
+
+	if maxSize <= 10 {
+		s = fake.FirstName()
+	} else if maxSize < 30 {
+		s = fake.FullName()
+	} else {
+		s = fake.Sentence()
+	}
+	if len(s) > int(maxSize) {
+		s = s[:int(maxSize)]
+	}
+	return s
+}
+
+func NewRandomString(maxSize float64, allowNull bool) Getter {
+	return &RandomString{maxSize, allowNull}
+}
+
+type RandomDate struct {
+	allowNull bool
+}
+
+func (r *RandomDate) Value() interface{} {
+	rand.Seed(time.Now().UnixNano())
+	d := time.Now().Add(time.Duration(-1*int64(uint64(rand.Int63n(int64(oneYear))))) * time.Second)
+	return d.Format("2006-01-02 15:03:04")
+}
+
+func NewRandomDate(allowNull bool) Getter {
+	return &RandomDate{allowNull}
+}
+
+type RandomDateInRange struct {
+	min       string
+	max       string
+	allowNull bool
+}
+
+func (r *RandomDateInRange) Value() interface{} {
+	d := time.Now().Add(time.Duration(-1*rand.Int63n(int64(oneYear.Seconds()))) * time.Second)
+	return d.Format("2006-01-02 15:03:04")
+}
+
+func NewRandomDateInRange(min, max string, allowNull bool) Getter {
+	if min == "" {
+		t := time.Now().Add(-1 * oneYear)
+		min = t.Format("2006-01-02")
+	}
+	return &RandomDateInRange{min, max, allowNull}
+}
+
+type RandomDateTimeInRange struct {
+	min       string
+	max       string
+	allowNull bool
+}
+
+func (r *RandomDateTimeInRange) Value() interface{} {
+	d := time.Now().Add(time.Duration(-1*rand.Int63n(int64(oneYear.Seconds()))) * time.Second)
+	return d.Format("2006-01-02 15:03:04")
+}
+
+func NewRandomDateTimeInRange(min, max string, allowNull bool) Getter {
+	if min == "" {
+		t := time.Now().Add(-1 * oneYear)
+		min = t.Format("2006-01-02")
+	}
+	return &RandomDateInRange{min, max, allowNull}
+}
+
+func NewRandomDateTime(allowNull bool) Getter {
+	return &RandomDateInRange{"", "", allowNull}
+}
+
+// RandomTime Getter
+type RandomTime struct {
+	allowNull bool
+}
+
+func (r *RandomTime) Value() interface{} {
+	rand.Seed(time.Now().UnixNano())
+	h := rand.Int63n(24)
+	m := rand.Int63n(60)
+	s := rand.Int63n(60)
+	return fmt.Sprintf("%02d:%02d:%02d", h, m, s)
+}
+
+func NewRandomTime(allowNull bool) Getter {
+	return &RandomTime{allowNull}
+}
+
+// RandomEnum Getter
+type RandomEnum struct {
+	allowedValues []string
+	allowNull     bool
+}
+
+func (r *RandomEnum) Value() interface{} {
+	rand.Seed(time.Now().UnixNano())
+	if r.allowNull && rand.Int63n(100) < nilFrequency {
+		return nil
+	}
+	i := rand.Int63n(int64(len(r.allowedValues)))
+	return r.allowedValues[i]
+}
+
+func NewRandomEnum(allowedValues []string, allowNull bool) Getter {
+	return &RandomEnum{allowedValues, allowNull}
+}
+
+// Constant Getter. Used for debugging
+type Constant struct {
+}
+
+func (r *Constant) Value() interface{} {
+	return "constant"
+}
+
+func NewConstant() Getter {
+	return &Constant{}
+}