Drop an MapD view

        Parameters
        ----------
        name : string
        database : string, default None
971604
def drop_view(self, name, database=None):
        
        statement = ddl.DropView(name, database=database)
        self._execute(statement, False)
470846
def delete(name, dry_run, verbose):
    """"""
    collection = Collection.query.filter_by(name=name).one()
    if verbose:
        tr = LeftAligned(traverse=AttributeTraversal())
        click.secho(tr(collection), fg='red')
    db.session.delete(collection)
835526
@Override
    public synchronized void clearParameters(final String name) throws DatabaseEngineException, ConnectionResetException {
        final PreparedStatementCapsule ps = stmts.get(name);
        if (ps == null) {
            throw new DatabaseEngineRuntimeException(String.format("PreparedStatement named '%s' does not exist", name));
        }

        try {
            ps.ps.clearParameters();
        } catch (final SQLException ex) {
            if (checkConnection(conn) || !properties.isReconnectOnLost()) {
                throw new DatabaseEngineException("Error clearing parameters", ex);
            }

            // At this point maybe it is an error with the connection, so we try to re-establish it.
            try {
                getConnection();
            } catch (final Exception e2) {
                throw new DatabaseEngineException("Connection is down", e2);
            }

            throw new ConnectionResetException("Connection was reset.");
        }
    }
626946
static void removeDatabase(Database database) {

        int     dbID = database.databaseID;
        String  type = database.getType();
        String  path = database.getPath();
        // A VoltDB extension to work around ENG-6044
        /* disable 2 lines ...
        Object  key  = path;
        HashMap databaseMap;
           ... disabled 2 lines */
        // End of VoltDB extension

        notifyServers(database);

        // A VoltDB extension to work around ENG-6044
        /* disable 11 lines ...
        if (type == DatabaseURL.S_FILE) {
            databaseMap = fileDatabaseMap;
            key         = filePathToKey(path);
        } else if (type == DatabaseURL.S_RES) {
            databaseMap = resDatabaseMap;
        } else if (type == DatabaseURL.S_MEM) {
            databaseMap = memDatabaseMap;
        } else {
            throw (Error.runtimeError(
                ErrorCode.U_S0500, "DatabaseManager.lookupDatabaseObject()"));
        }
           ... disabled 11 lines */

        assert(type == DatabaseURL.S_MEM);
        java.util.HashMap<String, Database> databaseMap = memDatabaseMap;
        String key = path;
        // End of VoltDB extension

        databaseIDMap.remove(dbID);
        databaseMap.remove(key);

        if (databaseIDMap.isEmpty()) {
            ValuePool.resetPool();
        }
    }
1053617
def drop_all_tables(self):
        

        # Retrieve database name from application config
        app = self.db.app
        mongo_settings = app.config['MONGODB_SETTINGS']
        database_name = mongo_settings['db']

        # Flask-MongoEngine is built on MongoEngine, which is built on PyMongo.
        # To drop database collections, we need to access the PyMongo Database object,
        # which is stored in the PyMongo MongoClient object,
        # which is stored in app.extensions['mongoengine'][self]['conn']
        py_mongo_mongo_client = app.extensions['mongoengine'][self.db]['conn']
        py_mongo_database = py_mongo_mongo_client[database_name]

        # Use the PyMongo Database object
        for collection_name in py_mongo_database.collection_names():
            py_mongo_database.drop_collection(collection_name)
735853
public function dropView($name)
    {
        if (!$this->hasView($name)) {
            throw SchemaException::schemaViewDoesNotExist($this->getName(), $name);
        }

        unset($this->views[$name]);
    }
553684
function dropDatabase (db, fn) {
  db.connection.db.executeDbCommand({
    dropDatabase: 1
  }, function(err, result) {
    db.disconnect()
    fn && fn(err, result)
  })
}
754632
def deregister(cls, name: str) -> None:
        
        if name not in cls.available:
            raise ConnectionPluginNotRegistered(
                f"Connection {name!r} is not registered"
            )
        cls.available.pop(name)
1077041
def drop_connection(self, name, database=None):
        
        request_executor = self._store.get_request_executor(database)
        command = DropSubscriptionConnectionCommand(name)
        request_executor.execute(command)
1275325
def drop_db(name, **client_args):
    '''
    
    '''
    if not db_exists(name, **client_args):
        log.info('DB \'%s\' does not exist', name)
        return False

    client = _client(**client_args)
    client.drop_database(name)

    return True
1090760
def drop_column(self, name):
        
        name = self._normalize_identifier(name)
        del self._columns[name]

        return self
714092
def remove_parameter(self, name):
		
		if name in self.__query:
			self.__query.pop(name)
992737
@Deprecated 
	private String convertDatabaseName(String name) {
		if (propBase.getBooleanProperty("db.useUnderscoreNaming")) {
			name = CamelCaseConverter.camelCaseToUnderscore(name);
		}
		name = truncateLongDatabaseName(name);
		name = name.toUpperCase();
		return name;
	}
1000928
public function dropSelectedDatabase()
    {
        $databaseName = $this->connector->getSelectedDatabase();
        if ($databaseName) {
            $this->connector->unloadDatabase();
            $this->schemaManager->dropDatabase($databaseName);
        }
    }
892738
def stopContext(self, context):
        

        # Use pymongo directly to drop all collections of created db
        if ((self.clear_context['module'] and inspect.ismodule(context)) or
           (self.clear_context['class'] and inspect.isclass(context))):
            self.connection.drop_database(self.database_name)
98724
def delete(self, drop_database=True):
        
        self.disable()
        Session.delete(self)

        if drop_database and self.db_name:
            mysql = create_engine('mysql://root:secret@localhost')
            mysql.execute('DROP DATABASE IF EXISTS `{db}`'.format(db=self.db_name))
            try:
                mysql.execute('DROP USER `{u}`'.format(u=self.db_user))
            except SQLAlchemyError:
                pass
1342877
def drop_user(self, name):
        
        statement = ddl.DropUser(name)
        self._execute(statement)