Drop this database.

        See
        https://cloud.google.com/spanner/reference/rpc/google.spanner.admin.database.v1#google.spanner.admin.database.v1.DatabaseAdmin.DropDatabase
196873
def drop(self):
        
        api = self._instance._client.database_admin_api
        metadata = _metadata_with_prefix(self.name)
        api.drop_database(self.name, metadata=metadata)
672478
protected function dropDatabase($database)
    {
        $connection = $this->pool->getConnection();
        $database = $database ?? $connection->defaultDatabase;

        $connection->getRawConnection()->dropDatabase($database);
    }
1262936
def drop_table(self, model_class):
        '''
        
        '''
        if model_class.is_system_model():
            raise DatabaseException("You can't drop system table")
        self._send(model_class.drop_table_sql(self))
89242
public void dropIndex(final ODatabaseObject db) {
        final String name = index.getName();
        logger.info("Dropping existing index '{}' (class '{}'), because of definition mismatch",
                name, index.getDefinition().getClassName());
        SchemeUtils.dropIndex(db, name);
    }
969900
def drop_schema(self):
        """"""
        try:
            self.cursor.execute("""
                DROP TABLE IF EXISTS gauged_data;
                DROP TABLE IF EXISTS gauged_keys;
                DROP TABLE IF EXISTS gauged_writer_history;
                DROP TABLE IF EXISTS gauged_cache;
                DROP TABLE IF EXISTS gauged_statistics;
                DROP TABLE IF EXISTS gauged_metadata""")
            self.db.commit()
        except self.psycopg2.InternalError:  # pragma: no cover
            self.db.rollback()
1165720
public static void dropTablesAndIndices(SQLiteDatabase db) {
		drop(db, QueryType.INDEX, null);
		drop(db, QueryType.TABLE, null);
	}
831325
public function dropDatabase($database, $optParams = array())
  {
    $params = array('database' => $database);
    $params = array_merge($params, $optParams);
    return $this->call('dropDatabase', array($params), "Google_Service_Spanner_SpannerEmpty");
  }
275633
public void dropCQLTable(String storeName) {
        String tableName = CQLService.storeToCQLName(storeName);
        m_logger.info("Dropping table: {}", tableName);
        String cql = "DROP TABLE " + qualifiedTableName(tableName) + ";";
        executeCQL(cql);
    }
542462
function destroyDatabase(name, cb) {
  if(name === user_dbname)
    throw new Error('We never ever delete that database.')
  nano().db.destroy(name, function(err) {
    if(err && err.status_code !== 404) return cb(err)
    cb(null, err ? false : true)
  })
}
768410
def cleardb(force=False):
    """"""

    # Drop database, if it exists
    if db_exists():
        try:
            dropdb(force)
        except subprocess.CalledProcessError as error:
            output = error.output.decode("utf-8")
            if "is being accessed by other users" in output:
                raise ValueError(
                    "{}\n"
                    "To forcibly terminate other sessions, run "
                    "this command again with --force".format(output)
                )
            else:
                raise
    else:
        logger.info(
            "Database %s does not currently exist; no need to drop", repr(DB["NAME"])
        )
    createdb()
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)
125247
public function drop_database($database) {
		$query = 'DROP DATABASE ' . $this->quote_identifier($database);
		$statement = $this->get_statement($query);

		$statement->execute();
	}
182235
def close(self):
        """"""

        # remove callbacks
        Datastore.stores[self.domain].remove(self)

        # delete data after the last instance is gone
        if self.release_storage and not Datastore.stores[self.domain]:
            del Datastore.global_data[self.domain]

        del self
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)
330974
function dropEnvironmentDatabase(domain, env, next) {
  _getEnvironmentDatabase({
    domain: domain,
    environment: env
  }, function (err, found) {
    if (err) {
      return next(common.buildErrorObject({
        err: err,
        msg: 'Failed to get environment',
        httpCode: 500
      }));
    }
    if (!found) {
      log.logger.info("no environment db for " + env + " moving on");
      return next();
    }
    found.dropDb(config.getConfig(), function dropped(err) {
      if (err) {
        log.logger.error('Failed to delete model');
        return next(common.buildErrorObject({
          err: err,
          msg: 'Failed to drop environment db',
          httpCode: 500
        }));
      }
      found.remove(next);
    });
  });
}
417609
def drop_database(self):
        
        self.print_message("Dropping database '%s'" % self.databases['destination']['name'])
        self.export_pgpassword('destination')
        args = [
            "dropdb",
            "--if-exists",
            self.databases['destination']['name'],
        ]
        args.extend(self.databases['destination']['args'])
        subprocess.check_call(args)
693561
public static function drop() {
		foreach([
			"DROP VIEW IF EXISTS v_usess",
			"DROP TABLE IF EXISTS usess",
			"DROP TABLE IF EXISTS udata",
			"DROP TABLE IF EXISTS meta",
		] as $drop) {
			// @codeCoverageIgnoreStart
			try {
				self::$sql->query_raw($drop);
			} catch(SQLError $e) {
				$msg = "Cannot drop data:" . $e->getMessage();
				self::$logger->error("Zapmin: sql error: $msg");
				throw new AdminStoreError($msg);
			}
			// @codeCoverageIgnoreEnd
		}
	}