Parameters:
     - dbname
     - name
     - deleteData
483001
def drop_table(self, dbname, name, deleteData):
    
    self.send_drop_table(dbname, name, deleteData)
    self.recv_drop_table()
318987
def DbDeleteDeviceAlias(self, argin):
        
        self._log.debug("In DbDeleteDeviceAlias()")
        self.db.delete_device_alias(argin)
923567
def drop_index_by_name(self, db_name, tbl_name, index_name, deleteData):
    
    self.send_drop_index_by_name(db_name, tbl_name, index_name, deleteData)
    return self.recv_drop_index_by_name()
276155
def delete_attachment(name, force=false)
      raise ArgumentError, "doc.database required to delete_attachment" unless database
      result = database.delete_attachment(self, name, force)
      self['_rev'] = result['rev']
      result['ok']
    end
230999
def drop(self, table_names):
        '''
        
        '''
        table_names = self._check_table_names(table_names)

        for tname in table_names:
            tname = self._check_tname(tname, noload=True)

            # Warning: if auto_load is on the next insert will re-create the table
            with self._lock:
                del self._db[tname]

                filepath = os.path.join(self.root_dir, self.name, tname + '.csv')
                if self.persistent and os.path.exists(filepath):
                    try:
                        os.remove(filepath)
                        self._print('Drop %s: Success' % tname)
                    except (IOError, WindowsError):
                        self._print('Drop %s: Failed' % tname)
1327176
def delete_database(self, dbname):
        
        db = self._DATABASE_CLASS(self, dbname)
        if not db.exists():
            raise CloudantClientException(404, dbname)
        db.delete()
        if dbname in list(self.keys()):
            super(CouchDB, self).__delitem__(dbname)
1170339
public function instance_deleted() {
        // We can't use purge here that acts upon a collection.
        // Instead we must drop the named database.
        if (!$this->is_ready()) {
            return;
        }
        $database = $this->connection->selectDatabase($this->databasename);
        $database->drop();
        $connection = null;
        $database = null;
        // Explicitly unset things to cause a close.
        $this->collection = null;
        $this->database = null;
        $this->connection = null;
    }
142894
public boolean deleteDataset(String datasetName) {
    // [START ]
    boolean deleted = bigquery.delete(datasetName, DatasetDeleteOption.deleteContents());
    if (deleted) {
      // the dataset was deleted
    } else {
      // the dataset was not found
    }
    // [END ]
    return deleted;
  }
691368
def db_remove(database_name, **kwargs):
    '''
    
    '''
    try:
        if db_exists(database_name, **kwargs) and database_name not in ['master', 'model', 'msdb', 'tempdb']:
            conn = _get_connection(**kwargs)
            conn.autocommit(True)
            cur = conn.cursor()
            cur.execute('ALTER DATABASE {0} SET SINGLE_USER WITH ROLLBACK IMMEDIATE'.format(database_name))
            cur.execute('DROP DATABASE {0}'.format(database_name))
            conn.autocommit(False)
            conn.close()
            return True
        else:
            return False
    except Exception as e:
        return 'Could not find the database: {0}'.format(e)
213298
@Override
  public final void restoreDatabase(final String pDbName) throws Exception {
    String encPath = this.backupDir + File.separator + pDbName + ".sqlten";
    File dbBkFile = new File(encPath);
    if (dbBkFile.exists()) {
      this.cryptoHelper.decryptFile(encPath,
        this.databaseDir + File.separator + pDbName + ".sqlite");
    }
  }
436585
def delete_row(dbconn, table_name, field, value):
    
    cur = dbconn.cursor()
    cur.execute("DELETE FROM '{name}' WHERE {field}='{value}'".format(name=table_name, field=field, value=value))
    dbconn.commit()
322150
def delete(name):
    '''
    '''
    with Session() as session:
        try:
            session.VFolder(name).delete()
            print_done('Deleted.')
        except Exception as e:
            print_error(e)
            sys.exit(1)
1024179
def delete(self, name):
    '''
    
    '''
    conn = self._client.connect()
    conn.execute( self._table.delete().where(self._table.c.name==name) )
976946
def drop_all(self):
        '''  '''
        self.drop(self.get_table_names())
        if self.persistent:
            with self._lock:
                try:
                    dbfolder = os.path.join(self.root_dir, self.name)
                    if os.path.exists(dbfolder) and not os.listdir(dbfolder):
                        rmtree(dbfolder)
                except (IOError, WindowsError):
                    self._print('Failed to delete folder %s when dropping database' % self.name)
                finally:
                    del self
99543
def delete_database(client, db_name, username=None, password=None):
    

    (username, password) = get_user_creds(username, password)

    sys_db = client.db("_system", username=username, password=password)

    try:
        return sys_db.delete_database(db_name)
    except Exception:
        log.warn("No arango database {db_name} to delete, does not exist")
882033
public int deleteByTableName(String tableName) throws SQLException {
		DeleteBuilder<ContentsId, Long> db = deleteBuilder();
		db.where().eq(ContentsId.COLUMN_TABLE_NAME, tableName);
		PreparedDelete<ContentsId> deleteQuery = db.prepare();
		int deleted = delete(deleteQuery);
		return deleted;
	}
770294
def delete_table(self, tablename):
        
        self.tables = filter(lambda x: x.name != tablename, self.tables)