add case insensitive like operator

connor/connor.go

@@ -40,6 +40,10 @@ func matchWith(op string, conditions, data any) (bool, error) {
 		return like(conditions, data)
 	case "_nlike":
 		return nlike(conditions, data)
+	case "_ilike":
+		return ilike(conditions, data)
+	case "_nilike":
+		return nilike(conditions, data)
 	case "_not":
 		return not(conditions, data)
 	default:

connor/ilike.go

@@ -0,0 +1,30 @@
+package connor
+
+import (
+	"strings"
+
+	"github.com/sourcenetwork/immutable"
+
+	"github.com/sourcenetwork/defradb/client"
+)
+
+// ilike is an operator which performs case insensitive string equality tests.
+func ilike(condition, data any) (bool, error) {
+	switch d := data.(type) {
+	case immutable.Option[string]:
+		if !d.HasValue() {
+			return condition == nil, nil
+		}
+		data = d.Value()
+	}
+
+	switch cn := condition.(type) {
+	case string:
+		if d, ok := data.(string); ok {
+			return like(strings.ToLower(cn), strings.ToLower(d))
+		}
+		return false, nil
+	default:
+		return false, client.NewErrUnhandledType("condition", cn)
+	}
+}

connor/ilike_test.go

@@ -0,0 +1,41 @@
+package connor
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestILike(t *testing.T) {
+	const testString = "Source Is The Glue of Web3"
+
+	// case insensitive exact match
+	result, err := ilike("source is the glue of web3", testString)
+	require.NoError(t, err)
+	require.True(t, result)
+
+	// case insensitive no match
+	result, err = ilike("source is the glue", testString)
+	require.NoError(t, err)
+	require.False(t, result)
+
+	// case insensitive match prefix
+	result, err = ilike("source%", testString)
+	require.NoError(t, err)
+	require.True(t, result)
+
+	// case insensitive match suffix
+	result, err = ilike("%web3", testString)
+	require.NoError(t, err)
+	require.True(t, result)
+
+	// case insensitive match contains
+	result, err = ilike("%glue%", testString)
+	require.NoError(t, err)
+	require.True(t, result)
+
+	// case insensitive match start and end with
+	result, err = ilike("source%web3", testString)
+	require.NoError(t, err)
+	require.True(t, result)
+}

connor/like.go

@@ -11,12 +11,12 @@ import (
 // like is an operator which performs string equality
 // tests.
 func like(condition, data any) (bool, error) {
-	switch arr := data.(type) {
+	switch d := data.(type) {
 	case immutable.Option[string]:
-		if !arr.HasValue() {
+		if !d.HasValue() {
 			return condition == nil, nil
 		}
-		data = arr.Value()
+		data = d.Value()
 	}
 
 	switch cn := condition.(type) {

connor/nilike.go

@@ -0,0 +1,15 @@
+package connor
+
+import "fmt"
+
+// nilike performs case insensitive string inequality comparisons by inverting
+// the result of the Like operator for non-error cases.
+func nilike(conditions, data any) (bool, error) {
+	m, err := ilike(conditions, data)
+	fmt.Println(m, err)
+	if err != nil {
+		return false, err
+	}
+
+	return !m, err
+}

connor/nilike_test.go

@@ -0,0 +1,41 @@
+package connor
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNILike(t *testing.T) {
+	const testString = "Source Is The Glue of Web3"
+
+	// case insensitive exact match
+	result, err := nilike("source is the glue of web3", testString)
+	require.NoError(t, err)
+	require.False(t, result)
+
+	// case insensitive no match
+	result, err = nilike("source is the glue", testString)
+	require.NoError(t, err)
+	require.True(t, result)
+
+	// case insensitive match prefix
+	result, err = nilike("source%", testString)
+	require.NoError(t, err)
+	require.False(t, result)
+
+	// case insensitive match suffix
+	result, err = nilike("%web3", testString)
+	require.NoError(t, err)
+	require.False(t, result)
+
+	// case insensitive match contains
+	result, err = nilike("%glue%", testString)
+	require.NoError(t, err)
+	require.False(t, result)
+
+	// case insensitive match start and end with
+	result, err = nilike("source%web3", testString)
+	require.NoError(t, err)
+	require.False(t, result)
+}

connor/nlike_test.go

@@ -0,0 +1,41 @@
+package connor
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNLike(t *testing.T) {
+	const testString = "Source is the glue of web3"
+
+	// exact match
+	result, err := nlike(testString, testString)
+	require.NoError(t, err)
+	require.False(t, result)
+
+	// exact match error
+	result, err = nlike("Source is the glue", testString)
+	require.NoError(t, err)
+	require.True(t, result)
+
+	// match prefix
+	result, err = nlike("Source%", testString)
+	require.NoError(t, err)
+	require.False(t, result)
+
+	// match suffix
+	result, err = nlike("%web3", testString)
+	require.NoError(t, err)
+	require.False(t, result)
+
+	// match contains
+	result, err = nlike("%glue%", testString)
+	require.NoError(t, err)
+	require.False(t, result)
+
+	// match start and end with
+	result, err = nlike("Source%web3", testString)
+	require.NoError(t, err)
+	require.False(t, result)
+}

db/fetcher/indexer_iterators.go

@@ -28,16 +28,18 @@ import (
 )
 
 const (
-	opEq    = "_eq"
-	opGt    = "_gt"
-	opGe    = "_ge"
-	opLt    = "_lt"
-	opLe    = "_le"
-	opNe    = "_ne"
-	opIn    = "_in"
-	opNin   = "_nin"
-	opLike  = "_like"
-	opNlike = "_nlike"
+	opEq     = "_eq"
+	opGt     = "_gt"
+	opGe     = "_ge"
+	opLt     = "_lt"
+	opLe     = "_le"
+	opNe     = "_ne"
+	opIn     = "_in"
+	opNin    = "_nin"
+	opLike   = "_like"
+	opNlike  = "_nlike"
+	opILike  = "_ilike"
+	opNILike = "_nilike"
 	// it's just there for composite indexes. We construct a slice of value matchers with
 	// every matcher being responsible for a corresponding field in the index to match.
 	// For some fields there might not be any criteria to match. For examples if you have
@@ -382,16 +384,18 @@ func (m *indexInArrayMatcher) Match(value any) (bool, error) {
 
 // checks if the index value satisfies the LIKE condition
 type indexLikeMatcher struct {
-	hasPrefix   bool
-	hasSuffix   bool
-	startAndEnd []string
-	isLike      bool
-	value       string
+	hasPrefix         bool
+	hasSuffix         bool
+	startAndEnd       []string
+	isLike            bool
+	isCaseInsensitive bool
+	value             string
 }
 
-func newLikeIndexCmp(filterValue string, isLike bool) (*indexLikeMatcher, error) {
+func newLikeIndexCmp(filterValue string, isLike bool, isCaseInsensitive bool) (*indexLikeMatcher, error) {
 	matcher := &indexLikeMatcher{
-		isLike: isLike,
+		isLike:            isLike,
+		isCaseInsensitive: isCaseInsensitive,
 	}
 	if len(filterValue) >= 2 {
 		if filterValue[0] == '%' {
@@ -406,7 +410,11 @@ func newLikeIndexCmp(filterValue string, isLike bool) (*indexLikeMatcher, error)
 			matcher.startAndEnd = strings.Split(filterValue, "%")
 		}
 	}
-	matcher.value = filterValue
+	if isCaseInsensitive {
+		matcher.value = strings.ToLower(filterValue)
+	} else {
+		matcher.value = filterValue
+	}
 
 	return matcher, nil
 }
@@ -417,6 +425,10 @@ func (m *indexLikeMatcher) Match(value any) (bool, error) {
 		return false, NewErrUnexpectedTypeValue[string](currentVal)
 	}
 
+	if m.isCaseInsensitive {
+		currentVal = strings.ToLower(currentVal)
+	}
+
 	return m.doesMatch(currentVal) == m.isLike, nil
 }
 
@@ -571,7 +583,7 @@ func (f *IndexFetcher) createIndexIterator() (indexIterator, error) {
 		}
 	case opIn:
 		return f.newInIndexIterator(fieldConditions, matchers)
-	case opGt, opGe, opLt, opLe, opNe, opNin, opLike, opNlike:
+	case opGt, opGe, opLt, opLe, opNe, opNin, opLike, opNlike, opILike, opNILike:
 		return &scanningIndexIterator{
 			queryResultIterator: f.newQueryResultIterator(),
 			indexKey:            f.newIndexDataStoreKey(),
@@ -627,12 +639,14 @@ func createValueMatcher(condition *fieldFilterCond) (valueMatcher, error) {
 			return nil, ErrInvalidInOperatorValue
 		}
 		return newNinIndexCmp(inArr, condition.kind, condition.op == opIn)
-	case opLike, opNlike:
+	case opLike, opNlike, opILike, opNILike:
 		strVal, ok := condition.val.(string)
 		if !ok {
 			return nil, NewErrUnexpectedTypeValue[string](condition.val)
 		}
-		return newLikeIndexCmp(strVal, condition.op == opLike)
+		isLike := condition.op == opLike || condition.op == opILike
+		isCaseInsensitive := condition.op == opILike || condition.op == opNILike
+		return newLikeIndexCmp(strVal, isLike, isCaseInsensitive)
 	case opAny:
 		return &anyMatcher{}, nil
 	}

request/graphql/schema/types/base.go

@@ -291,6 +291,14 @@ var StringOperatorBlock = gql.NewInputObject(gql.InputObjectConfig{
 			Description: nlikeStringOperatorDescription,
 			Type:        gql.String,
 		},
+		"_ilike": &gql.InputObjectFieldConfig{
+			Description: ilikeStringOperatorDescription,
+			Type:        gql.String,
+		},
+		"_nilike": &gql.InputObjectFieldConfig{
+			Description: nilikeStringOperatorDescription,
+			Type:        gql.String,
+		},
 	},
 })
 
@@ -323,6 +331,14 @@ var NotNullstringOperatorBlock = gql.NewInputObject(gql.InputObjectConfig{
 			Description: nlikeStringOperatorDescription,
 			Type:        gql.String,
 		},
+		"_ilike": &gql.InputObjectFieldConfig{
+			Description: ilikeStringOperatorDescription,
+			Type:        gql.String,
+		},
+		"_nilike": &gql.InputObjectFieldConfig{
+			Description: nilikeStringOperatorDescription,
+			Type:        gql.String,
+		},
 	},
 })
 

request/graphql/schema/types/descriptions.go

@@ -202,6 +202,16 @@ The like operator - if the target value contains the given sub-string the check
 The not-like operator - if the target value does not contain the given sub-string the check will
  pass. '%' characters may be used as wildcards, for example '_nlike: "%Ritchie"' would match on
  the string 'Quentin Tarantino'.
+`
+	ilikeStringOperatorDescription string = `
+The case insensitive like operator - if the target value contains the given case insensitive sub-string the check
+ will pass. '%' characters may be used as wildcards, for example '_like: "%ritchie"' would match on strings
+ ending in 'Ritchie'.
+`
+	nilikeStringOperatorDescription string = `
+The case insensitive not-like operator - if the target value does not contain the given case insensitive sub-string
+ the check will pass. '%' characters may be used as wildcards, for example '_nlike: "%ritchie"' would match on
+ the string 'Quentin Tarantino'.
 `
 	AndOperatorDescription string = `
 The and operator - all checks within this clause must pass in order for this check to pass.