Add more helper functions to the table

Author: Sergey Podgornyy

table.go

@@ -85,6 +85,86 @@ func (t *Table) Timestamps() {
 	})
 }
 
+// Int adds int(precision) column to the table
+func (t *Table) Int(name string, precision uint16, unsigned bool) {
+	t.Column(name, Integer{Precision: precision, Unsigned: unsigned})
+}
+
+// BigInt adds bigint(precision) column to the table
+func (t *Table) BigInt(name string, precision uint16, unsigned bool) {
+	t.Column(name, Integer{Prefix: "big", Precision: precision, Unsigned: unsigned})
+}
+
+// Float adds float(precision,scale) column to the table
+func (t *Table) Float(name string, precision uint16, scale uint16) {
+	t.Column(name, Floatable{Precision: precision, Scale: scale})
+}
+
+// FixedFloat is an alias to decimal(precision,scale) column
+func (t *Table) FixedFloat(name string, precision uint16, scale uint16) {
+	t.Decimal(name, precision, scale)
+}
+
+// Decimal adds decimal(precision,scale) column to the table
+func (t *Table) Decimal(name string, precision uint16, scale uint16) {
+	t.Column(name, Floatable{Type: "decimal", Precision: precision, Scale: scale})
+}
+
+// Varchar adds varchar(precision) column to the table
+func (t *Table) Varchar(name string, precision uint16) {
+	t.Column(name, String{Precision: precision})
+}
+
+// Char adds char(precision) column to the table
+func (t *Table) Char(name string, precision uint16) {
+	t.Column(name, String{Fixed: true, Precision: precision})
+}
+
+// Text adds text column to the table
+func (t *Table) Text(name string, nullable bool) {
+	t.Column(name, Text{Nullable: nullable})
+}
+
+// Blob adds blob column to the table
+func (t *Table) Blob(name string, nullable bool) {
+	t.Column(name, Text{Blob: true, Nullable: nullable})
+}
+
+// JSON adds json column to the table
+func (t *Table) JSON(name string) {
+	t.Column(name, JSON{})
+}
+
+// Timestamp adds timestamp column to the table
+func (t *Table) Timestamp(name string, nullable bool, def string) {
+	t.Column(name, Timable{Nullable: nullable, Default: def})
+}
+
+// Date adds date column to the table
+func (t *Table) Date(name string, nullable bool, def string) {
+	t.Column(name, Timable{Type: "date", Nullable: nullable, Default: def})
+}
+
+// Time adds time column to the table
+func (t *Table) Time(name string, nullable bool, def string) {
+	t.Column(name, Timable{Type: "time", Nullable: nullable, Default: def})
+}
+
+// Year adds year column to the table
+func (t *Table) Year(name string, nullable bool, def string) {
+	t.Column(name, Timable{Type: "year", Nullable: nullable, Default: def})
+}
+
+// Binary adds binary(precision) column to the table
+func (t *Table) Binary(name string, precision uint16, nullable bool) {
+	t.Column(name, Binary{Fixed: true, Precision: precision, Nullable: nullable})
+}
+
+// Varbinary adds varbinary(precision) column to the table
+func (t *Table) Varbinary(name string, precision uint16, nullable bool) {
+	t.Column(name, Binary{Precision: precision, Nullable: nullable})
+}
+
 // Primary adds primary key
 func (t *Table) Primary(columns ...string) {
 	if len(columns) == 0 {

table_test.go

@@ -109,6 +109,214 @@ func TestTimestampsColumn(t *testing.T) {
 	assert.Equal(Timable{Type: "timestamp", Default: "CURRENT_TIMESTAMP", OnUpdate: "CURRENT_TIMESTAMP"}, table.columns[1].definition)
 }
 
+func TestIntColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Int("number", 64, true)
+
+	assert.Len(table.columns, 1)
+	assert.Equal("number", table.columns[0].field)
+	assert.Equal(Integer{Precision: 64, Unsigned: true}, table.columns[0].definition)
+}
+
+func TestBigIntColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.BigInt("number", 64, true)
+
+	assert.Len(table.columns, 1)
+	assert.Equal("number", table.columns[0].field)
+	assert.Equal(Integer{Prefix: "big", Precision: 64, Unsigned: true}, table.columns[0].definition)
+}
+
+func TestFloatColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Float("number", 15, 2)
+
+	assert.Len(table.columns, 1)
+	assert.Equal("number", table.columns[0].field)
+	assert.Equal(Floatable{Precision: 15, Scale: 2}, table.columns[0].definition)
+}
+
+func TestFixedFloatColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.FixedFloat("number", 15, 2)
+
+	assert.Len(table.columns, 1)
+	assert.Equal("number", table.columns[0].field)
+	assert.Equal(Floatable{Type: "decimal", Precision: 15, Scale: 2}, table.columns[0].definition)
+}
+
+func TestDecimalColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Decimal("number", 15, 2)
+
+	assert.Len(table.columns, 1)
+	assert.Equal("number", table.columns[0].field)
+	assert.Equal(Floatable{Type: "decimal", Precision: 15, Scale: 2}, table.columns[0].definition)
+}
+
+func TestVarcharColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Varchar("string", 64)
+
+	assert.Len(table.columns, 1)
+	assert.Equal("string", table.columns[0].field)
+	assert.Equal(String{Precision: 64}, table.columns[0].definition)
+}
+
+func TestCharColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Char("string", 32)
+
+	assert.Len(table.columns, 1)
+	assert.Equal("string", table.columns[0].field)
+	assert.Equal(String{Fixed: true, Precision: 32}, table.columns[0].definition)
+}
+
+func TestTextColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Text("string", true)
+
+	assert.Len(table.columns, 1)
+	assert.Equal("string", table.columns[0].field)
+	assert.Equal(Text{Nullable: true}, table.columns[0].definition)
+}
+
+func TestBlobColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Blob("string", true)
+
+	assert.Len(table.columns, 1)
+	assert.Equal("string", table.columns[0].field)
+	assert.Equal(Text{Blob: true, Nullable: true}, table.columns[0].definition)
+}
+
+func TestJsonColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.JSON("data")
+
+	assert.Len(table.columns, 1)
+	assert.Equal("data", table.columns[0].field)
+	assert.Equal(JSON{}, table.columns[0].definition)
+}
+
+func TestTimestampColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Timestamp("date", true, "CURRENT_TIMESTAMP")
+
+	assert.Len(table.columns, 1)
+	assert.Equal("date", table.columns[0].field)
+	assert.Equal(Timable{Nullable: true, Default: "CURRENT_TIMESTAMP"}, table.columns[0].definition)
+}
+
+func TestDateColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Date("date", true, "NOW()")
+
+	assert.Len(table.columns, 1)
+	assert.Equal("date", table.columns[0].field)
+	assert.Equal(Timable{Type: "date", Nullable: true, Default: "NOW()"}, table.columns[0].definition)
+}
+
+func TestTimeColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Time("time", true, "NOW()")
+
+	assert.Len(table.columns, 1)
+	assert.Equal("time", table.columns[0].field)
+	assert.Equal(Timable{Type: "time", Nullable: true, Default: "NOW()"}, table.columns[0].definition)
+}
+
+func TestYearColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Year("year", true, "YEAR(NOW())")
+
+	assert.Len(table.columns, 1)
+	assert.Equal("year", table.columns[0].field)
+	assert.Equal(Timable{Type: "year", Nullable: true, Default: "YEAR(NOW())"}, table.columns[0].definition)
+}
+
+func TestBinaryColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Binary("binary", 36, true)
+
+	assert.Len(table.columns, 1)
+	assert.Equal("binary", table.columns[0].field)
+	assert.Equal(Binary{Fixed: true, Precision: 36, Nullable: true}, table.columns[0].definition)
+}
+
+func TestVarbinaryColumn(t *testing.T) {
+	assert := assert.New(t)
+	table := Table{}
+
+	assert.Nil(table.columns)
+
+	table.Varbinary("binary", 36, true)
+
+	assert.Len(table.columns, 1)
+	assert.Equal("binary", table.columns[0].field)
+	assert.Equal(Binary{Precision: 36, Nullable: true}, table.columns[0].definition)
+}
+
 func TestTablePrimaryIndex(t *testing.T) {
 	t.Run("it skips adding key on empty columns list", func(t *testing.T) {
 		assert := assert.New(t)