notExists example

  public function exists($property, $langcode = NULL) {
    $this->condition->exists($property, $langcode);
    return $this;
  }

  /** * {@inheritdoc} */
  public function notExists($property, $langcode = NULL) {
    $this->condition->notExists($property, $langcode);
    return $this;
  }

  /** * {@inheritdoc} */
  public function range($start = NULL, $length = NULL) {
    $this->range = [
      'start' => $start,
      'length' => $length,
    ];
    

  public function exists(SelectInterface $select) {
    $this->condition->exists($select);
    return $this;
  }

  /** * {@inheritdoc} */
  public function notExists(SelectInterface $select) {
    $this->condition->notExists($select);
    return $this;
  }

  /** * {@inheritdoc} */
  public function alwaysFalse() {
    $this->condition->alwaysFalse();
    return $this;
  }

  

->accessCheck(FALSE)
      ->condition("$figures.color", ['blue', 'red'], 'IN')
      ->sort('id')
      ->execute();
    // Bit 0 or 1 is on.     $this->assertResult(1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15);

    $this->queryResults = $this->storage
      ->getQuery()
      ->accessCheck(FALSE)
      ->exists("$figures.color")
      ->notExists("$greetings.value")
      ->sort('id')
      ->execute();
    // Bit 0 or 1 is on but 2 and 3 are not.     $this->assertResult(1, 2, 3);
    // Now update the 'merhaba' string to xsiemax which is not a meaningful     // word but allows us to test revisions and string operations.     $ids = $this->storage
      ->getQuery()
      ->accessCheck(FALSE)
      ->condition("$greetings.value", 'merhaba')
      ->sort('id')
      

  public function exists(SelectInterface $select) {
    $this->query->exists($select);
    return $this;
  }

  /** * {@inheritdoc} */
  public function notExists(SelectInterface $select) {
    $this->query->notExists($select);
    return $this;
  }

  /** * {@inheritdoc} */
  public function alwaysFalse() {
    $this->query->alwaysFalse();
    return $this;
  }

  

/** * {@inheritdoc} */
  public function existsAggregate($field, $function, $langcode = NULL) {
    return $this->conditionAggregate->exists($field, $function, $langcode);
  }

  /** * {@inheritdoc} */
  public function notExistsAggregate($field, $function, $langcode = NULL) {
    return $this->conditionAggregate->notExists($field, $function, $langcode);
  }

  /** * Adds the aggregations to the query. * * @return $this * Returns the called object. */
  protected function addAggregate() {
    if ($this->aggregate) {
      foreach ($this->aggregate as $aggregate) {
        

$or_group = $query->orConditionGroup();

    $nested_or_group = $query->orConditionGroup();
    $nested_or_group->condition('colors', 'red', 'CONTAINS');
    $nested_or_group->condition('shapes', 'circle', 'CONTAINS');
    $or_group->condition($nested_or_group);

    $nested_and_group = $query->andConditionGroup();
    $nested_and_group->condition('colors', 'yellow', 'CONTAINS');
    $nested_and_group->condition('shapes', 'square', 'CONTAINS');
    $nested_and_group->notExists('photo.alt');
    $or_group->condition($nested_and_group);

    $query->condition($or_group);

    return [
      [
        [
          'or-group' => ['group' => ['conjunction' => 'OR']],
          'nested-or-group' => ['group' => ['conjunction' => 'OR', 'memberOf' => 'or-group']],
          'nested-and-group' => ['group' => ['conjunction' => 'AND', 'memberOf' => 'or-group']],
          'condition-0' => [
            

  protected function getUnassociatedRevisions($entity_type_id, $entity_ids = NULL) {
    $entity_type = \Drupal::entityTypeManager()->getDefinition($entity_type_id);

    $query = \Drupal::entityTypeManager()
      ->getStorage($entity_type_id)
      ->getQuery()
      ->allRevisions()
      ->accessCheck(FALSE)
      ->notExists($entity_type->get('revision_metadata_keys')['workspace']);

    if ($entity_ids) {
      $query->condition($entity_type->getKey('id'), $entity_ids, 'IN');
    }

    return $query->execute();
  }

}

  public function havingExists(SelectInterface $select) {
    $this->having->exists($select);
    return $this;
  }

  /** * {@inheritdoc} */
  public function havingNotExists(SelectInterface $select) {
    $this->having->notExists($select);
    return $this;
  }

  /** * {@inheritdoc} */
  public function forUpdate($set = TRUE) {
    if (isset($set)) {
      $this->forUpdate = $set;
    }
    return $this;
  }

$this->assertResults([1, 2]);
    // This returns all three entities because all of them point to an     // account.     $this->queryResults = $storage->getQuery()
      ->accessCheck(FALSE)
      ->exists("user_id.entity.name")
      ->execute();
    $this->assertResults([0, 1, 2]);
    // This returns no entities because all of them point to an account.     $this->queryResults = $storage->getQuery()
      ->accessCheck(FALSE)
      ->notExists("user_id.entity.name")
      ->execute();
    $this->assertCount(0, $this->queryResults);
    // This returns the 0th entity as that's only one pointing to the 0th     // term (test without specifying the field column).     $this->queryResults = $storage->getQuery()
      ->accessCheck(FALSE)
      ->condition("$this->fieldName.entity.name", $this->terms[0]->name->value)
      ->execute();
    $this->assertResults([0]);
    // This returns the 0th entity as that's only one pointing to the 0th     // term (test with specifying the column name).

'job' => 'Singer',
      ])
      ->execute();

    // Base query to {test}.     $query = $this->connection->select('test', 't')
      ->fields('t', ['name']);
    // Subquery to {test_people}.     $subquery = $this->connection->select('test_people', 'tp')
      ->fields('tp', ['name'])
      ->where('[tp].[age] = [t].[age]');
    $query->notExists($subquery);

    // Ensure that we got the right number of records.     $people = $query->execute()->fetchCol();
    $this->assertCount(3, $people, 'NOT EXISTS query returned the correct results.');
  }

}

    $this->queryResults = $this->entityStorage->getQuery()
      ->exists('id')
      ->execute();
    $this->assertResults(['1', '2', '3', '4', '5', '6', '7']);

    $this->queryResults = $this->entityStorage->getQuery()
      ->exists('non-existent')
      ->execute();
    $this->assertResults([]);

    $this->queryResults = $this->entityStorage->getQuery()
      ->notExists('id')
      ->execute();
    $this->assertResults([]);

    $this->queryResults = $this->entityStorage->getQuery()
      ->notExists('non-existent')
      ->execute();
    $this->assertResults(['1', '2', '3', '4', '5', '6', '7']);
  }

  /** * Tests ID conditions. */

/** * {@inheritdoc} */
  public function existsAggregate($field, $function, $langcode = NULL) {
    return $this->conditionAggregate->exists($field, $function, $langcode);
  }

  /** * {@inheritdoc} */
  public function notExistsAggregate($field, $function, $langcode = NULL) {
    return $this->conditionAggregate->notExists($field, $function, $langcode);
  }

  /** * {@inheritdoc} */
  public function conditionAggregateGroupFactory($conjunction = 'AND') {
    return new ConditionAggregate($conjunction, $this);
  }

}

$group = $query->orConditionGroup();
        break;
    }

    // Get all children of the group.     $members = $condition_group->members();

    foreach ($members as $member) {
      // If the child is simply a condition, add it to the new group.       if ($member instanceof EntityCondition) {
        if ($member->operator() == 'IS NULL') {
          $group->notExists($member->field());
        }
        elseif ($member->operator() == 'IS NOT NULL') {
          $group->exists($member->field());
        }
        else {
          $group->condition($member->field(), $member->value(), $member->operator());
        }
      }
      // If the child is a group, then recursively construct a sub group.       elseif ($member instanceof EntityConditionGroup) {
        // Add the subgroup to this new group.