Create a {@code this == right} expression

<p>Use expr.isNull() instead of expr.eq(null)</p>

@param right rhs of the comparison
@return this == right
353702
public BooleanExpression eq(T right) {
        if (right == null) {
            throw new IllegalArgumentException("eq(null) is not allowed. Use isNull() instead");
        } else {
            return eq(ConstantImpl.create(right));
        }
    }
765125
public BooleanExpression or(@Nullable Predicate right) {
        right = (Predicate) ExpressionUtils.extract(right);
        if (right != null) {
            return Expressions.booleanOperation(Ops.OR, mixin, right);
        } else {
            return this;
        }
    }
410757
public static Predicate or(Predicate left, Predicate right) {
        left = (Predicate) extract(left);
        right = (Predicate) extract(right);
        if (left == null) {
            return right;
        } else if (right == null) {
            return left;
        } else {
            return predicate(Ops.OR, left, right);
        }
    }
1059599
public final <A extends Number & Comparable<?>> BooleanExpression loe(Expression<A> right) {
        return Expressions.booleanOperation(Ops.LOE, mixin, right);
    }
1362697
public static Boolean ne(Object left, Object right) {
        return not(EvalHelper.isEqual(left, right, null));
    }
786921
public static Boolean eq(Object left, Object right) {
        return EvalHelper.isEqual(left, right, null);
    }
1106458
public OqlBuilder<T> newFrom(final String from) {
    if (null == from) {
      this.from = null;
    } else {
      if (Strings.contains(from.toLowerCase(), "from")) {
        this.from = from;
      } else {
        this.from = "from " + from;
      }
    }
    return this;
  }
1268375
public static <D> Predicate eq(Expression<D> left, Expression<? extends D> right) {
        return predicate(Ops.EQ, left, right);
    }
140399
@Override
    public R setValue(final R value) {
        final R result = getRight();
        setRight(value);
        return result;
    }
664976
public final BooleanExpression notIn(Expression<? extends T>... right) {
        return Expressions.booleanOperation(Ops.NOT_IN, mixin, Expressions.list(right));
    }
176374
public Formula implication(final Formula left, final Formula right) {
    if (left.type() == FALSE || right.type() == TRUE)
      return this.verum();
    if (left.type() == TRUE)
      return right;
    if (right.type() == FALSE)
      return this.not(left);
    if (left.equals(right))
      return this.verum();
    final Pair<Formula, Formula> key = new Pair<>(left, right);
    Implication implication = this.implications.get(key);
    if (implication == null) {
      implication = new Implication(left, right, this);
      this.implications.put(key, implication);
    }
    return implication;
  }
1185672
public BooleanExpression notIn(T... right) {
        if (right.length == 1) {
            return ne(right[0]);
        } else {
            return Expressions.booleanOperation(Ops.NOT_IN, mixin, ConstantImpl.create(ImmutableList.copyOf(right)));
        }
    }
1356619
public <N extends Number & Comparable<?>> NumberExpression<T> add(Expression<N> right) {
        return Expressions.numberOperation(getType(), Ops.ADD, mixin, right);
    }
534410
public Cell<C,T> right () {
		if (align == null)
			align = RIGHT;
		else {
			align |= RIGHT;
			align &= ~LEFT;
		}
		return this;
	}
1056428
public BooleanExpression ne(T right) {
        if (right == null) {
            throw new IllegalArgumentException("ne(null) is not allowed. Use isNotNull() instead");
        } else {
            return ne(ConstantImpl.create(right));
        }
    }
99372
public static Expression compare(
      final int comparisonOpcode, final Expression left, final Expression right) {
    checkArgument(
        left.resultType().equals(right.resultType()),
        "left and right must have matching types, found %s and %s",
        left.resultType(),
        right.resultType());
    checkIntComparisonOpcode(left.resultType(), comparisonOpcode);
    Features features =
        Expression.areAllCheap(left, right) ? Features.of(Feature.CHEAP) : Features.of();
    return new Expression(Type.BOOLEAN_TYPE, features) {
      @Override
      protected void doGen(CodeBuilder mv) {
        left.gen(mv);
        right.gen(mv);
        Label ifTrue = mv.newLabel();
        Label end = mv.newLabel();
        mv.ifCmp(left.resultType(), comparisonOpcode, ifTrue);
        mv.pushBoolean(false);
        mv.goTo(end);
        mv.mark(ifTrue);
        mv.pushBoolean(true);
        mv.mark(end);
      }
    };
  }
950235
public final BooleanExpression loe(T right) {
        return Expressions.booleanOperation(Ops.LOE, mixin, ConstantImpl.create(right));
    }