Returns sql condition for less than
@param Selectable $leftHandSide The left hand side of equality check
@param Selectable $rightHandSide The right hand side of equality check
@return Condition
966531
protected function CreateConditionLT(Selectable $leftHandSide, Selectable $rightHandSide)
    {
        return Condition::LT($this->connection, $leftHandSide, $rightHandSide);
    }
60748
public function rightJoin($table, $condition = null, $alias = null)
    {
        return $this->join($table, $condition, $alias, 'RIGHT');
    }
1032760
public function condition(Expression $left, Expression $right, $comparator, $conjunction = Cmp::CONJUNCTION_AND)
    {
        $this->getWhereStatement()->add($left, $right, $comparator, $conjunction);
        
        return $this;
    }
7321
public static Optional<Condition> createCompareCondition(final PredicateCompareRightValue compareRightValue, final Column column) {
        return compareRightValue.getExpression() instanceof SimpleExpressionSegment
                ? Optional.of(new Condition(column, ((SimpleExpressionSegment) compareRightValue.getExpression()).getSQLExpression())) : Optional.<Condition>absent();
    }
167080
public function leftJoin($fromAlias, $join, $alias, $condition = null)
    {
        $this->_dbPending[] = [
            'name' => 'leftJoin',
            'args' => [
                $fromAlias,
                $join,
                $alias,
                $condition
            ],
        ];

        return $this;
    }
183727
public static function selectQuery($tableName, $fields, $data, $condition, $connection)
    {
        $query = "";
        $columnName = "";
        
        try
        {
            $arraySize = count($data);
            if( $arraySize > 1 && $condition == NULL)
            {
                $query = "Please Supply the condition";
            }
            else
            {
                if ($condition === 'AND' || $condition === 'OR' || $condition === NULL) {
                    $columnName = self::whereAndClause($tableName, $data, $condition);
                } elseif ($condition === 'LIKE') {
                    $columnName = self::whereLikeClause($tableName, $data, $condition);
                } 
                $query =  "SELECT $fields FROM $tableName WHERE $columnName";
            }
        } catch (PDOException $e) {
            $query = $e->getMessage();
        }

        return $query;
    }
561339
protected function valueEquals($left, $right)
    {
        if ($left instanceof EqualityComparable) {
            return $left->isEqualTo($right, $this);
        } elseif ($right instanceof EqualityComparable) {
            return $right->isEqualTo($left, $this);
        }

        switch (gettype($left)) {
            case 'array':
                return $this->arrayEquals($left, $right);
            case 'object':
                return $this->objectEquals($left, $right);
        }

        return $left === $right;
    }
40058
private Boolean compareValues(Session session, Object left, Object right) {
        if (left == null) {
            if (opType == OpTypes.NOT_DISTINCT) {
                return right == null;
            }
            return null;
        }

        if (right == null) {
            return (opType == OpTypes.NOT_DISTINCT) ? Boolean.FALSE : null;
        }

        int result = nodes[LEFT].dataType.compare(left, right);

        switch (opType) {

            case OpTypes.EQUAL :
            case OpTypes.NOT_DISTINCT :
                return result == 0 ? Boolean.TRUE
                                   : Boolean.FALSE;

            case OpTypes.NOT_EQUAL :
                return result != 0 ? Boolean.TRUE
                                   : Boolean.FALSE;

            case OpTypes.GREATER :
                return result > 0 ? Boolean.TRUE
                                  : Boolean.FALSE;

            case OpTypes.GREATER_EQUAL :
                return result >= 0 ? Boolean.TRUE
                                   : Boolean.FALSE;

            case OpTypes.SMALLER_EQUAL :
                return result <= 0 ? Boolean.TRUE
                                   : Boolean.FALSE;

            case OpTypes.SMALLER :
                return result < 0 ? Boolean.TRUE
                                  : Boolean.FALSE;

            default :
                throw Error.runtimeError(ErrorCode.U_S0500, "Expression");
        }
    }
143483
private function LayoutCondition()
    {
        $sql = Access::SqlBuilder();
        $tbl = Area::Schema()->Table();
        return $sql->Equals($tbl->Field('Layout'), $sql->Value($this->layout->GetID()));
    }
316909
public function leftJoin(string $table, string $key, string $operator, string $value): SelectQueryBuilder
    {
        $this->addJoin($table, $key, $operator, $value, 'left');
        return $this;
    }
124830
@Pure /* not guaranteed, since compareTo() is invoked */
	@Inline("($1.compareTo($2) >= 0)")
	public static <C> boolean operator_greaterEqualsThan(Comparable<? super C> left, C right) {
		return left.compareTo(right) >= 0;
	}
736500
public function rightJoin($table, $leftKey, $rightKey)
	{
		$this->syntax->setJoin($table, $leftKey, $rightKey, 'right');
		return $this;
	}
716766
function SelectLimit($sql,$nrows=-1,$offset=-1,$inputarr=false, $secs=0)
	{
		$nrows = (integer) $nrows;
		$offset = (integer) $offset;
		$str = 'SELECT ';
		if ($nrows >= 0) $str .= "FIRST $nrows ";
		$str .=($offset>=0) ? "SKIP $offset " : '';

		$sql = preg_replace('/^[ \t]*select/i',$str,$sql);
		if ($secs)
			$rs = $this->CacheExecute($secs,$sql,$inputarr);
		else
			$rs = $this->Execute($sql,$inputarr);

		return $rs;
	}
222796
protected function getConditions()
    {
        $limit  = $this->getLimit();
        $offset = $this->getOffset();
        $order  = $this->getOrder();

        $sql = '';

        if (!empty($order) && is_array($order)) {
            foreach ($order as $field => $type) {
                $order[$field] = $field . ' ' . $type;
            }
            
            $sql .= ' ORDER BY '. implode(', ', $order);
        }

        if (!empty($limit) && $limit > 0) {

            $aux = ' LIMIT ';

            if (isset($offset)) {
                $aux .= $offset . ', ';
            }

            $aux .= $limit;

            $sql .= $aux;
        }

        return $sql;
    }
870069
protected function CreateConditionGTE(Selectable $leftHandSide, Selectable $rightHandSide)
    {
        return Condition::GTE($this->connection, $leftHandSide, $rightHandSide);
    }
1268375
public static <D> Predicate eq(Expression<D> left, Expression<? extends D> right) {
        return predicate(Ops.EQ, left, right);
    }
1156727
public static Optional<Condition> createInCondition(final PredicateInRightValue inRightValue, final Column column) {
        List<SQLExpression> sqlExpressions = new LinkedList<>();
        for (ExpressionSegment each : inRightValue.getSqlExpressions()) {
            if (!(each instanceof SimpleExpressionSegment)) {
                sqlExpressions.clear();
                break;
            } else {
                sqlExpressions.add(((SimpleExpressionSegment) each).getSQLExpression());
            }
        }
        return sqlExpressions.isEmpty() ? Optional.<Condition>absent() : Optional.of(new Condition(column, sqlExpressions));
    }