Used to NOT the next clause specified.
767772
public Where<T, ID> not() {
		/*
		 * Special circumstance here when we have a needs future with a not. Something like and().not().like(...). In
		 * this case we satisfy the and()'s future as the not() but the not() becomes the new needs-future.
		 */
		Not not = new Not();
		addClause(not);
		addNeedsFuture(not);
		return this;
	}
1301661
@NotNull
    public OptionalLong filterNot(@NotNull LongPredicate predicate) {
        return filter(LongPredicate.Util.negate(predicate));
    }
736785
public Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder) throws SQLException {
		return in(false, columnName, subQueryBuilder);
	}
1215702
private boolean nextWithoutLimit() throws SQLException {
		if (maxRows > 0 && rowsFetched >= maxRows) {
			System.out.println("Reach max rows " + maxRows);
			return false;
		}

		if ((recordItr == null || !recordItr.hasNext()) && !emptyResultSet) {
			TSFetchResultsReq req = new TSFetchResultsReq(sql, fetchSize);

			try {
				TSFetchResultsResp resp = client.fetchResults(req);
				Utils.verifySuccess(resp.getStatus());
				if (!resp.hasResultSet) {
					emptyResultSet = true;
				} else {
					TSQueryDataSet tsQueryDataSet = resp.getQueryDataSet();
					List<RowRecord> records = Utils.convertRowRecords(tsQueryDataSet);
					recordItr = records.iterator();
				}
			} catch (TException e) {
				throw new SQLException("Cannot fetch result from server, because of network connection");
			}

		}
		if (emptyResultSet) {
			return false;
		}
		record = recordItr.next();
		// if(record.getDeltaObjectType() != null &&
		// record.getDeltaObjectType().equals(AGGREGATION_STR)){
		// if(columnInfo.containsKey(TIMESTAMP_STR)){
		// columnInfo.remove(TIMESTAMP_STR);
		// }
		// }

		rowsFetched++;
        // maxRows is a constraint that exists in parallel with the LIMIT&SLIMIT constraints,
        // so rowsFetched will increase whenever the row is fetched,
        // regardless of whether the row satisfies the LIMIT&SLIMIT constraints or not.

		return true;
	}
824636
def reduce(self):
        """"""
        support = frozenset(range(1, self.nvars+1))
        new_clauses = set()
        for clause in self.clauses:
            vs = list(support - {abs(uniqid) for uniqid in clause})
            if vs:
                for num in range(1 << len(vs)):
                    new_part = {v if bit_on(num, i) else ~v
                                for i, v in enumerate(vs)}
                    new_clauses.add(clause | new_part)
            else:
                new_clauses.add(clause)
        return self.__class__(self.nvars, new_clauses)
378388
private function skipHidden() {
    $token = $this->iterator->current();
    while ($token && $token instanceof HiddenNode) {
      $this->skipped[] = $token;
      $token = $this->iterator->next();
    }
  }
1336559
void resetSequential() {
        seq = nextLong(prand, maxSeq);
        inc = minInc + nextLong(prand, maxInc - minInc);
    }
821952
private int tailingNonNewline(char[] cbuf, int off, int len) {
    for(int cnt = 0; cnt < len; cnt++) {
      final int pos = off + (len - 1) - cnt;
      if(cbuf[pos] == UNIX_NEWLINE) {
        return cnt;
      }
      if(cbuf[pos] == CARRIAGE_RETURN) {
        return cnt;
      }
      // TODO: need to compare to NEWLINEC, too?
    }
    return len;
  }
714798
def NotIn(self, *values):
    
    self._awql = self._CreateMultipleValuesCondition(values, 'NOT_IN')
    return self._query_builder
213473
def _not(condition=None, **kwargs):
    

    result = True

    if condition is not None:
        result = not run(condition, **kwargs)

    return result
1243368
@Override
  public Container not(final int firstOfRange, final int lastOfRange) {
    // TODO: may need to convert to a RunContainer
    if (firstOfRange >= lastOfRange) {
      return clone(); // empty range
    }

    // determine the span of array indices to be affected
    int startIndex = Util.unsignedBinarySearch(content, 0, cardinality, (short) firstOfRange);
    if (startIndex < 0) {
      startIndex = -startIndex - 1;
    }
    int lastIndex = Util.unsignedBinarySearch(content, 0, cardinality, (short) (lastOfRange - 1));
    if (lastIndex < 0) {
      lastIndex = -lastIndex - 2;
    }
    final int currentValuesInRange = lastIndex - startIndex + 1;
    final int spanToBeFlipped = lastOfRange - firstOfRange;
    final int newValuesInRange = spanToBeFlipped - currentValuesInRange;
    final int cardinalityChange = newValuesInRange - currentValuesInRange;
    final int newCardinality = cardinality + cardinalityChange;

    if (newCardinality > DEFAULT_MAX_SIZE) {
      return toBitmapContainer().not(firstOfRange, lastOfRange);
    }

    ArrayContainer answer = new ArrayContainer(newCardinality);

    // copy stuff before the active area
    System.arraycopy(content, 0, answer.content, 0, startIndex);

    int outPos = startIndex;
    int inPos = startIndex; // item at inPos always >= valInRange

    int valInRange = firstOfRange;
    for (; valInRange < lastOfRange && inPos <= lastIndex; ++valInRange) {
      if ((short) valInRange != content[inPos]) {
        answer.content[outPos++] = (short) valInRange;
      } else {
        ++inPos;
      }
    }

    for (; valInRange < lastOfRange; ++valInRange) {
      answer.content[outPos++] = (short) valInRange;
    }

    // content after the active range
    for (int i = lastIndex + 1; i < cardinality; ++i) {
      answer.content[outPos++] = content[i];
    }
    answer.cardinality = newCardinality;
    return answer;
  }
205277
def negated(self):
        
        query = self.copy()
        op = self.op()
        query.setOp(self.NegatedOp.get(op, op))
        query.setValue(self.value())
        return query
1068464
void nextExecuted(String sql) throws SQLException
    {
        count++;

        if (_order.contains(sql))
        {
            return;
        }

        String sqlCmd = sql.substring(0, 7);
        String rest = sql.substring(sqlCmd.equals("UPDATE ") ? 7 // "UPDATE "
                : 12); // "INSERT INTO " or "DELETE FROM "
        String tableName = rest.substring(0, rest.indexOf(' '));
        HashSet fkTables = (HashSet) _fkInfo.get(tableName);

        // we should not change order of INSERT/DELETE/UPDATE
        // statements for the same table
        if (_touched.contains(tableName))
        {
            executeBatch();
        }
        if (sqlCmd.equals("INSERT "))
        {
            if (_dontInsert != null && _dontInsert.contains(tableName))
            {
                // one of the previous INSERTs contained a table
                // that references this table.
                // Let's execute that previous INSERT right now so that
                // in the future INSERTs into this table will go first
                // in the _order array.
                executeBatch();
            }
        }
        else
        //if (sqlCmd.equals("DELETE ") || sqlCmd.equals("UPDATE "))
        {
            // We process UPDATEs in the same way as DELETEs
            // because setting FK to NULL in UPDATE is equivalent
            // to DELETE from the referential integrity point of view.

            if (_deleted != null && fkTables != null)
            {
                HashSet intersection = (HashSet) _deleted.clone();

                intersection.retainAll(fkTables);
                if (!intersection.isEmpty())
                {
                    // one of the previous DELETEs contained a table
                    // that is referenced from this table.
                    // Let's execute that previous DELETE right now so that
                    // in the future DELETEs into this table will go first
                    // in the _order array.
                    executeBatch();
                }
            }
        }

        _order.add(sql);

        _touched.add(tableName);
        if (sqlCmd.equals("INSERT "))
        {
            if (fkTables != null)
            {
                if (_dontInsert == null)
                {
                    _dontInsert = new HashSet();
                }
                _dontInsert.addAll(fkTables);
            }
        }
        else if (sqlCmd.equals("DELETE "))
        {
            if (_deleted == null)
            {
                _deleted = new HashSet();
            }
            _deleted.add(tableName);
        }
    }
229437
def not_next(e):
    
    def match_not_next(s, grm=None, pos=0):
        try:
            e(s, grm, pos)
        except PegreError as ex:
            return PegreResult(s, Ignore, (pos, pos))
        else:
            raise PegreError('Negative lookahead failed', pos)
    return match_not_next
208854
function dontParenthesizeSubQuery(parentQuery){
	if (!parentQuery) return false;
	if (parentQuery.nodes.length === 0) return false;
	if (['INSERT', 'REPLACE'].indexOf(parentQuery.nodes[0].type) === -1)  return false;
	return true;
}
446420
public void skip(long n) throws IllegalArgumentException, NoSuchElementException
   {
      if (n < 0)
      {
         throw new IllegalArgumentException("skip(" + n + ")");
      }

      for (long i = 0; i < n; i++)
      {
         next();
      }
   }
377721
private void excludeTemplateRange(int tPosBegin, int tPosEnd) {
        if (blockTabCnt > 0) {
            // Check whether we can extend the previous block.
            BlockTabRec btr = blockTab[blockTabCnt - 1];
            if (btr.dummy && btr.tPosEnd == tPosBegin) {
                btr.tPosContentsEnd = tPosEnd;
                btr.tPosEnd = tPosEnd;
                return;
            }
        }
        int blockNo = registerBlock(null);
        BlockTabRec btr = blockTab[blockNo];
        btr.tPosBegin = tPosBegin;
        btr.tPosContentsBegin = tPosBegin;
        btr.tPosContentsEnd = tPosEnd;
        btr.tPosEnd = tPosEnd;
        btr.definitionIsOpen = false;
        btr.dummy = true;
    }