Logical opposite of `where`.
518830
def wherenot(self, fieldname, value):
        
        return self.where(fieldname, value, negate=True)
1075027
def query_under_condition(condition, kind='2'):
        '''
        
        '''
        if DB_CFG['kind'] == 's':
            return TabPost.select().where(
                (TabPost.kind == kind) & (TabPost.valid == 1)
            ).order_by(
                TabPost.time_update.desc()
            )

        return TabPost.select().where(
            (TabPost.kind == kind) &
            (TabPost.valid == 1) &
            TabPost.extinfo.contains(condition)
        ).order_by(TabPost.time_update.desc())
931315
public final void mWHERE() throws RecognitionException {
		try {
			int _type = WHERE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// hql.g:71:7: ( 'where' )
			// hql.g:71:9: 'where'
			{
			match("where"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
229757
private Where<ExtendedRelation, Long> addToWhere(
			QueryBuilder<ExtendedRelation, Long> qb,
			Where<ExtendedRelation, Long> where) {
		if (where == null) {
			where = qb.where();
		} else {
			where.and();
		}
		return where;
	}
1021587
def search(self, query: Optional[dict] = None, offset: Optional[int] = None,
               limit: Optional[int] = None,
               order_by: Union[None, list, tuple] = None) -> Sequence['IModel']:
        """"""
        raise NotImplementedError
668464
def logical_not(f):  # function factory
    '''
    '''
    def f_not(arr):
        return np.logical_not(f(arr))
    f_not.__name__ = "not_" + f.__name__
    return f_not
263487
def where(self, key, operator, value):
        
        self.__store_query({"key": key, "operator": operator, "value": value})
        return self
14119
def _set_where(self):
        
        foreign = self.get_foreign_key()

        self._query.where(foreign, "=", self._parent.get_key())

        return self
215636
def _nest_wheres_for_scope(self, query, where_counts):
        
        # Here, we totally remove all of the where clauses since we are going to
        # rebuild them as nested queries by slicing the groups of wheres into
        # their own sections. This is to prevent any confusing logic order.
        wheres = query.wheres

        query.wheres = []

        # We will take the first offset (typically 0) of where clauses and start
        # slicing out every scope's where clauses into their own nested where
        # groups for improved isolation of every scope's added constraints.
        previous_count = where_counts.pop(0)

        for where_count in where_counts:
            query.wheres.append(
                self._slice_where_conditions(
                    wheres, previous_count, where_count - previous_count
                )
            )

            previous_count = where_count
107668
public function or_where($wheres = array())
	{
		if (count($wheres) > 0)
		{
			if ( ! isset($this->wheres['$or']) or ! is_array($this->wheres['$or']))
			{
				$this->wheres['$or'] = array();
			}

			foreach ($wheres as $wh => $val)
			{
				$this->wheres['$or'][] = array($wh => $val);
			}
		}
		return $this;
	}
14636
def where(self, field, value = None, operator = '='):
        
        if field is None:
            return self
        conjunction = None
        if value is None and isinstance(field, dict):
            for field, value in field.items():
                operator, value = value if isinstance(value, tuple) else ('=', value)
                self.where(field, value, operator)
        else:
            if self.where_criteria.size() > 0:
                    conjunction = 'AND'
            self.where_criteria.append(expressions.ConditionExpression(field, value, operator=operator, conjunction=conjunction))
        return self
766517
function whereNull(column) {
    this._statements.push({
      grouping: 'where',
      type: 'whereNull',
      column: column,
      not: this._not(),
      bool: this._bool()
    });
    return this;
  }
1261860
def selectnotin(table, field, value, complement=False):
    """"""

    return select(table, field, lambda v: v not in value,
                  complement=complement)
481734
def interpolate_where(self, condition):
        
        raise NotImplementedError()
        self[self < 0] = np.nan
        return self.interpolate()
817346
function whereExists(callback) {
    this._statements.push({
      grouping: 'where',
      type: 'whereExists',
      value: callback,
      not: this._not(),
      bool: this._bool() });
    return this;
  }
121242
public static <D> Predicate notIn(Expression<D> left, SubQueryExpression<? extends D> right) {
        return predicate(Ops.NOT_IN, left, right);
    }
910743
def sub(self, inplace=False, **kwargs):
        """"""
        filter_ = self.where(**kwargs)
        return self.subindex(filter_, inplace)