@param   bool $not

@return  WhereStatement|Select|Delete|Update
11008
protected function addNullCondition(bool $not): WhereStatement
    {
        $this->sql->addWhereNullCondition($this->column, $this->separator, $not);
        return $this->statement;
    }
270166
public function whereNotIn($field, $values)
    {
        foreach ($this->queries as $query) {
            $query->whereNotIn($field, $values);
        }

        return $this;
    }
1259966
public function statsOnly(bool $bool = true): Compare
    {
        $this->stats = $this->useOption('--numstat', $bool);
        return $this;
    }
1277475
protected function whereInSub($column, Closure $callback, $boolean, $not)
    {
        $type = $not ? 'NotInSub' : 'InSub';

        // To create the exists sub-select, we will actually create a query and call the
        // provided callback with the query so the developer may set any of the query
        // conditions they want for the in clause, then we'll put it in this array.
        call_user_func($callback, $query = $this->newQuery());

        $this->wheres[] = compact('type', 'column', 'query', 'boolean');

        $this->addBinding($query->getBindings(), 'where');

        return $this;
    }
264912
public function whereIntegerInRaw($column, $values, $boolean = 'and', $not = false)
    {
        $type = $not ? 'NotInRaw' : 'InRaw';

        if ($values instanceof Arrayable) {
            $values = $values->toArray();
        }

        foreach ($values as &$value) {
            $value = (int) $value;
        }

        $this->wheres[] = compact('type', 'column', 'values', 'boolean');

        return $this;
    }
1105011
public function isNull($column, string $separator = 'AND', bool $not = false)
	{
		$this->wheres[] =
		[
			'type'      => 'null',
			'column'    => $column,
			'separator' => $separator,
			'not'       => $not,
		];

		return $this;
	}
388785
public function delete_by()
    {
        $where = func_get_args();

	    $where = $this->trigger('before_delete', $where);

        $this->_set_where($where);


        if ($this->soft_delete)
        {
            $result = $this->_database->update($this->_table, array( $this->soft_delete_key => TRUE ));
        }
        else
        {
            $result = $this->_database->delete($this->_table);
        }

        $this->trigger('after_delete', $result);

        return $result;
    }
451255
public function exists($query, string $separator = 'AND', bool $not = false)
	{
		if($query instanceof Closure)
		{
			$query = new Subquery($query);
		}

		$this->wheres[] =
		[
			'type'      => 'exists',
			'query'     => $query,
			'separator' => $separator,
			'not'       => $not,
		];

		return $this;
	}
526484
public function deleteWhere(SQLPredicate $condition = null, $cascade = false) {
		//connect to database
		$this->mapper->connect();
		
		//begin transaction
		$this->mapper->beginTransaction();
		
		if ($cascade) {
			$list = $this->find($condition);
				
			foreach ($list as $entity)
				$this->delete($entity);
			
			$result = true;
		}
		else {
			$query = $this->mapper->newQuery($this->entityProfile)
			->deleteFrom($this->entityProfile->getEntityTable())
			->where($condition);
			
			//run query
			$result = $query->exec();
		}
		
		//commit
		$this->mapper->commit();
		return $result;
	}
530692
public function between($column, $value1, $value2, string $separator = 'AND', bool $not = false)
	{
		$this->wheres[] =
		[
			'type'      => 'between',
			'column'    => $column,
			'value1'    => $value1,
			'value2'    => $value2,
			'separator' => $separator,
			'not'       => $not,
		];

		return $this;
	}
741063
public function returnUpdateCol($noCol)
    {
        if ($this->stateCol($noCol)) {

            $idTable = $this->getId();
            $cols = $this->getColValues($noCol);
            $params['col'] = $noCol;
            $params['datas'] = $cols;
            return self::formatRetour($idTable, $idTable, 'updateCol', $params);
        }
        return false;
    }
43120
public function whereIn($column, $values, $boolean = 'and', $not = false)
    {
        $type = $not ? 'NotIn' : 'In';

        // If the value is a query builder instance we will assume the developer wants to
        // look for any values that exists within this given query. So we will add the
        // query accordingly so that this query is properly executed when it is run.
        if ($values instanceof self ||
            $values instanceof EloquentBuilder ||
            $values instanceof Closure) {
            [$query, $bindings] = $this->createSub($values);

            $values = [new Expression($query)];

            $this->addBinding($bindings, 'where');
        }

        // Next, if the value is Arrayable we need to cast it to its raw array form so we
        // have the underlying array value instead of an Arrayable object which is not
        // able to be added as a binding, etc. We will then add to the wheres array.
        if ($values instanceof Arrayable) {
            $values = $values->toArray();
        }

        $this->wheres[] = compact('type', 'column', 'values', 'boolean');

        // Finally we'll add a binding for each values unless that value is an expression
        // in which case we will just skip over it since it will be the query as a raw
        // string and not as a parameterized place-holder to be replaced by the PDO.
        $this->addBinding($this->cleanBindings($values), 'where');

        return $this;
    }
605839
public function whereNotIn($where, $value)
    {
        if( !is_array($value) ) {
            $value = (array) $value;
        }
        if( count($value) <= 0 ) {
            $this->where[] = array(new Expression('TRUE'));
        } else {
            $this->where[] = array($where, $value, 'NOT IN');
        }
        return $this;
    }
736369
public function notWhere($clause, $type = '$and')
    {
        if ($clause instanceof Closure) {
            $query = new static();
            $clause($query);
            $clause = $query->getWhere();

            if (empty($clause)) {
                return $this;
            }
        }

        if (! is_array($clause)) {
            throw new \InvalidArgumentException('$not statements should be Closures or arrays.');
        }

        return $this->formatWhere($type, '$not', [$clause]);
    }
487327
public function update($updateNulls = false)
    {
        // Event
        $this->triggerEvent(
            'onBefore' . ucfirst(__FUNCTION__),
            [
                'updateNulls' => &$updateNulls,
            ]
        );

        $this->triggerEvent(
            'onBeforeStore',
            [
                'updateNulls' => &$updateNulls,
            ]
        );

        // Do Action
        $this->getDataMapper()->updateOne($this, $this->getKeyName(true), $updateNulls);

        // Event
        $this->triggerEvent(
            'onAfterStore',
            [
                'updateNulls' => &$updateNulls,
            ]
        );

        $this->triggerEvent('onAfter' . ucfirst(__FUNCTION__));

        return $this;
    }
932773
function UpdateBlob($table,$column,$val,$where,$blobtype='BLOB')
	{
		return $this->Execute("UPDATE $table SET $column=? WHERE $where",array($val)) != false;
	}
41200
public function whereNotNull($column, $boolean = 'and')
    {
        if (is_null($this->where)) {
            $this->where = '(`'. $column . '` is not null)';
        } else {
            $this->where .= ' ' . $boolean .' (`' . $column .'` is not null)';
        }

        return $this;
    }