Create a {@code this in right} expression

@param right rhs of the comparison
@return this in right
421565
public BooleanExpression in(Expression<? extends T>... right) {
        return Expressions.booleanOperation(Ops.IN, mixin, Expressions.set(right));
    }
1079267
public static <L, R> Either<L, R> create(L l, R r) {
		if (l == null && r != null) {
			return createRight(r);
		} else if (l != null && r == null) {
			return createLeft(l);
		} else {
			if (l == null) {
				throw new IllegalArgumentException("Both arguments were null.");
			} else {
				throw new IllegalArgumentException("Both arguments were non-null: " + l + " " + r);
			}
		}
	}
566383
public static Object add(Object left, Object right) {
        return InfixOpNode.add(left, right, null);
    }
463025
@Deprecated
    public static Criteria create(String left, String operator, String right) {
        Criteria criteria = new Criteria(ValueNode.toValueNode(left));
        criteria.criteriaType = RelationalOperator.fromString(operator);
        criteria.right = ValueNode.toValueNode(right);
        return criteria;
    }
907805
public final BooleanExpression notIn(CollectionExpression<?,? extends T> right) {
        return Expressions.booleanOperation(Ops.NOT_IN, mixin, right);
    }
1281134
public BooleanBuilder and(@Nullable Predicate right) {
        if (right != null) {
            if (predicate == null) {
                predicate = right;
            } else {
                predicate = ExpressionUtils.and(predicate, right);
            }
        }
        return this;
    }
89596
public final BooleanExpression loe(Expression<T> right) {
        return Expressions.booleanOperation(Ops.LOE, mixin, right);
    }
962652
public static BooleanIsNotEqual isNotEqual(ComparableExpression<Boolean> left, ComparableExpression<Boolean> right) {
        return new BooleanIsNotEqual(left, right);
    }
670497
public static <L, R> Either<L, R> rightOf(R reference) {
        require(reference != null, "Expected non-null reference");
        return new Right<>(reference);
    }
711492
public static <L, R> Either<L, R> Right(R value) {
		return new Right<L, R>(value);
	}
565334
public BooleanExpression gt(Expression<T> right) {
        return Expressions.booleanOperation(Ops.GT, mixin, right);
    }
1252968
public JcString right(int n) {
		JcNumber right = new JcNumber(n, this, OPERATOR.Common.COMMA_SEPARATOR);
		SubString ret = new SubString(null, right,
				new FunctionInstance(FUNCTION.String.RIGHT, 2));
		QueryRecorder.recordInvocationConditional(this, "right", ret, QueryRecorder.literal(n));
		return ret;
	}
1169270
public void addAll(IntBitRelation right) {
        int i, max;

        max = right.line.length;
        for (i = 0; i < max; i++) {
            if (right.line[i] != null) {
                add(i, right.line[i]);
            }
        }
    }
948745
@Override
    public BooleanExpression ne(Expression<? super T> right) {
        if (right instanceof RelationalPath) {
            return primaryKeyOperation(Ops.NE, primaryKey, ((RelationalPath) right).getPrimaryKey());
        } else {
            return super.ne(right);
        }
    }
288061
public static And and(Expression<Boolean> left, Expression<Boolean> right) {
        return new And(left, right);
    }
956133
public static PredicateDef cmpEq(Expression left, Expression right) {
		return cmp(CompareOperation.EQ, left, right);
	}
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;
  }