Adding tests for SELECT.

util/sqlgen/cond.go

+package sqlgen
+
+type Cond struct {
+}
+
+func (self Cond) String() string {
+	return ""
+}

util/sqlgen/fields.go

@@ -17,3 +17,7 @@ func (self Columns) String() string {
 
 	return strings.Join(out, sqlColumnComma)
 }
+
+func (self Columns) Len() int {
+	return len(self.v)
+}

util/sqlgen/main.go

@@ -11,17 +11,24 @@ const (
 	sqlColumnComma     = `, `
 	sqlEscape          = `"{{.Raw}}"`
 
+	sqlOrderByLayout = `
+		{{if .Columns}}
+			ORDER BY {{.Columns}} {{.Sort}}
+		{{end}}
+	`
+
 	sqlSelectLayout = `
-		SELECT {{.Fields}} FROM {{.Source}}
+		SELECT {{.Columns}} FROM {{.Source}}
 			{{if .Where}}
 				WHERE {{.Where}}
 			{{end}}
-			{{if .OrderBy}}
-				ORDER BY {{.OrderBy}} {{.Sort}}
-			{{end}}
+
+			{{.OrderBy}}
+
 			{{if .Limit}}
 				LIMIT {{.Limit}}
 			{{end}}
+
 			{{if .Offset}}
 				OFFSET {{.Offset}}
 			{{end}}
@@ -71,6 +78,8 @@ const (
 	sqlAnd             = `AND`
 	sqlOr              = `OR`
 	sqlDefaultOperator = `=`
+	sqlDescKeyword     = `DESC`
+	sqlAscKeyword      = `ASC`
 
 	sqlColumnValue = `{{.Column}} {{.Operator}} {{.Value}}`
 
@@ -84,21 +93,12 @@ const (
 	SqlDropTable
 	SqlDropDatabase
 	SqlSelectCount
+	SqlSelect
 )
 
 type (
-	Fields      []string
 	Limit  int
 	Offset int
-	Sort        string
-	OrderBy     string
-	FieldValues map[string]string
-	PrimaryKey  string
-	Values      []string
-	Operator    string
-	Field       string
-	Function    string
-	Where       string
 )
 
 func mustParse(text string, data interface{}) string {
@@ -114,26 +114,18 @@ func mustParse(text string, data interface{}) string {
 	return b.String()
 }
 
-func (self *FieldValues) String() string {
-	return ""
-}
-
 type Statement struct {
 	Type
 	Source
 	Database
 	Limit
 	Offset
-	Field
 	Columns
-	FieldValues
-	PrimaryKey
-	Values
-	Function
+	OrderBy
 	Where
 }
 
-func (self *Statement) String() string {
+func (self *Statement) Compile() string {
 	switch self.Type {
 	case SqlTruncate:
 		return mustParse(sqlTruncateLayout, self)
@@ -143,6 +135,8 @@ func (self *Statement) String() string {
 		return mustParse(sqlDropDatabaseLayout, self)
 	case SqlSelectCount:
 		return mustParse(sqlSelectCountLayout, self)
+	case SqlSelect:
+		return mustParse(sqlSelectLayout, self)
 	}
 	return ""
 }

util/sqlgen/main_test.go

@@ -129,7 +129,7 @@ func TestTruncateTable(t *testing.T) {
 		Source: Source{"source name"},
 	}
 
-	s = strings.TrimSpace(stmt.String())
+	s = strings.TrimSpace(stmt.Compile())
 	e = `TRUNCATE TABLE "source name"`
 
 	if s != e {
@@ -146,7 +146,7 @@ func TestDropTable(t *testing.T) {
 		Source: Source{"source name"},
 	}
 
-	s = strings.TrimSpace(stmt.String())
+	s = strings.TrimSpace(stmt.Compile())
 	e = `DROP TABLE "source name"`
 
 	if s != e {
@@ -163,7 +163,7 @@ func TestDropDatabase(t *testing.T) {
 		Database: Database{"source name"},
 	}
 
-	s = trim(stmt.String())
+	s = trim(stmt.Compile())
 	e = `DROP DATABASE "source name"`
 
 	if s != e {
@@ -180,10 +180,191 @@ func TestSelectCount(t *testing.T) {
 		Source: Source{"source name"},
 	}
 
-	s = trim(stmt.String())
+	s = trim(stmt.Compile())
 	e = `SELECT COUNT(1) AS _t FROM "source name"`
 
 	if s != e {
 		t.Fatalf("Got: %s, Expecting: %s", s, e)
 	}
 }
+
+func TestSelectFieldsFrom(t *testing.T) {
+	var s, e string
+	var stmt Statement
+
+	stmt = Statement{
+		Type: SqlSelect,
+		Columns: Columns{
+			[]Column{
+				{"foo"},
+				{"bar"},
+				{"baz"},
+			},
+		},
+		Source: Source{"source name"},
+	}
+
+	s = trim(stmt.Compile())
+	e = `SELECT "foo", "bar", "baz" FROM "source name"`
+
+	if s != e {
+		t.Fatalf("Got: %s, Expecting: %s", s, e)
+	}
+}
+
+func TestSelectFieldsFromWithLimitOffset(t *testing.T) {
+	var s, e string
+	var stmt Statement
+
+	// LIMIT only.
+	stmt = Statement{
+		Type: SqlSelect,
+		Columns: Columns{
+			[]Column{
+				{"foo"},
+				{"bar"},
+				{"baz"},
+			},
+		},
+		Limit:  42,
+		Source: Source{"source name"},
+	}
+
+	s = trim(stmt.Compile())
+	e = `SELECT "foo", "bar", "baz" FROM "source name" LIMIT 42`
+
+	if s != e {
+		t.Fatalf("Got: %s, Expecting: %s", s, e)
+	}
+
+	// OFFSET only.
+	stmt = Statement{
+		Type: SqlSelect,
+		Columns: Columns{
+			[]Column{
+				{"foo"},
+				{"bar"},
+				{"baz"},
+			},
+		},
+		Offset: 17,
+		Source: Source{"source name"},
+	}
+
+	s = trim(stmt.Compile())
+	e = `SELECT "foo", "bar", "baz" FROM "source name" OFFSET 17`
+
+	if s != e {
+		t.Fatalf("Got: %s, Expecting: %s", s, e)
+	}
+
+	// LIMIT AND OFFSET.
+	stmt = Statement{
+		Type: SqlSelect,
+		Columns: Columns{
+			[]Column{
+				{"foo"},
+				{"bar"},
+				{"baz"},
+			},
+		},
+		Limit:  42,
+		Offset: 17,
+		Source: Source{"source name"},
+	}
+
+	s = trim(stmt.Compile())
+	e = `SELECT "foo", "bar", "baz" FROM "source name" LIMIT 42 OFFSET 17`
+
+	if s != e {
+		t.Fatalf("Got: %s, Expecting: %s", s, e)
+	}
+}
+
+func TestSelectFieldsFromWithOrderBy(t *testing.T) {
+	var s, e string
+	var stmt Statement
+
+	// Simple ORDER BY
+	stmt = Statement{
+		Type: SqlSelect,
+		Columns: Columns{
+			[]Column{
+				{"foo"},
+				{"bar"},
+				{"baz"},
+			},
+		},
+		OrderBy: OrderBy{
+			Columns: Columns{
+				[]Column{
+					{"foo"},
+				},
+			},
+		},
+		Source: Source{"source name"},
+	}
+
+	s = trim(stmt.Compile())
+	e = `SELECT "foo", "bar", "baz" FROM "source name" ORDER BY "foo"`
+
+	if s != e {
+		t.Fatalf("Got: %s, Expecting: %s", s, e)
+	}
+
+	// ORDER BY field ASC
+	stmt = Statement{
+		Type: SqlSelect,
+		Columns: Columns{
+			[]Column{
+				{"foo"},
+				{"bar"},
+				{"baz"},
+			},
+		},
+		OrderBy: OrderBy{
+			Columns: Columns{
+				[]Column{
+					{"foo"},
+				},
+			},
+			Sort: Sort{SqlSortAsc},
+		},
+		Source: Source{"source name"},
+	}
+
+	s = trim(stmt.Compile())
+	e = `SELECT "foo", "bar", "baz" FROM "source name" ORDER BY "foo" ASC`
+
+	if s != e {
+		t.Fatalf("Got: %s, Expecting: %s", s, e)
+	}
+
+	// ORDER BY field DESC
+	stmt = Statement{
+		Type: SqlSelect,
+		Columns: Columns{
+			[]Column{
+				{"foo"},
+				{"bar"},
+				{"baz"},
+			},
+		},
+		OrderBy: OrderBy{
+			Columns: Columns{
+				[]Column{
+					{"foo"},
+				},
+			},
+			Sort: Sort{SqlSortDesc},
+		},
+		Source: Source{"source name"},
+	}
+
+	s = trim(stmt.Compile())
+	e = `SELECT "foo", "bar", "baz" FROM "source name" ORDER BY "foo" DESC`
+
+	if s != e {
+		t.Fatalf("Got: %s, Expecting: %s", s, e)
+	}
+}

util/sqlgen/order_by.go

+package sqlgen
+
+type OrderBy struct {
+	Columns
+	Sort
+}
+
+func (self OrderBy) String() string {
+	if self.Columns.Len() > 0 {
+		return mustParse(sqlOrderByLayout, self)
+	}
+	return ""
+}
+
+type Sort struct {
+	v uint8
+}
+
+const (
+	SqlSortNone = iota
+	SqlSortAsc
+	SqlSortDesc
+)
+
+func (self Sort) String() string {
+	switch self.v {
+	case SqlSortAsc:
+		return sqlAscKeyword
+	case SqlSortDesc:
+		return sqlDescKeyword
+	}
+	return ""
+}