Merge pull request #17 from schemahero/char-var

Support for character varying, move not notnullable to a pointer

config/crds/schemas_v1alpha1_table.yaml

@@ -45,10 +45,13 @@ spec:
                         properties:
                           constraints:
                             properties:
+                              maxLength:
+                                format: int64
+                                type: integer
                               notNull:
                                 type: boolean
                             required:
-                            - notNull
+                            - maxLength
                             type: object
                           default:
                             type: string

pkg/apis/schemas/v1alpha1/table_types.go

@@ -21,7 +21,8 @@ import (
 )
 
 type PostgresTableColumnConstraints struct {
-	NotNull bool `json:"notNull" yaml:"notNull"`
+	NotNull   *bool  `json:"notNull,omitempty" yaml:"notNull,omitempty"`
+	MaxLength *int64 `json:"maxLength,omitempt" yaml:"maxLength,omitempty"`
 }
 
 type PostgresTableColumn struct {

pkg/controller/table/postgres.go

@@ -10,6 +10,11 @@ import (
 	"github.com/schemahero/schemahero/pkg/database/postgres"
 )
 
+var (
+	trueValue  = true
+	falseValue = false
+)
+
 func (r *ReconcileTable) deployPostgres(connection *databasesv1alpha1.PostgresConnection, tableName string, postgresTableSchema *schemasv1alpha1.PostgresTableSchema) error {
 	db, err := sql.Open("postgres", connection.URI.Value)
 	if err != nil {
@@ -68,17 +73,22 @@ func (r *ReconcileTable) deployPostgres(connection *databasesv1alpha1.PostgresCo
 		foundColumnNames = append(foundColumnNames, columnName)
 
 		existingColumn := postgres.Column{
-			Name:     columnName,
-			DataType: dataType,
-			Constraints: &postgres.ColumnConstraints{
-				NotNull: isNullable == "NO",
-			},
+			Name:        columnName,
+			DataType:    dataType,
+			Constraints: &postgres.ColumnConstraints{},
 		}
+
+		if isNullable == "NO" {
+			existingColumn.Constraints.NotNull = &trueValue
+		} else {
+			existingColumn.Constraints.NotNull = &falseValue
+		}
+
 		if columnDefault.Valid {
 			existingColumn.ColumnDefault = &columnDefault.String
 		}
 		if charMaxLength.Valid {
-			existingColumn.CharMaxLength = &charMaxLength.Int64
+			existingColumn.Constraints.MaxLength = &charMaxLength.Int64
 		}
 
 		columnStatement, err := postgres.AlterColumnStatement(tableName, postgresTableSchema.Columns, &existingColumn)

pkg/database/postgres/alter.go

@@ -51,10 +51,10 @@ func AlterColumnStatement(tableName string, desiredColumns []*schemasv1alpha1.Po
 			}
 
 			if column.Constraints != nil {
-				if existingColumn.Constraints != nil {
-					if column.Constraints.NotNull && !existingColumn.Constraints.NotNull {
+				if existingColumn.Constraints != nil && column.Constraints.NotNull != nil {
+					if *column.Constraints.NotNull == true && *existingColumn.Constraints.NotNull == false {
 						columnStatement = fmt.Sprintf("%s set not null", columnStatement)
-					} else if !column.Constraints.NotNull && existingColumn.Constraints.NotNull {
+					} else if *column.Constraints.NotNull == false && *existingColumn.Constraints.NotNull == true {
 						columnStatement = fmt.Sprintf("%s drop not null", columnStatement)
 					}
 				}

pkg/database/postgres/alter_test.go

@@ -81,7 +81,7 @@ func Test_AlterColumnStatment(t *testing.T) {
 					Name: "a",
 					Type: "integer",
 					Constraints: &schemasv1alpha1.PostgresTableColumnConstraints{
-						NotNull: true,
+						NotNull: &trueValue,
 					},
 				},
 			},
@@ -90,7 +90,7 @@ func Test_AlterColumnStatment(t *testing.T) {
 				DataType:      "integer",
 				ColumnDefault: nil,
 				Constraints: &ColumnConstraints{
-					NotNull: false,
+					NotNull: &falseValue,
 				},
 			},
 			expectedStatement: `alter table "t" alter column "a" set not null`,
@@ -103,7 +103,7 @@ func Test_AlterColumnStatment(t *testing.T) {
 					Name: "a",
 					Type: "integer",
 					Constraints: &schemasv1alpha1.PostgresTableColumnConstraints{
-						NotNull: false,
+						NotNull: &falseValue,
 					},
 				},
 			},
@@ -112,7 +112,7 @@ func Test_AlterColumnStatment(t *testing.T) {
 				DataType:      "integer",
 				ColumnDefault: nil,
 				Constraints: &ColumnConstraints{
-					NotNull: true,
+					NotNull: &trueValue,
 				},
 			},
 			expectedStatement: `alter table "t" alter column "a" drop not null`,

pkg/database/postgres/column.go

@@ -46,13 +46,13 @@ var unparameterizedColumnTypes = []string{
 }
 
 type ColumnConstraints struct {
-	NotNull bool
+	NotNull   *bool
+	MaxLength *int64
 }
 
 type Column struct {
 	Name          string
 	DataType      string
-	CharMaxLength *int64
 	ColumnDefault *string
 	Constraints   *ColumnConstraints
 }
@@ -69,6 +69,7 @@ func maybeParseParameterizedColumnType(requestedType string) (string, *int64, er
 	// 	matchGroups := r.FindStringSubmatch(requestedType)
 	// 	masStr
 	// }
+
 	if strings.HasPrefix(requestedType, "character varying") {
 		columnType = "character varying"
 
@@ -85,7 +86,7 @@ func maybeParseParameterizedColumnType(requestedType string) (string, *int64, er
 	} else if strings.HasPrefix(requestedType, "timestamp") {
 		columnType = "timestamp"
 
-		withPrecisionWithoutTimeZone := regexp.MustCompile(`timestamp\s*\(\s*(?P<precision>.*)\s*\)without time zone`)
+		withPrecisionWithoutTimeZone := regexp.MustCompile(`timestamp\s*\(\s*(?P<precision>.*)\s*\)\s*without time zone`)
 		withPrecision := regexp.MustCompile(`timestamp\s*\(\s*(?P<precision>.*)\s*\)`)
 		withoutPrecisionWithoutTimeZone := regexp.MustCompile(`timestamp\s*without time zone`)
 		withoutPrecision := regexp.MustCompile(`timestamp\s*`)
@@ -163,7 +164,8 @@ func unaliasParameterizedColumnType(requestedType string) string {
 
 		return fmt.Sprintf("bit varying (%s)", matchGroups[1])
 	}
-	if strings.HasPrefix(requestedType, "char") {
+	if strings.HasPrefix(requestedType, "char ") || strings.HasPrefix(requestedType, "char(") ||
+		requestedType == "character" || requestedType == "char" {
 		r := regexp.MustCompile(`char\s*\((?P<len>\d*)\)`)
 
 		matchGroups := r.FindStringSubmatch(requestedType)
@@ -225,7 +227,8 @@ func unaliasParameterizedColumnType(requestedType string) string {
 
 func PostgresColumnToSchemaColumn(column *Column) (*schemasv1alpha1.PostgresTableColumn, error) {
 	constraints := &schemasv1alpha1.PostgresTableColumnConstraints{
-		NotNull: column.Constraints.NotNull,
+		NotNull:   column.Constraints.NotNull,
+		MaxLength: column.Constraints.MaxLength,
 	}
 
 	schemaColumn := &schemasv1alpha1.PostgresTableColumn{
@@ -271,10 +274,14 @@ func schemaColumnToPostgresColumn(schemaColumn *schemasv1alpha1.PostgresTableCol
 		return nil, err
 	}
 
+	if maxLength != nil {
+		column.Constraints = &ColumnConstraints{
+			MaxLength: maxLength,
+		}
+	}
+
 	if columnType != "" {
 		column.DataType = columnType
-		column.CharMaxLength = maxLength
-
 		return column, nil
 	}
 
@@ -295,12 +302,12 @@ func postgresColumnAsInsert(column *schemasv1alpha1.PostgresTableColumn) (string
 
 	formatted := fmt.Sprintf("%s %s", pq.QuoteIdentifier(column.Name), postgresColumn.DataType)
 
-	if postgresColumn.CharMaxLength != nil {
-		formatted = fmt.Sprintf("%s(%d)", formatted, *postgresColumn.CharMaxLength)
+	if postgresColumn.Constraints != nil && postgresColumn.Constraints.MaxLength != nil {
+		formatted = fmt.Sprintf("%s (%d)", formatted, *postgresColumn.Constraints.MaxLength)
 	}
 
-	if postgresColumn.Constraints != nil {
-		if postgresColumn.Constraints.NotNull {
+	if postgresColumn.Constraints != nil && postgresColumn.Constraints.NotNull != nil {
+		if *postgresColumn.Constraints.NotNull == true {
 			formatted = fmt.Sprintf("%s not null", formatted)
 		} else {
 			formatted = fmt.Sprintf("%s null", formatted)

pkg/database/postgres/column_test.go

@@ -43,18 +43,64 @@ func Test_unaliasParameterizedColumnType(t *testing.T) {
 }
 
 func Test_maybeParseParameterizedColumnType(t *testing.T) {
-	parameterizedTests := map[string]string{
-		"fake":                        "",
-		"timestamp":                   "timestamp",
-		"timestamp without time zone": "timestamp without time zone",
-		// "timestamp (01:02)":                   "timestamp (01:02)",
-		// "timestamp (01:02) without time zone": "timestamp (01:02) without time zone",
+	none := int64(-1)
+
+	tests := []struct {
+		name               string
+		requestedType      string
+		expectedColumnType string
+		expectedMaxLength  int64
+	}{
+		{
+			name:               "fake",
+			requestedType:      "fake",
+			expectedColumnType: "",
+			expectedMaxLength:  none,
+		},
+		{
+			name:               "timestamp",
+			requestedType:      "timestamp",
+			expectedColumnType: "timestamp",
+			expectedMaxLength:  none,
+		},
+		{
+			name:               "timestamp without time zone",
+			requestedType:      "timestamp without time zone",
+			expectedColumnType: "timestamp without time zone",
+			expectedMaxLength:  none,
+		},
+		{
+			name:               "timestamp (01:02)",
+			requestedType:      "timestamp (01:02)",
+			expectedColumnType: "timestamp (01:02)",
+			expectedMaxLength:  none,
+		},
+		{
+			name:               "timestamp (01:02) without time zone",
+			requestedType:      "timestamp (01:02) without time zone",
+			expectedColumnType: "timestamp (01:02) without time zone",
+			expectedMaxLength:  none,
+		},
+		{
+			name:               "character varying (10)",
+			requestedType:      "character varying (10)",
+			expectedColumnType: "character varying",
+			expectedMaxLength:  int64(10),
+		},
 	}
 
-	for input, expectedOutput := range parameterizedTests {
-		t.Run(input, func(t *testing.T) {
-			output, _, _ := maybeParseParameterizedColumnType(input)
-			assert.Equal(t, expectedOutput, output)
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			columnType, maxLength, err := maybeParseParameterizedColumnType(test.requestedType)
+			req := require.New(t)
+			req.NoError(err)
+			assert.Equal(t, test.expectedColumnType, columnType)
+
+			if test.expectedMaxLength == none {
+				assert.Nil(t, maxLength)
+			} else {
+				assert.Equal(t, test.expectedMaxLength, *maxLength)
+			}
 		})
 	}
 }
@@ -150,6 +196,14 @@ func Test_postgresColumnAsInsert(t *testing.T) {
 			},
 			expectedStatement: `"t" timestamp without time zone`,
 		},
+		{
+			name: "character varying (4)",
+			column: &schemasv1alpha1.PostgresTableColumn{
+				Name: "c",
+				Type: "character varying (4)",
+			},
+			expectedStatement: `"c" character varying (4)`,
+		},
 	}
 
 	for _, test := range tests {
@@ -186,7 +240,7 @@ func Test_InsertColumnStatement(t *testing.T) {
 				Name: "a",
 				Type: "integer",
 				Constraints: &schemasv1alpha1.PostgresTableColumnConstraints{
-					NotNull: true,
+					NotNull: &trueValue,
 				},
 			},
 			expectedStatement: `alter table "t" add column "a" integer not null`,
@@ -198,7 +252,7 @@ func Test_InsertColumnStatement(t *testing.T) {
 				Name: "a",
 				Type: "integer",
 				Constraints: &schemasv1alpha1.PostgresTableColumnConstraints{
-					NotNull: false,
+					NotNull: &falseValue,
 				},
 			},
 			expectedStatement: `alter table "t" add column "a" integer null`,

pkg/database/postgres/create_test.go

@@ -55,7 +55,7 @@ func Test_CreateTableStatement(t *testing.T) {
 				},
 			},
 			tableName:         "composite_primary_key",
-			expectedStatement: `create table "composite_primary_key" ("one" integer, "two" integer, "three" character varying(255), primary key ("one", "two"))`,
+			expectedStatement: `create table "composite_primary_key" ("one" integer, "two" integer, "three" character varying (255), primary key ("one", "two"))`,
 		},
 	}
 

pkg/database/postgres/tables.go

@@ -6,6 +6,11 @@ import (
 	_ "github.com/lib/pq"
 )
 
+var (
+	trueValue  = true
+	falseValue = false
+)
+
 func (pg *Postgres) ListTables() ([]string, error) {
 	query := "select table_name from information_schema.tables where table_catalog = $1 and table_schema = $2"
 
@@ -74,18 +79,24 @@ func (pg *Postgres) GetTableSchema(tableName string) ([]*Column, error) {
 			return nil, err
 		}
 
+		if isNullable == "NO" {
+			column.Constraints = &ColumnConstraints{
+				NotNull: &trueValue,
+			}
+		} else {
+			column.Constraints = &ColumnConstraints{
+				NotNull: &falseValue,
+			}
+		}
+
 		if maxLength.Valid {
-			column.CharMaxLength = &maxLength.Int64
+			column.Constraints.MaxLength = &maxLength.Int64
 		}
 
 		if columnDefault.Valid {
 			column.ColumnDefault = &columnDefault.String
 		}
 
-		column.Constraints = &ColumnConstraints{
-			NotNull: isNullable == "NO",
-		}
-
 		columns = append(columns, &column)
 	}