add InCond

where.go

@@ -144,6 +144,68 @@ func (c *NullCond) ToASTWhere() (*ast.Where, error) {
 	}, nil
 }
 
+// InConditionValue is a value expression in IN clauses.
+type InConditionValue interface {
+	ToASTInConditionValue() (ast.InCondition, error)
+}
+
+// UnnestInConditionValue is a UNNEST operator in IN clauses.
+type UnnestInConditionValue struct {
+	value interface{}
+}
+
+func (v *UnnestInConditionValue) ToASTInConditionValue() (ast.InCondition, error) {
+	value, err := internal.ToExpr(v.value)
+	if err != nil {
+		return nil, err
+	}
+	return &ast.UnnestInCondition{
+		Expr: value,
+	}, nil
+}
+
+// Unnest(v) creates `UNNEST(v)` predicate.
+func Unnest(v interface{}) *UnnestInConditionValue {
+	return &UnnestInConditionValue{
+		value: v,
+	}
+}
+
+// InCond represents IN or NOT IN predicates.
+type InCond struct {
+	lhs interface{}
+	rhs InConditionValue
+	not bool
+}
+
+// In(x, y) creates `x IN y` predicate.
+func In(x interface{}, y InConditionValue) *InCond {
+	return &InCond{lhs: x, rhs: y, not: false}
+}
+
+// In(x, y) creates `x NOT IN y` predicate.
+func NotIn(x interface{}, y InConditionValue) *InCond {
+	return &InCond{lhs: x, rhs: y, not: true}
+}
+
+func (c *InCond) ToASTWhere() (*ast.Where, error) {
+	lhs, err := internal.ToExpr(c.lhs)
+	if err != nil {
+		return nil, err
+	}
+	rhs, err := c.rhs.ToASTInConditionValue()
+	if err != nil {
+		return nil, err
+	}
+	return &ast.Where{
+		Expr: &ast.InExpr{
+			Not:   c.not,
+			Left:  lhs,
+			Right: rhs,
+		},
+	}, nil
+}
+
 // BetweenCond represents BETWEEN or NOT BETWEEN predicates.
 type BetweenCond struct {
 	arg interface{}

where_test.go

@@ -73,6 +73,16 @@ func TestIsNullAndIsNotNull(t *testing.T) {
 	testWhere(t, memeduck.IsNotNull(memeduck.Ident("fuga")), `fuga IS NOT NULL`)
 }
 
+func TestIn(t *testing.T) {
+	testWhere(t, memeduck.In(memeduck.Ident("hoge"), memeduck.Unnest(memeduck.Param("hoge"))), `hoge IN UNNEST(@hoge)`)
+	testWhere(t, memeduck.In(memeduck.Ident("hoge"), memeduck.Unnest([]string{"foo", "bar"})), `hoge IN UNNEST(ARRAY["foo", "bar"])`)
+}
+
+func TestNotIn(t *testing.T) {
+	testWhere(t, memeduck.NotIn(memeduck.Ident("hoge"), memeduck.Unnest(memeduck.Param("hoge"))), `hoge NOT IN UNNEST(@hoge)`)
+	testWhere(t, memeduck.NotIn(memeduck.Ident("hoge"), memeduck.Unnest([]string{"foo", "bar"})), `hoge NOT IN UNNEST(ARRAY["foo", "bar"])`)
+}
+
 func TestBetweenAndNotBetween(t *testing.T) {
 	testWhere(t, memeduck.Between(memeduck.Ident("hoge"), 1, 10), `hoge BETWEEN 1 AND 10`)
 	testWhere(t, memeduck.NotBetween(memeduck.Ident("hoge"), 1, 10), `hoge NOT BETWEEN 1 AND 10`)