Range, EqNotEmpty

Author: n-r-w

README.md

@@ -33,11 +33,13 @@ sq.Case("id").When(1, 2).When(2, "text").Else(4)
 
 ## New features
 
-- Add subquery support for `WHERE` clause (e.g. `sq.Eq{"id": sq.Select("id").From("other_table")}`).
-- Add support for integer values in `CASE THEN/ELSE` clause (e.g. `sq.Case("id").When(1, 2).When(2, 3).Else(4)`).
-- Add support for aggregate functions `SUM`, `COUNT`, `AVG`, `MIN`, `MAX` (e.g. `sq.Sum(subQuery)`).
-- Add support for using slice as argument for `Column` function (e.g. `Column(sq.Expr("id = ANY(?)", []int{1,2,3}))`).
-- Add support for `IN` and `NOT IN` clause (e.g. `In("id", []int{1, 2, 3})`, `NotIn("id", subQuery)`).
+- Subquery support for `WHERE` clause (e.g. `sq.Eq{"id": sq.Select("id").From("other_table")}`).
+- Support for integer values in `CASE THEN/ELSE` clause (e.g. `sq.Case("id").When(1, 2).When(2, 3).Else(4)`).
+- Support for aggregate functions `SUM`, `COUNT`, `AVG`, `MIN`, `MAX` (e.g. `sq.Sum(subQuery)`).
+- Support for using slice as argument for `Column` function (e.g. `Column(sq.Expr("id = ANY(?)", []int{1,2,3}))`).
+- Support for `IN` and `NOT IN` clause (e.g. `In("id", []int{1, 2, 3})`, `NotIn("id", subQuery)`).
+- Range function: `sq.Range("id", 1, 10)` -> `id BETWEEN 1 AND 10`. `sq.Range("id", 1, nil)` -> `id >= 1`. `sq.Range("id", nil, 10)` -> `id <= 10`.
+- EqNotEmpty function: ignores empty and zero values in Eq map. Useful for filtering. `EqNotEmpty{"id1": 1, "name": nil, id2: 0, "desc": ""}` -> `id1 = 1`.
 
 ## Miscellaneous
 

expr.go

@@ -627,3 +627,89 @@ func (e notInExpr) ToSql() (sql string, args []any, err error) {
 
 	return sql, args, err
 }
+
+// rangeExpr helps to use BETWEEN in SQL query
+type rangeExpr struct {
+	column string
+	start  any
+	end    any
+}
+
+// Range allows to use range in SQL query
+// Ex: SelectBuilder.Where(Range("id", 1, 3)) -> "id BETWEEN 1 AND 3"
+// If start or end is nil, it will be omitted from the query.
+// Ex: SelectBuilder.Where(Range("id", 1, nil)) -> "id >= 1"
+// Ex: SelectBuilder.Where(Range("id", nil, 3)) -> "id <= 3"
+func Range(column string, start, end any) rangeExpr {
+	return rangeExpr{column, start, end}
+}
+
+// ToSql builds the query into a SQL string and bound args.
+func (e rangeExpr) ToSql() (sql string, args []any, err error) {
+	hasStart := e.start != nil && !reflect.ValueOf(e.start).IsZero()
+	hasEnd := e.end != nil && !reflect.ValueOf(e.end).IsZero()
+
+	if !hasStart && !hasEnd {
+		return "", nil, nil
+	}
+
+	var s Sqlizer
+	if hasStart && hasEnd {
+		s = Expr(fmt.Sprintf("%s BETWEEN ? AND ?", e.column), e.start, e.end)
+	} else if hasStart {
+		s = GtOrEq{e.column: e.start}
+	} else {
+		s = LtOrEq{e.column: e.end}
+	}
+
+	return s.ToSql()
+}
+
+// EqNotEmpty ignores empty and zero values in Eq map.
+// Ex: EqNotEmpty{"id1": 1, "name": nil, id2: 0, "desc": ""} -> "id1 = 1".
+type EqNotEmpty map[string]any
+
+// ToSql builds the query into a SQL string and bound args.
+func (eq EqNotEmpty) ToSql() (sql string, args []any, err error) {
+	vals := make(Eq, len(eq))
+	for k, v := range eq {
+		v = clearEmptyValue(v)
+		if v != nil {
+			vals[k] = v
+		}
+	}
+
+	return vals.ToSql()
+}
+
+// clearEmptyValue recursively clears empty and zero values in any type.
+func clearEmptyValue(v any) any {
+	if v == nil {
+		return nil
+	}
+
+	t := reflect.ValueOf(v)
+	switch t.Kind() { //nolint:exhaustive
+	case reflect.Array, reflect.Slice:
+		if t.Len() != 0 {
+			newSlice := reflect.MakeSlice(t.Type(), 0, t.Len())
+			for i := 0; i < t.Len(); i++ {
+				itemVal := clearEmptyValue(t.Index(i).Interface())
+				if itemVal != nil {
+					newSlice = reflect.Append(newSlice, t.Index(i))
+				}
+			}
+
+			if newSlice.Len() != 0 {
+				return newSlice.Interface()
+			}
+		}
+
+	default:
+		if !t.IsZero() {
+			return v
+		}
+	}
+
+	return nil
+}

expr_test.go

@@ -554,6 +554,42 @@ func TestIn(t *testing.T) {
 	assert.Equal(t, []any{[]int{1, 2, 3}}, args)
 }
 
+func Test_Range(t *testing.T) {
+	sql, args, err := Range("id", 1, 10).ToSql()
+	assert.NoError(t, err)
+	assert.Equal(t, "id BETWEEN ? AND ?", sql)
+	assert.Equal(t, []any{1, 10}, args)
+
+	sql, args, err = Range("id", 1, nil).ToSql()
+	assert.NoError(t, err)
+	assert.Equal(t, "id >= ?", sql)
+	assert.Equal(t, []any{1}, args)
+
+	sql, args, err = Range("id", nil, 10).ToSql()
+	assert.NoError(t, err)
+	assert.Equal(t, "id <= ?", sql)
+	assert.Equal(t, []any{10}, args)
+
+	sql, args, err = Range("id", nil, nil).ToSql()
+	assert.NoError(t, err)
+	assert.Equal(t, "", sql)
+	assert.Empty(t, args)
+}
+
+func Test_EqNotEmpty(t *testing.T) {
+	sql, args, err := EqNotEmpty{
+		"col1": 1,
+		"col2": 0,
+		"col3": "",
+		"col4": nil,
+		"col5": []int{2, 0, 3},
+		"col6": []any{0, 0},
+	}.ToSql()
+	assert.NoError(t, err)
+	assert.Equal(t, "col1 = ? AND col5 IN (?,?)", sql)
+	assert.Equal(t, []any{1, 2, 3}, args)
+}
+
 func ExampleEq() {
 	Select("id", "created", "first_name").From("users").Where(Eq{
 		"company": 20,