add where and or

Author: aacebo

sqlx/and.go

@@ -1,20 +1,55 @@
 package sqlx
 
-import "strings"
+import (
+	"fmt"
+	"strings"
+)
 
-type AndClause []Sqlizer
+type AndClause struct {
+	depth      uint
+	conditions []Sqlizer
+}
 
-func And(conditions ...Sqlizer) AndClause {
-	return conditions
+func And(conditions ...Sqlizer) *AndClause {
+	return &AndClause{0, conditions}
 }
 
 func (self AndClause) Sql() string {
-	parts := make([]string, len(self))
+	parts := []string{}
 
-	for i, cond := range self {
-		parts[i] = cond.Sql()
+	for _, cond := range self.conditions {
+		parts = append(parts, cond.Sql())
+	}
+
+	sql := strings.Join(parts, " AND ")
+
+	if self.depth > 0 && len(parts) > 1 {
+		sql = fmt.Sprintf("(%s)", sql)
 	}
 
-	sql := strings.Join(parts, "")
 	return sql
 }
+
+func (self AndClause) SqlPretty() string {
+	parts := []string{}
+
+	for _, cond := range self.conditions {
+		parts = append(parts, cond.Sql())
+	}
+
+	sql := strings.Join(parts, "\nAND ")
+
+	if self.depth > 0 && len(parts) > 1 {
+		sql = fmt.Sprintf("(%s)", sql)
+	}
+
+	return sql
+}
+
+func (self *AndClause) setDepth(depth uint) {
+	self.depth = depth
+
+	for _, cond := range self.conditions {
+		cond.setDepth(self.depth + 1)
+	}
+}

sqlx/as.go

@@ -3,12 +3,13 @@ package sqlx
 import "fmt"
 
 type AsClause struct {
+	depth uint
 	stmt  Sqlizer
 	alias string
 }
 
 func As(stmt Sqlizer, alias string) *AsClause {
-	return &AsClause{stmt, alias}
+	return &AsClause{0, stmt, alias}
 }
 
 func (self AsClause) Sql() string {
@@ -18,3 +19,8 @@ func (self AsClause) Sql() string {
 func (self AsClause) SqlPretty() string {
 	return fmt.Sprintf("%s as \"%s\"", self.stmt.SqlPretty(), self.alias)
 }
+
+func (self *AsClause) setDepth(depth uint) {
+	self.depth = depth
+	self.stmt.setDepth(depth + 1)
+}

sqlx/or.go

@@ -0,0 +1,55 @@
+package sqlx
+
+import (
+	"fmt"
+	"strings"
+)
+
+type OrClause struct {
+	depth      uint
+	conditions []Sqlizer
+}
+
+func Or(conditions ...Sqlizer) *OrClause {
+	return &OrClause{0, conditions}
+}
+
+func (self OrClause) Sql() string {
+	parts := []string{}
+
+	for _, cond := range self.conditions {
+		parts = append(parts, cond.Sql())
+	}
+
+	sql := strings.Join(parts, " OR ")
+
+	if self.depth > 0 && len(parts) > 1 {
+		sql = fmt.Sprintf("(%s)", sql)
+	}
+
+	return sql
+}
+
+func (self OrClause) SqlPretty() string {
+	parts := []string{}
+
+	for _, cond := range self.conditions {
+		parts = append(parts, cond.Sql())
+	}
+
+	sql := strings.Join(parts, "\nOR ")
+
+	if self.depth > 0 && len(parts) > 1 {
+		sql = fmt.Sprintf("(%s)", sql)
+	}
+
+	return sql
+}
+
+func (self *OrClause) setDepth(depth uint) {
+	self.depth = depth
+
+	for _, cond := range self.conditions {
+		cond.setDepth(self.depth + 1)
+	}
+}

sqlx/raw.go

@@ -1,11 +1,12 @@
 package sqlx
 
 type RawStatement struct {
-	stmt string
+	depth uint
+	stmt  string
 }
 
 func Raw(stmt string) *RawStatement {
-	return &RawStatement{stmt}
+	return &RawStatement{0, stmt}
 }
 
 func (self RawStatement) Sql() string {
@@ -15,3 +16,7 @@ func (self RawStatement) Sql() string {
 func (self RawStatement) SqlPretty() string {
 	return self.stmt
 }
+
+func (self *RawStatement) setDepth(depth uint) {
+	self.depth = depth
+}

sqlx/select.go

@@ -9,6 +9,7 @@ type SelectStatement struct {
 	depth   uint
 	columns []Sqlizer
 	from    Sqlizer
+	where   Sqlizer
 }
 
 func Select(columns ...string) *SelectStatement {
@@ -22,6 +23,7 @@ func Select(columns ...string) *SelectStatement {
 		depth:   0,
 		columns: cols,
 		from:    nil,
+		where:   nil,
 	}
 }
 
@@ -46,6 +48,12 @@ func (self *SelectStatement) FromSelect(stmt *SelectStatement, alias string) *Se
 	return self
 }
 
+func (self *SelectStatement) Where(where Sqlizer) *SelectStatement {
+	where.setDepth(self.depth)
+	self.where = where
+	return self
+}
+
 func (self SelectStatement) Sql() string {
 	parts := []string{"SELECT"}
 	columns := []string{}
@@ -55,7 +63,15 @@ func (self SelectStatement) Sql() string {
 	}
 
 	parts = append(parts, strings.Join(columns, ", "))
-	parts = append(parts, "FROM", self.from.Sql())
+
+	if self.from != nil {
+		parts = append(parts, "FROM", self.from.Sql())
+	}
+
+	if self.where != nil {
+		parts = append(parts, "WHERE", self.where.Sql())
+	}
+
 	sql := strings.Join(parts, " ")
 
 	if self.depth == 0 {
@@ -70,3 +86,7 @@ func (self SelectStatement) Sql() string {
 func (self SelectStatement) SqlPretty() string {
 	return strings.Join([]string{}, "\n")
 }
+
+func (self *SelectStatement) setDepth(depth uint) {
+	self.depth = depth
+}

sqlx/select_test.go

@@ -7,22 +7,77 @@ import (
 )
 
 func TestSelect(t *testing.T) {
-	t.Run("should build basic", func(t *testing.T) {
-		sql := sqlx.Select("a", "b", "c").From("test").Sql()
+	t.Run("from", func(t *testing.T) {
+		t.Run("string", func(t *testing.T) {
+			sql := sqlx.Select("a", "b", "c").From("test").Sql()
 
-		if sql != "SELECT a, b, c FROM test;" {
-			t.Fatalf(sql)
-		}
+			if sql != "SELECT a, b, c FROM test;" {
+				t.Fatalf(sql)
+			}
+		})
+
+		t.Run("select", func(t *testing.T) {
+			sql := sqlx.Select("a", "b", "c").FromSelect(
+				sqlx.Select("d", "e", "f").From("test"),
+				"test",
+			).Sql()
+
+			if sql != "SELECT a, b, c FROM (SELECT d, e, f FROM test) as \"test\";" {
+				t.Fatalf(sql)
+			}
+		})
 	})
 
-	t.Run("should build with nested from", func(t *testing.T) {
-		sql := sqlx.Select("a", "b", "c").FromSelect(
-			sqlx.Select("d", "e", "f").From("test"),
-			"test",
-		).Sql()
+	t.Run("where", func(t *testing.T) {
+		t.Run("and", func(t *testing.T) {
+			sql := sqlx.Select(
+				"a", "b", "c",
+			).From("test").Where(
+				sqlx.And(
+					sqlx.Raw("a = b"),
+					sqlx.Raw("b = c"),
+				),
+			).Sql()
+
+			if sql != "SELECT a, b, c FROM test WHERE a = b AND b = c;" {
+				t.Fatalf(sql)
+			}
+		})
+
+		t.Run("or", func(t *testing.T) {
+			sql := sqlx.Select(
+				"a", "b", "c",
+			).From("test").Where(
+				sqlx.Or(
+					sqlx.Raw("a = b"),
+					sqlx.Raw("b = c"),
+				),
+			).Sql()
+
+			if sql != "SELECT a, b, c FROM test WHERE a = b OR b = c;" {
+				t.Fatalf(sql)
+			}
+		})
+
+		t.Run("and or", func(t *testing.T) {
+			sql := sqlx.Select(
+				"a", "b", "c",
+			).From("test").Where(
+				sqlx.And(
+					sqlx.And(
+						sqlx.Raw("a = b"),
+						sqlx.Raw("b = c"),
+					),
+					sqlx.Or(
+						sqlx.Raw("a = b"),
+						sqlx.Raw("b = c"),
+					),
+				),
+			).Sql()
 
-		if sql != "SELECT a, b, c FROM (SELECT d, e, f FROM test) as \"test\";" {
-			t.Fatalf(sql)
-		}
+			if sql != "SELECT a, b, c FROM test WHERE (a = b AND b = c) AND (a = b OR b = c);" {
+				t.Fatalf(sql)
+			}
+		})
 	})
 }

sqlx/sqlizer.go

@@ -3,4 +3,6 @@ package sqlx
 type Sqlizer interface {
 	Sql() string
 	SqlPretty() string
+
+	setDepth(depth uint)
 }