分库分表：NOT 支持

[flycash]

仅限中文

使用场景

NOT 的支持和 AND，OR 不太一样。对于 AND 和 OR 来说，目前可以预期的规则都是 AND 取交集，OR 取并集。NOT 看上去和 AND 和 OR 类似，但是实际上很不一样。

对于范围查询来说，假如说我们的分库分表规则是按照每100来分，那么 NOT(user_id >= 200) 等价于 (user_id <200)。这在范围查询里面是可以确定命中的表是 user_tab_0 和 user_tab_1 。

但是在哈希里面则不一样，比如说 %3 分库分表，那么 NOT(user_id = 1) 应该是广播。因为我们可以预期 user_id 可以是除了 1 以外的任何值，那么肯定是分散在所有的表里面。

因此 NOT 是一个和分库分表算法相关的东西。

[flycash]

暂时挂起，我需要一个统一的设计

[flycash]

这个问题和 #168 是一样的，我们需要在具体实现里面处理这种操作符。

[flycash]

需要先解决 #168

[Stone-afk]

简单的实现如下

func (s *ShardingSelector[T]) findDstByPredicate(ctx context.Context, pre Predicate) (sharding.Result, error) {
	switch pre.op {
	case opAnd:
		left, err := s.findDstByPredicate(ctx, pre.left.(Predicate))
		if err != nil {
			return sharding.EmptyResult, err
		}
		right, err := s.findDstByPredicate(ctx, pre.right.(Predicate))
		if err != nil {
			return sharding.EmptyResult, err
		}
		return s.mergeAnd(left, right), nil
	case opOr:
		left, err := s.findDstByPredicate(ctx, pre.left.(Predicate))
		if err != nil {
			return sharding.EmptyResult, err
		}
		right, err := s.findDstByPredicate(ctx, pre.right.(Predicate))
		if err != nil {
			return sharding.EmptyResult, err
		}
		return s.mergeOR(left, right), nil
	case opIn:
		col := pre.left.(Column)
		right := pre.right.(values)
		var results []sharding.Result
		for _, val := range right.data {
			res, err := s.meta.ShardingAlgorithm.Sharding(ctx,
				sharding.Request{Op: opEQ, SkValues: map[string]any{col.name: val}})
			if err != nil {
				return sharding.EmptyResult, err
			}
			results = append(results, res)
		}
		return s.mergeIN(results), nil
	case opNotIN:
		col := pre.left.(Column)
		right := pre.right.(values)
		var results []sharding.Result
		for _, val := range right.data {
			res, err := s.meta.ShardingAlgorithm.Sharding(ctx,
				sharding.Request{Op: opNEQ, SkValues: map[string]any{col.name: val}})
			if err != nil {
				return sharding.EmptyResult, err
			}
			results = append(results, res)
		}
		return s.mergeNotIN(results), nil
	case opNot:
		rightPre := pre.right.(Predicate)
		//col, isCol := rightPre.left.(Column)
		switch exp := rightPre.left.(type) {
		case Column:
			right, ok := rightPre.right.(valueExpr)
			if !ok {
				return sharding.EmptyResult, errs.ErrUnsupportedTooComplexQuery
			}
			return s.meta.ShardingAlgorithm.Sharding(ctx,
				sharding.Request{Op: pre.op, SkValues: map[string]any{exp.name: right.val}})
		case Predicate:
			// 是否需要考虑 多重条件嵌套的情况
			//return s.findDstByPredicate(ctx, rightPre)
		default:
			return sharding.EmptyResult, errs.ErrUnsupportedTooComplexQuery
		}
	case opEQ, opGT, opLT, opGTEQ, opLTEQ:
		col, isCol := pre.left.(Column)
		right, isVals := pre.right.(valueExpr)
		if !isCol || !isVals {
			return sharding.EmptyResult, errs.ErrUnsupportedTooComplexQuery
		}
		return s.meta.ShardingAlgorithm.Sharding(ctx,
			sharding.Request{Op: pre.op, SkValues: map[string]any{col.name: right.val}})
	default:
		return sharding.EmptyResult, errs.NewUnsupportedOperatorError(pre.op.Text)
	}
}

[Stone-afk]

Not 其实可以很复杂，里面可以嵌套多个查询条件，对于这个处理有没有什么好的想法 @flycash

[flycash]

并没有太好的办法。也是跟具体的分库分表算法有关的。比如说在哈希里面，即便 NOT C 的 C 是一个复合条件，你也比较有一个一致的算法来判断是取反，还是广播。

而对于范围就比较容易，NOT C 中 C 确定的取反就可以了。

你有啥好的想法吗？我之前去看 shardingsphere 之类的都是差不多这种策略。你可以看看 shardingsphere 和 vitess 是如何处理的。类似的分布式关系型数据库 TiDB 也会有类似的场景，但是这部分我没有深入了解过。

[Stone-afk]

我倾向于用一个函数将not条件取反，然后在求sharding， 例如将 NOT(user_id >= 200) 变成 user_id < 200, NOT((user_id >= 200) OR (user_id < 600)) 变成 (user_id < 200) OR (user_id >= 600)

[Stone-afk]

	case opNot:
		rPre, err := s.negatePredicate(pre.right.(Predicate))
		if err != nil {
			return sharding.EmptyResult, err
		}
		return s.findDstByPredicate(ctx, rPre)

[Stone-afk]

func (s *ShardingSelector[T]) negatePredicate(pre Predicate) (Predicate, error) {
	switch pre.op {
	case opAnd, opOr:
		left, err := s.negatePredicate(pre.left.(Predicate))
		if err != nil {
			return EmptyPredicate, err
		}
		right, err := s.negatePredicate(pre.right.(Predicate))
		if err != nil {
			return EmptyPredicate, err
		}
		return Predicate{left: left, op: pre.op, right: right}, nil
	case opEQ:
		return Predicate{left: pre.left, op: opNEQ, right: pre.right}, nil
	case opGT:
		return Predicate{left: pre.left, op: opLTEQ, right: pre.right}, nil
	case opLT:
		return Predicate{left: pre.left, op: opGTEQ, right: pre.right}, nil
	case opGTEQ:
		return Predicate{left: pre.left, op: opLT, right: pre.right}, nil
	case opLTEQ:
		return Predicate{left: pre.left, op: opGT, right: pre.right}, nil
	default:
		return EmptyPredicate, errs.NewUnsupportedOperatorError(pre.op.Text)
	}
}

[flycash]

我草这个思路貌似可以啊。比较操作符都好办，between 貌似也没什么难度，NOT IN 呢？还有虽然我现在不考虑支持，就是子查询的那种 NOT EXIST，>= ALL 之类的这种计算反条件有点恶心。

[Stone-afk]

NOT IN 不直接可以用吗，防呆不防傻吧。还有 NOT EXIST 和 >= ALL 我觉得有点太复杂了