add not like condition.

@param   string  $key
@param   string  $like
@return  Samurai\Onikiri\Criteria\WhereCondition
179607
public function andNotLike($key, $like)
    {
        $value = sprintf('%s NOT LIKE ?', $key);
        return $this->andAdd($value, [$like]);
    }
855276
protected function addLikeCondition(string $pattern, bool $not): WhereStatement
    {
        $this->sql->addWhereLikeCondition($this->column, $pattern, $this->separator, $not);
        return $this->statement;
    }
1019371
function like($field, $like)
    {
        self::sql_safe($field);
        $this->where($field, 'like', $like);
    }
237224
public function orNotLike($column, $pattern)
    {
        $this->conditions[] = 'OR ' . $this->grammar->buildId($column) . ' NOT LIKE ' . $pattern;

        return $this;
    }
1019906
public function created(LikeContract $like)
    {
        if ($like->type_id == LikeType::LIKE) {
            event(new ModelWasLiked($like->likeable, $like->user_id));
            app(LikeableServiceContract::class)->incrementLikesCount($like->likeable);
        } else {
            event(new ModelWasDisliked($like->likeable, $like->user_id));
            app(LikeableServiceContract::class)->incrementDislikesCount($like->likeable);
        }
    }
974103
public function addWhereFieldIsNotLike($field, $like_value, $left_any = true, $right_any = true, $table = ''): self
    {
        if (!$table) {
            $table = $this->getDbTableName();
        }

        $this->addWhereFieldAsString('`'. $table .'`.`'. $field .'` NOT LIKE "'. ($left_any ? '%' : '') . sql_prepare($like_value, true) . ($right_any ? '%' : '') .'"');

        return $this;
    }
553873
public function where_like($field, $match, $joker='both', $not=FALSE){
        if($this->where != ''){$this->where.='AND ';}
        $this->like($field, $match, $joker, $not);
    }
140676
protected function _whereNotLike($expr, $like)
    {
        if ($like === '') {
            return $this;
        }

        if (is_array($expr)) {
            $and = [];
            /** @noinspection ForeachSourceInspection */
            foreach ($expr as $v) {
                $and[] = [$v => ['$not' => new Regex($like, 'i')]];
            }
            $this->_filters[] = ['$and' => $and];
        } else {
            $this->_filters[] = [$expr => ['$not' => new Regex($like, 'i')]];
        }

        return $this;
    }
123408
public function addKey($key, $after=null) {

        // Detect duplicates first
        if ($this->getKey($key->getName())) {
            throw new coding_exception('Duplicate key '.$key->getName().' specified in table '.$this->getName());
        }

        // Make sure there are no indexes with the key column specs because they would collide.
        $newfields = $key->getFields();
        $allindexes = $this->getIndexes();
        foreach ($allindexes as $index) {
            $fields = $index->getFields();
            if ($fields === $newfields) {
                throw new coding_exception('Index '.$index->getName().' collides with key'.$key->getName().' specified in table '.$this->getName());
            }
        }

        // Calculate the previous and next keys
        $prevkey = null;
        $nextkey = null;

        if (!$after) {
            $allkeys = $this->getKeys();
            if (!empty($allkeys)) {
                end($allkeys);
                $prevkey = $allkeys[key($allkeys)];
            }
        } else {
            $prevkey = $this->getKey($after);
        }
        if ($prevkey && $prevkey->getNext()) {
            $nextkey = $this->getKey($prevkey->getNext());
        }

        // Set current key previous and next attributes
        if ($prevkey) {
            $key->setPrevious($prevkey->getName());
            $prevkey->setNext($key->getName());
        }
        if ($nextkey) {
            $key->setNext($nextkey->getName());
            $nextkey->setPrevious($key->getName());
        }
        // Some more attributes
        $key->setLoaded(true);
        $key->setChanged(true);
        // Add the new key
        $this->keys[] = $key;
        // Reorder the keys
        $this->orderKeys($this->keys);
        // Recalculate the hash
        $this->calculateHash(true);
        // We have one new field, so the table has changed
        $this->setChanged(true);
    }
150373
public function addByKey(string $key): Preference
    {
        $preference = new SimplePreference($key);

        $this->add($preference);

        return $preference;
    }
299786
protected function normalizeConditionKeyword($key)
    {
        static $map = [
            'AND' => '$and',
            'OR' => '$or',
            'IN' => '$in',
            'NOT IN' => '$nin',
        ];
        $matchKey = strtoupper($key);
        if (array_key_exists($matchKey, $map)) {
            return $map[$matchKey];
        }
        return $key;
    }
583291
public function addWhereLike($column, $keyword, $escape = true, $operator = 'AND', $isLike = true)
    {
        if (empty($keyword)) {
            return $this;
        }
        if ($escape) {
            $keyword = '%' . strtr($keyword, ['%' => '\%', '_' => '\_', '\\' => '\\\\']) . '%';
        }
        $bk = $this->getBindKey();
        $condition = $this->quoteColumnName($column)
            . ($isLike ? " LIKE " : " NOT LIKE ")
            . $bk;
        return $this->addWhere($condition, [
            $bk => $keyword,
        ], $operator);
    }
587573
public function filterByPrimaryKey($key)
    {
        $this->addUsingAlias(SkillVersionTableMap::COL_ID, $key[0], Criteria::EQUAL);
        $this->addUsingAlias(SkillVersionTableMap::COL_VERSION, $key[1], Criteria::EQUAL);

        return $this;
    }
935085
public function andNotLike($column, $pattern)
    {
        $this->conditions[] = 'AND ' . $this->grammar->buildId($column) . ' NOT LIKE ' . $pattern;

        return $this;
    }
200383
public static function where(string $key, string $value){

            return function($compare) use ($key, $value){

                return (@$compare[$key] == $value);

            };

        }
271626
protected function skipKey(string $key): bool
    {
        if (!empty($this->search)) {
            foreach ($this->search as $search) {
                if ($this->hasWildCard($search)) {
                    $search = substr($search, 0,-2);
                    if (substr($key, 0, mb_strlen($search)) === $search) {
                        return false;
                    }
                } elseif ($search === $key) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
1321538
public function allowedSetting($key = null)
    {
        if (!is_null($key)) {
            return $this->settings()->getAllowed($key);
        }

        return $this->settings()->allAllowed();
    }