add join

sqlx/join.go

@@ -0,0 +1,67 @@
+package sqlx
+
+import (
+	"fmt"
+	"strings"
+)
+
+type JoinClause struct {
+	method *string
+	table  string
+	where  *WhereClause
+}
+
+func LeftJoin(table string, predicate any) *JoinClause {
+	method := "LEFT"
+	return &JoinClause{&method, table, Where(predicate)}
+}
+
+func LeftOuterJoin(table string, predicate any) *JoinClause {
+	method := "LEFT OUTER"
+	return &JoinClause{&method, table, Where(predicate)}
+}
+
+func (self *JoinClause) And(predicate any) *JoinClause {
+	self.where.And(predicate)
+	return self
+}
+
+func (self *JoinClause) Or(predicate any) *JoinClause {
+	self.where.Or(predicate)
+	return self
+}
+
+func (self JoinClause) Sql() string {
+	parts := []string{}
+
+	if self.method != nil {
+		parts = append(parts, *self.method)
+	}
+
+	parts = append(parts, "JOIN", self.table, "ON")
+	parts = append(parts, self.where.Sql())
+	return strings.Join(parts, " ")
+}
+
+func (self JoinClause) SqlPretty(indent string) string {
+	parts := []string{}
+
+	if self.method != nil {
+		parts = append(parts, fmt.Sprintf("%s JOIN %s", *self.method, self.table))
+	} else {
+		parts = append(parts, fmt.Sprintf("JOIN %s", self.table))
+	}
+
+	lines := strings.Split(self.where.SqlPretty(indent), "\n")
+	parts = append(parts, indent+"ON "+lines[0])
+
+	for _, line := range lines[1:] {
+		parts = append(parts, indent+line)
+	}
+
+	return strings.Join(parts, "\n")
+}
+
+func (self *JoinClause) setDepth(_ uint) {
+
+}

sqlx/select.go

@@ -10,6 +10,7 @@ type SelectStatement struct {
 	columns Columns
 	from    Sqlizer
 	where   *WhereClause
+	joins   []Sqlizer
 	groupBy Sqlizer
 	orderBy Sqlizer
 	limit   Sqlizer
@@ -26,6 +27,7 @@ func Select(columns ...any) *SelectStatement {
 	return &SelectStatement{
 		depth:   0,
 		columns: cols,
+		joins:   []Sqlizer{},
 	}
 }
 
@@ -39,6 +41,11 @@ func (self *SelectStatement) From(from any) *SelectStatement {
 	return self
 }
 
+func (self *SelectStatement) Join(join Sqlizer) *SelectStatement {
+	self.joins = append(self.joins, join)
+	return self
+}
+
 func (self *SelectStatement) Where(predicate any) *SelectStatement {
 	self.where = Where(predicate)
 	return self
@@ -93,6 +100,10 @@ func (self SelectStatement) Sql() string {
 		parts = append(parts, "FROM", self.from.Sql())
 	}
 
+	for _, join := range self.joins {
+		parts = append(parts, join.Sql())
+	}
+
 	if self.where != nil {
 		parts = append(parts, "WHERE", self.where.Sql())
 	}
@@ -144,6 +155,11 @@ func (self SelectStatement) SqlPretty(indent string) string {
 		parts = append(parts, lines[1:]...)
 	}
 
+	for _, join := range self.joins {
+		lines := strings.Split(join.SqlPretty(indent), "\n")
+		parts = append(parts, lines...)
+	}
+
 	if self.where != nil {
 		lines := strings.Split(self.where.SqlPretty(indent), "\n")
 		parts = append(parts, "WHERE "+lines[0])

sqlx/select_test.go

@@ -166,6 +166,40 @@ func TestSelect(t *testing.T) {
 		})
 	})
 
+	t.Run("join", func(t *testing.T) {
+		t.Run("left", func(t *testing.T) {
+			expected, err := os.ReadFile("./testcases/select/left_join.sql")
+
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			sql := sqlx.Select("*").From("a").Join(
+				sqlx.LeftJoin("b", "a.id = b.id").And("b.deleted_at IS NULL"),
+			).Sql()
+
+			if sql != strings.TrimSuffix(string(expected), "\n") {
+				t.Fatalf(sql)
+			}
+		})
+
+		t.Run("left outer", func(t *testing.T) {
+			expected, err := os.ReadFile("./testcases/select/left_outer_join.sql")
+
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			sql := sqlx.Select("*").From("a").Join(
+				sqlx.LeftOuterJoin("b", "a.id = b.id").And("b.deleted_at IS NULL"),
+			).Sql()
+
+			if sql != strings.TrimSuffix(string(expected), "\n") {
+				t.Fatalf(sql)
+			}
+		})
+	})
+
 	t.Run("group by", func(t *testing.T) {
 		expected, err := os.ReadFile("./testcases/select/group_by.sql")
 
@@ -399,6 +433,40 @@ func TestSelect(t *testing.T) {
 			})
 		})
 
+		t.Run("join", func(t *testing.T) {
+			t.Run("left", func(t *testing.T) {
+				expected, err := os.ReadFile("./testcases/select/left_join_pretty.sql")
+
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				sql := sqlx.Select("*").From("a").Join(
+					sqlx.LeftJoin("b", "a.id = b.id").And("b.deleted_at IS NULL"),
+				).SqlPretty("    ")
+
+				if sql != strings.TrimSuffix(string(expected), "\n") {
+					t.Fatalf(sql)
+				}
+			})
+
+			t.Run("left outer", func(t *testing.T) {
+				expected, err := os.ReadFile("./testcases/select/left_outer_join_pretty.sql")
+
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				sql := sqlx.Select("*").From("a").Join(
+					sqlx.LeftOuterJoin("b", "a.id = b.id").And("b.deleted_at IS NULL"),
+				).SqlPretty("    ")
+
+				if sql != strings.TrimSuffix(string(expected), "\n") {
+					t.Fatalf(sql)
+				}
+			})
+		})
+
 		t.Run("group by", func(t *testing.T) {
 			expected, err := os.ReadFile("./testcases/select/group_by_pretty.sql")
 

sqlx/testcases/select/left_join.sql

@@ -0,0 +1 @@
+SELECT * FROM a LEFT JOIN b ON a.id = b.id AND b.deleted_at IS NULL;

sqlx/testcases/select/left_join_pretty.sql

@@ -0,0 +1,6 @@
+SELECT
+    *
+FROM a
+LEFT JOIN b
+    ON a.id = b.id
+    AND b.deleted_at IS NULL;

sqlx/testcases/select/left_outer_join.sql

@@ -0,0 +1 @@
+SELECT * FROM a LEFT OUTER JOIN b ON a.id = b.id AND b.deleted_at IS NULL;

sqlx/testcases/select/left_outer_join_pretty.sql

@@ -0,0 +1,6 @@
+SELECT
+    *
+FROM a
+LEFT OUTER JOIN b
+    ON a.id = b.id
+    AND b.deleted_at IS NULL;