Returns sql condition for none equality
@param Selectable $leftHandSide The left hand side of none equality check
@param Selectable $rightHandSide The right hand side of none equality check
@return Condition
357355
protected function CreateConditionEqualsNot(Selectable $leftHandSide, Selectable $rightHandSide)
    {
        return Condition::EqualsNot($this->connection, $leftHandSide, $rightHandSide);
    }
558878
function RightJoin(Table $table, Condition $condition, $prepend = false)
    {
        return $this->Join($table, JoinType::Right(), $condition, $prepend);
    }
330065
public QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder) throws SQLException {
		addJoinInfo(JoinType.LEFT, null, null, joinedQueryBuilder, JoinWhereOperation.OR);
		return this;
	}
1287216
protected function queryBetween($left, $right, $leftIncluded = false, $rightIncluded = false)
    {
        $positionColumn = $this->getOrderColumnName();

        $leftOperator = $leftIncluded ? '>=' : '>';
        $rightOperator = $rightIncluded ? '<=' : '<';

        $query = $this->newPivotQuery();

        return $query->where($positionColumn, $leftOperator, $left)->where($positionColumn, $rightOperator, $right);
    }
1080108
protected function CreateConditionGT(Selectable $leftHandSide, Selectable $rightHandSide)
    {
        return Condition::GT($this->connection, $leftHandSide, $rightHandSide);
    }
1130212
function hasRightSideContent() {
            var walker = new TreeWalker(container, parentBlock), node;
            var nonEmptyElementsMap = editor.schema.getNonEmptyElements();

            while ((node = walker.next())) {
              if (nonEmptyElementsMap[node.nodeName.toLowerCase()] || node.length > 0) {
                return true;
              }
            }
          }
721523
protected function deepMerge($leftSide, $rightSide)
    {
        if (!is_array($rightSide)) {
            
            return $rightSide;
        }
        
        foreach ($rightSide as $k => $v) {
            // no conflict
            if (!array_key_exists($k, $leftSide)) {

                $leftSide[$k] = $v;
                continue;
            }
            
            $leftSide[$k] = $this->deepMerge($leftSide[$k], $v);
        }
        
        return $leftSide;
    }
1048141
public function leftJoin($table, $condition = null, $alias = null)
    {
        return $this->join($table, $condition, $alias, 'LEFT');
    }
870069
protected function CreateConditionGTE(Selectable $leftHandSide, Selectable $rightHandSide)
    {
        return Condition::GTE($this->connection, $leftHandSide, $rightHandSide);
    }
299914
public function having($left, $right, $comparator = Cmp::EQ, $conjunction = Cmp::CONJUNCTION_AND)
    {
        $left = ($left instanceof Expression) ? $left : new Expr\Column($left);
        $right = ($right instanceof Expression) ? $right : new Expr\Parameter($right);
        
        return $this->addHavingCondition($left, $right, $comparator, $conjunction);
    }
167080
public function leftJoin($fromAlias, $join, $alias, $condition = null)
    {
        $this->_dbPending[] = [
            'name' => 'leftJoin',
            'args' => [
                $fromAlias,
                $join,
                $alias,
                $condition
            ],
        ];

        return $this;
    }
687813
protected function compare($left, $operator, $right)
    {
        switch ($operator) {
            case '<':
                return $left < $right;
            case '>':
                return $left > $right;
            case '<=':
                return $left <= $right;
            case '>=':
                return $left >= $right;
            case '!=':
            case '<>':
                return $left != $right;
            case '=':
                return $left == $right;
            case 'is':
                return $left === $right;
            case 'is not':
                return $left !== $right;
            default:
                throw new InvalidArgumentException("Unknown operator '$operator");
        }
    }
915569
public function selectHandle($fields = null, $where = null, $orderBy = null, $limit = null): ?\PDOStatement
    {
        // 执行前置钩子
        $ret = $this->before('Select', $fields, $where, $orderBy, $limit);
        if ($ret === self::INTERRUPT) {
            return null;
        }

        //修正请求参数
        list($fields, $where, $orderBy, $limit) = $ret;

        $this->statement->selectHandle($fields, $where, $orderBy, $limit);
        try {
            $this->statement->create();
        } catch (MysqlException $e) {
            trigger_error('获取查询句柄时出错:' . $e->getMessage(), E_USER_ERROR);
        }

        // 查询结果, 执行后置钩子
        return $this->after('Select', parent::queryHandle($this->statement));
    }
764180
def __check_left_side_conflict(x, y, dfs_data):
    """"""
    l = dfs_data['FG']['l']
    w, z = dfs_data['LF'][l]
    return __check_conflict_fronds(x, y, w, z, dfs_data)
976952
public function equalFields($left, $right)
    {
        $wrapIdentifier = function ($field) {
            if ($field instanceof ExpressionInterface) {
                return $field;
            }

            return new IdentifierExpression($field);
        };

        return $this->eq($wrapIdentifier($left), $wrapIdentifier($right));
    }
678494
public static int compare(Date left, String right) throws PageException {
	if (Decision.isNumber(right)) return compare(left.getTime() / 1000, Caster.toDoubleValue(right));
	DateTime dt = DateCaster.toDateAdvanced(right, DateCaster.CONVERTING_TYPE_OFFSET, null, null);
	if (dt != null) {
	    return compare(left.getTime() / 1000, dt.getTime() / 1000);
	}
	return Caster.toString(left).compareToIgnoreCase(right);
    }
231950
public function orNotBetween($column, $left, $right)
    {
        $this->conditions[] = 'OR ' . $this->grammar->buildId($column) . ' NOT BETWEEN ' . $left . ' AND ' . $right;

        return $this;
    }