Method called on the destruction of a database session.

@param string|int $id ID that uniquely identifies session in database.
@return bool True for successful delete, false otherwise.
487981
public function destroy($id)
    {
        $this->_table->delete(new Entity(
            [$this->_table->getPrimaryKey() => $id],
            ['markNew' => false]
        ));

        return true;
    }
291111
public function delete(string $id) : bool
    {
        $query = $this->storageTable->find('all', [
            'conditions' => [self::FILE_STORAGE_FOREIGN_KEY => $id]
        ]);
        $entity = $query->first();

        if (is_null($entity)) {
            return false;
        }

        if ($this->storageTable->delete($entity)) {
            $this->removeThumbnails($entity);

            return true;
        }

        return false;
    }
1210925
public function destroy($session_id)
    {
        $result = false;

        if ($this->getTable()->isConnected())
        {
            $row = $this->_table->select($session_id, KDatabase::FETCH_ROW);

            if (!$row->isNew()) {
                $result = $row->delete();
            }
        }

        return $result;
    }
616107
public static function destroy($id)
    {
        if (self::confirmIdExists($id)) {
            return self::doDelete($id); 
        } else { 
            throw new Exception('Now rows found with ID '.$id.' in the database, it may have been already deleted'); 
        }
    }
749474
public function destroy(/*# string */ $session_id)/*# : bool */
    {
        $file = $this->getSessionFile($session_id);
        return $this->storage->del($file);
    }
1061862
protected function doDelete($id) {
    $this->cache_clear_all($this->getCacheId($id), $this->cache_table);
    return TRUE;
  }
854721
public function destroy($id)
    {
        $session = $this->entityManager->find($this->entityManager, $id);
        if (false !== $session) {
            try {
                $this->entityManager->remove($session);
                $this->entityManager->flush();
                return true;
            } catch (\Doctrine\ORM\OptimisticLockException $exc) {
                return false;
            }
        }

        return true;
    }
702514
public function delete($id)
	{
		$id = trim($this->escape($id));
		$hits = $this->getIndex()->find("xref_id:\"{$id}\"");
		if (empty($hits)) {
			return false;
		}
		
		foreach ($hits as $hit) {
			$this->getIndex()->delete($hit->id);
		}
		
		return true;
	}
1247291
public function destroySession ($id) {
        $this->_connection->getClient ()->delete ($this->calculateKey ($id));
        return true;
    }
1022234
public function do_destroy($session_id)
    {
        $redis = is_object($this->_redis) ? $this->_redis : $this->_getRedis();
        $redis->delete($this->_prefix . $session_id);

        return true;
    }
239775
public function delete(string $id): bool
    {
        if (\array_key_exists($id, $this->cache)) {

            //delete value
            unset($this->cache[$id]);

            //return function result
            return true;
        }

        return false;
    }
975709
public function destroy($id)
	{
		// SECURITY:
		// if delete_permission is false, abort
		if (isset($this->crud['delete_permission']) && !$this->crud['delete_permission']) {
			abort(403, trans('crud.unauthorized_access'));
		}

		$model = $this->crud['model'];
		$item = $model::find($id);
		$item->delete();

		return 'true';
	}
500841
public function destroy($id)
    {
        $return = false;

        $record = \Doctrine::getTable($this->_tableName)->find($id);
        if (false !== $record) {
            if ($record->delete()) {
                $return = true;
            }
        }

        return $return;
    }
774694
public function delete( $id ) {

		if ( $this->contains( $id ) ) {
			$this->count--;
			$this->cacheDeletes++;
			unset( $this->cache[ $id ] );
			unset( $this->ttl[ $id ] );
			return true;
		}

		return false;
	}
283691
public function delete($id = null)
    {
        // This allows for delete based on the primary key
        if ($id && !$this->exists) {
            $this->setAttribute($this->getKeyName(), $id);
            $this->exists = true;
        }

        // Can't delete something that doesn't exists
        if ($this->exists) {
            if ($this->fireModelEvent('deleting') === false) {
                return false;
            }

            $this->performDeleteOnModel();

            $this->exists = false;

            // Once the model has been deleted, we will fire off the deleted event so that
            // the developers may hook into post-delete operations. We will then return
            // a boolean true as the delete is presumably successful on the database.
            $this->fireModelEvent('deleted', false);

            return true;
        }

        return false;
    }
1032404
public function destroy($id)
    {
        try {
            $file = $this->fileDB->getById($id);
            $this->fileDB->deleteFile($file);
            return 'File deleted';
        } catch (\Exception $e) {
            \Log::error($e);
            $this->flashMessage('delete-failed','danger');
            return 'Error: File not deleted';
        }
    }
1089849
public function destroy($id)
    {
        $language = Language::find($id);
        $destroyResult = parent::destroy($id);

        if ($destroyResult) {
            \File::deleteDirectory(resource_path('lang/'.$language->abbr));
        }

        return $destroyResult;
    }