Delete an items from a database

@param  array $criteria
@param  array $options
@return bool
436572
public function delete(array $criteria = [], array $options = []) {
		return $this->getAdapter()->remove(
			$this->getTableName(),
			$criteria,
			$options
		);
	}
1199553
public function deleteMyCredentials($strategy, array $options = [])
    {
        $options['httpParams'][':strategy'] = $strategy;

        return $this->query($this->buildQueryArgs('auth', 'deleteMyCredentials'), [], $options)['result'];
    }
151110
public function trash(EntityInterface $entity, array $options = [])
    {
        $primaryKey = (array)$this->_table->getPrimaryKey();

        foreach ($primaryKey as $field) {
            if (!$entity->has($field)) {
                throw new RuntimeException();
            }
        }

        foreach ($this->_table->associations() as $association) {
            if ($this->_isRecursable($association, $this->_table)) {
                $association->cascadeDelete($entity, ['_primary' => false] + $options);
            }
        }

        $data = [$this->getTrashField(false) => new Time()];
        $entity->set($data, ['guard' => false]);

        if ($this->_table->save($entity, $options)) {
            return true;
        }

        return false;
    }
1309264
public static function delete($tname, $options=array()) {
        
        try {        
            return PdoLite::exec(self::qbDelete($tname, $options));
        } catch (PDOException $e) {
            die(self::dbError($tname));
        }
    }
543810
public static function delete($id, $options = [])
    {
        $url = static::classUrl() . '/' . $id;
        return static::_directRequest('delete', $url, null, $options);
    }
431331
public function findOneAndDelete(array $filter, array $options = [])
    {
        $options = ['remove' => true] + FindOneAndDeleteResolver::resolveStatic($options);

        return $this->findAndModify($filter, $options);
    }
545708
public function dropIndex($collection, $indexName, array $options = [])
    {
        $col = $this->db->selectCollection($collection);

        return $col->dropIndex($indexName, $options);
    }
752248
public function delete(array $options = [])
    {
        $data = [
            '_id' => $this->id
        ];

        $response = $this->security->getKuzzle()->query(
            $this->security->buildQueryArgs($this->deleteActionName),
            $data,
            $options
        );

        return $response['result']['_id'];
    }
908075
public function delete($collection, array $criteria, $multi = TRUE)
	{
		$conds = $this->preprocessor->processCondition($criteria);

		$result = (int) $this->queryAdapter->delete($collection, $conds, $multi);

		$this->onQuery($collection, 'delete', ['criteria' => $conds, 'multi' => $multi], $result);

		return $result;
	}
1224430
public function deleteMany(array $filter, array $options = [])
    {
        list($bulkOptions, $options) = self::extractBulkWriteOptions($options);
        $model = new DeleteMany($filter, $options);
        $bulkWriteResult = $this->bulkWrite([$model], $bulkOptions);

        return new DeleteResult($bulkWriteResult);
    }
639700
public function delete($selection, $options = null)
    {
        $sel = $selection instanceof Selection ? $selection : new Selection($selection);
        $opts = array_replace(['returnDocuments' =>  false], $options ?: []);
        return $this->mutate(['delete' => $sel->serialize()], $opts);
    }
456749
public static function Delete ($table_name, array $values = [], array $options = []) {
		return static::GetConnection($options)->delete($table_name, $values, $options);
	}
1255866
public function delete($options)
    {
        $where = $this->parseWhere($options['where']);
        $bulk = new BulkWrite;
        if (1 == $options['limit']) {
            $deleteOptions = ['limit' => 1];
        } else {
            $deleteOptions = ['limit' => 0];
        }
        $bulk->delete($where, $deleteOptions);
        $this->log('remove', $where, $deleteOptions);
        return $bulk;
    }
1032665
public static function doDelete(array $options=array(), $instance=null, $IDField=null) {
		self::prepareQuery($options, $instance, $IDField);
		return self::$instances[$instance]->delete($options);
	}
979078
public function delete($query, array $options = []) {
		$params = compact('query', 'options');

		return Filters::run($this, __FUNCTION__, $params, function($params) {
			$query = $params['query'];
			$params = $query->export($this);
			list($_path, $conditions) = $params['conditions'];
			$data = $query->data();

			if (!empty($data['rev'])) {
				$conditions['rev'] = $data['rev'];
			}
			$result = $this->connection->delete(
				"{$this->_config['database']}/{$_path}",
				$conditions
			);
			$result = json_decode($result);
			$result = (isset($result->ok) && $result->ok === true);

			if ($query->entity()) {
				$query->entity()->sync(null, [], ['dematerialize' => true]);
			}
			return $result;
		});
	}
1293340
public function deleteMany(array $filter, array $options = [])
    {
        $this->writeModels[] = [BulkWrite::DELETE_MANY => [$filter, $options]];

        return $this;
    }
752606
protected function doRemove(array $query, array $options)
    {
        $options = isset($options['safe']) ? $this->convertWriteConcern($options) : $options;
        $options = isset($options['wtimeout']) ? $this->convertWriteTimeout($options) : $options;
        $options = isset($options['timeout']) ? $this->convertSocketTimeout($options) : $options;
        return $this->mongoCollection->remove($query, $options);
    }