Delete the selected run from the database.
    :return:
967170
def delete_project():
    
    assert request.method == "POST", "POST request expected received {}".format(request.method)
    if request.method == "POST":
        try:
            selections = json.loads(request.form["selections"])
            utils.drop_project(selections["project"])
            return jsonify({"response": "deleted {}".format(selections["project"])})
        except Exception as e:
            logging.error(e)
    return jsonify({"0": "__EMPTY"})
985760
def deleteSelected(self):
        ''
        ndeleted = self.deleteBy(self.isSelected)
        nselected = len(self._selectedRows)
        self._selectedRows.clear()
        if ndeleted != nselected:
            error('expected %s' % nselected)
314415
def destroy(self):
        '''
        
        '''
        if self._running is False:
            return

        self._running = False
        if hasattr(self, 'schedule'):
            del self.schedule
        if hasattr(self, 'pub_channel') and self.pub_channel is not None:
            self.pub_channel.on_recv(None)
            if hasattr(self.pub_channel, 'close'):
                self.pub_channel.close()
            del self.pub_channel
        if hasattr(self, 'periodic_callbacks'):
            for cb in six.itervalues(self.periodic_callbacks):
                cb.stop()
322510
def remove(self):
        
        session = client.get_client().create_session()

        if not self._base_query(session).count() > 0:
            session.close()
            raise RuntimeError("Target does not exist, name={:s}, params={:s}"
                               "".format(self.name, self.params))

        # remove the target from the database
        self._base_query(session).delete()
        session.commit()

        session.close()
880006
def delete(self, id):
        """"""
        run = self.backend_store.get_run(id)
        if not run:
            return abort(http_client.NOT_FOUND,
                         message="Run {} doesn't exist".format(id))
        if not self.manager.delete_run(run):
            return abort(http_client.BAD_REQUEST,
                         message="Failed to find the task queue "
                                 "manager of run {}.".format(id))
        return '', http_client.NO_CONTENT
1035216
def clean_previous_run(self):
        
        # Clean all lists
        self.arbiters.clear()
        self.schedulers.clear()
        with self.external_commands_lock:
            self.external_commands = self.external_commands[:]
729429
def api_run_delete(run_id):
    """"""
    data = current_app.config["data"]  # type: DataStorage
    RunFacade(data).delete_run(run_id)
    return "DELETED run %s" % run_id
816389
def remove():
    
    if exists(env.venv_path):
        run("rm -rf %s" % env.venv_path)
    if exists(env.proj_path):
        run("rm -rf %s" % env.proj_path)
    for template in get_templates().values():
        remote_path = template["remote_path"]
        if exists(remote_path):
            sudo("rm %s" % remote_path)
    if exists(env.repo_path):
        run("rm -rf %s" % env.repo_path)
    sudo("supervisorctl update")
    psql("DROP DATABASE IF EXISTS %s;" % env.proj_name)
    psql("DROP USER IF EXISTS %s;" % env.proj_name)
1350197
def delete(self):
        

        if self.oracle:
            self.oracle.delete()
            self.oracle = None

        if self.tot:
            self.tot.delete()
            self.tot = None
113359
def delete(self):
        

        if self.grid.IsSelection():
            # Delete selection
            self.grid.actions.delete_selection()

        else:
            # Delete cell at cursor
            cursor = self.grid.actions.cursor
            self.grid.actions.delete_cell(cursor)

        # Update grid
        self.grid.ForceRefresh()
874561
def delete(self):
        # type: (_BaseResumeManager) -> None
        
        self.close()
        if self._resume_file.exists():  # noqa
            try:
                self._resume_file.unlink()
            except OSError as e:
                logger.warning('could not unlink resume db: {}'.format(e))
        for ext in ('.bak', '.dat', '.dir'):  # noqa
            fp = pathlib.Path(str(self._resume_file) + ext)
            if fp.exists():
                try:
                    fp.unlink()
                except OSError as e:
                    logger.warning('could not unlink resume db: {}'.format(e))
419591
def delete(self):
        
        redis_search_key = ":".join([self.namespace, self.key, "*"])
        keys = self.conn.keys(redis_search_key)
        if keys:
            for key in keys:
                part = key.split(":")[-1]
                self._data.pop(part)
                self.conn.delete(part)

        del self
795720
def clean(self):
        
        self.exec_pg_success(['dropdb', '-U', self.user, self.database])
        self.exec_pg_success(['createdb', '-U', self.user, self.database])
95485
def _run_select(self):
        
        return self._connection.select(
            self.to_sql(), self.get_bindings(), not self._use_write_connection
        )
1101068
def delete(self):
        ''
        #url = '%s?dl=true' % self.path
        r = self.jfs.post(url=self.path, params={'dl':'true'})
        return r
912087
void endOfRunDb()
    {
        DbConn cnx = null;

        try
        {
            cnx = Helpers.getNewDbSession();

            // Done: put inside history & remove instance from queue.
            History.create(cnx, this.ji, this.resultStatus, endDate);
            jqmlogger.trace("An History was just created for job instance " + this.ji.getId());
            cnx.runUpdate("ji_delete_by_id", this.ji.getId());
            cnx.commit();
        }
        catch (RuntimeException e)
        {
            endBlockDbFailureAnalysis(e);
        }
        finally
        {
            Helpers.closeQuietly(cnx);
        }
    }
1143401
def clear(self):
        
        self._options = []
        self._combo_menu.tk.delete(0, END)
        self._selected.set("")