From 938c01b9b22d6b2b06d1b2925268e10cf51ed357 Mon Sep 17 00:00:00 2001
From: zer0sub <zer0.sub@protonmail.com>
Date: Sun, 2 Jun 2019 13:43:43 +0200
Subject: [PATCH] Support for pattern matching operators (LIKE, SIMILAR TO).

---
 sqlbuilder/string_expression.go      | 21 +++++++++++++++++++++
 sqlbuilder/string_expression_test.go | 20 ++++++++++++++++++++
 tests/types_test.go                  |  4 ++++
 3 files changed, 45 insertions(+)

diff --git a/sqlbuilder/string_expression.go b/sqlbuilder/string_expression.go
index ad6aee8..e45f49a 100644
--- a/sqlbuilder/string_expression.go
+++ b/sqlbuilder/string_expression.go
@@ -14,6 +14,11 @@ type StringExpression interface {
 	GT_EQ(rhs StringExpression) BoolExpression
 
 	CONCAT(rhs expression) StringExpression
+
+	LIKE(pattern StringExpression) BoolExpression
+	NOT_LIKE(pattern StringExpression) BoolExpression
+	SIMILAR_TO(pattern StringExpression) BoolExpression
+	NOT_SIMILAR_TO(pattern StringExpression) BoolExpression
 }
 
 type stringInterfaceImpl struct {
@@ -56,6 +61,22 @@ func (s *stringInterfaceImpl) CONCAT(rhs expression) StringExpression {
 	return newBinaryStringExpression(s.parent, rhs, "||")
 }
 
+func (s *stringInterfaceImpl) LIKE(pattern StringExpression) BoolExpression {
+	return newBinaryBoolExpression(s.parent, pattern, "LIKE")
+}
+
+func (s *stringInterfaceImpl) NOT_LIKE(pattern StringExpression) BoolExpression {
+	return newBinaryBoolExpression(s.parent, pattern, "NOT LIKE")
+}
+
+func (s *stringInterfaceImpl) SIMILAR_TO(pattern StringExpression) BoolExpression {
+	return newBinaryBoolExpression(s.parent, pattern, "SIMILAR TO")
+}
+
+func (s *stringInterfaceImpl) NOT_SIMILAR_TO(pattern StringExpression) BoolExpression {
+	return newBinaryBoolExpression(s.parent, pattern, "NOT SIMILAR TO")
+}
+
 //---------------------------------------------------//
 type binaryStringExpression struct {
 	expressionInterfaceImpl
diff --git a/sqlbuilder/string_expression_test.go b/sqlbuilder/string_expression_test.go
index 57b1eca..a697a53 100644
--- a/sqlbuilder/string_expression_test.go
+++ b/sqlbuilder/string_expression_test.go
@@ -45,3 +45,23 @@ func TestStringCONCAT(t *testing.T) {
 	assertExpressionSerialize(t, table3StrCol.CONCAT(table2ColStr), "(table3.col2 || table2.colStr)")
 	assertExpressionSerialize(t, table3StrCol.CONCAT(String("JOHN")), "(table3.col2 || $1)", "JOHN")
 }
+
+func TestStringLIKE(t *testing.T) {
+	assertExpressionSerialize(t, table3StrCol.LIKE(table2ColStr), "(table3.col2 LIKE table2.colStr)")
+	assertExpressionSerialize(t, table3StrCol.LIKE(String("JOHN")), "(table3.col2 LIKE $1)", "JOHN")
+}
+
+func TestStringNOT_LIKE(t *testing.T) {
+	assertExpressionSerialize(t, table3StrCol.NOT_LIKE(table2ColStr), "(table3.col2 NOT LIKE table2.colStr)")
+	assertExpressionSerialize(t, table3StrCol.NOT_LIKE(String("JOHN")), "(table3.col2 NOT LIKE $1)", "JOHN")
+}
+
+func TestStringSIMILAR_TO(t *testing.T) {
+	assertExpressionSerialize(t, table3StrCol.SIMILAR_TO(table2ColStr), "(table3.col2 SIMILAR TO table2.colStr)")
+	assertExpressionSerialize(t, table3StrCol.SIMILAR_TO(String("JOHN")), "(table3.col2 SIMILAR TO $1)", "JOHN")
+}
+
+func TestStringNOT_SIMILAR_TO(t *testing.T) {
+	assertExpressionSerialize(t, table3StrCol.NOT_SIMILAR_TO(table2ColStr), "(table3.col2 NOT SIMILAR TO table2.colStr)")
+	assertExpressionSerialize(t, table3StrCol.NOT_SIMILAR_TO(String("JOHN")), "(table3.col2 NOT SIMILAR TO $1)", "JOHN")
+}
diff --git a/tests/types_test.go b/tests/types_test.go
index 68cad95..0e894fd 100644
--- a/tests/types_test.go
+++ b/tests/types_test.go
@@ -41,6 +41,10 @@ func TestStringOperators(t *testing.T) {
 		AllTypes.Text.LT_EQ(String("Text")),
 		AllTypes.Text.CONCAT(String("text2")),
 		AllTypes.Text.CONCAT(Int(11)),
+		AllTypes.Text.LIKE(String("abc")),
+		AllTypes.Text.NOT_LIKE(String("_b_")),
+		AllTypes.Text.SIMILAR_TO(String("%(b|d)%")),
+		AllTypes.Text.NOT_SIMILAR_TO(String("(b|c)%")),
 
 		BIT_LENGTH(AllTypes.Text),
 		CHAR_LENGTH(AllTypes.Character),