Delete a plate from the database
        
        :param plate_id: The plate id
        :param delete_meta_data: Optionally delete all meta data associated with this plate as well
        :return: None
436637
def delete_plate(self, plate_id, delete_meta_data=False):
        

        if plate_id not in self.plates:
            logging.info("Plate {} not found for deletion".format(plate_id))
            return

        plate = self.plates[plate_id]

        if delete_meta_data:
            for pv in plate.values:
                identifier = ".".join(map(lambda x: "_".join(x), pv))
                self.meta_data_manager.delete(identifier=identifier)

        with switch_db(PlateDefinitionModel, "hyperstream"):
            try:
                p = PlateDefinitionModel.objects.get(plate_id=plate_id)
                p.delete()
                del self.plates[plate_id]
            except DoesNotExist as e:
                logging.warn(e)
        logging.info("Plate {} deleted".format(plate_id))
774880
def delete(self, request, **resources):
        

        resource = resources.get(self._meta.name)
        if not resource:
            raise HttpError("Bad request", status=status.HTTP_404_NOT_FOUND)

        for o in as_tuple(resource):
            o.delete()

        return HttpResponse("")
116323
protected function deletePostMeta()
    {
        $WpDb = $this->s::wpDb();

        $sql = /* Delete post meta. */ '
                DELETE
                    FROM `'.esc_sql($WpDb->postmeta).'`
                WHERE
                    `meta_key` LIKE %s
                    OR `meta_key` LIKE %s
            ';
        $like1 = $WpDb->esc_like($this->App->Config->©brand['©var'].'_').'%';
        $like2 = '%'.$WpDb->esc_like('_'.$this->App->Config->©brand['©var'].'_').'%';

        $WpDb->query($WpDb->prepare($sql, $like1, $like2));
    }
471998
public BoxRequestsMetadata.DeleteItemMetadata getDeleteFolderMetadataTemplateRequest(String id, String template) {
        BoxRequestsMetadata.DeleteItemMetadata request = new BoxRequestsMetadata.DeleteItemMetadata(getFolderMetadataUrl(id, template), mSession);
        return request;
    }
356211
def delete(self, **kwargs):
        
        kwargs['stack'] = self.stack_mark(inspect.stack())
        
        return self.db_adapter(role='master').delete(**kwargs)
488890
def _delete_collection(self, **kwargs):
        
        error_message = "The request must include \"requests_params\": {\"params\": \"options=<glob pattern>\"} as kwarg"
        try:
            if kwargs['requests_params']['params'].split('=')[0] != 'options':
                raise MissingRequiredRequestsParameter(error_message)
        except KeyError:
            raise

        requests_params = self._handle_requests_params(kwargs)
        delete_uri = self._meta_data['uri']
        session = self._meta_data['bigip']._meta_data['icr_session']

        session.delete(delete_uri, **requests_params)
1313449
def deleteMetadata(self, remote, address, key):
        """"""
        if self._server is not None:
            # pylint: disable=E1121
            return self._server.deleteMetadata(remote, address, key)
240277
def delete(self):
        
        if self.id:
            with Repo.db:
                Repo(self.__table).where(id=self.id).delete()
518600
def delete(self, table_id):
        
        from google.api_core.exceptions import NotFound

        if not self.exists(table_id):
            raise NotFoundException("Table does not exist")

        table_ref = self.client.dataset(self.dataset_id).table(table_id)
        try:
            self.client.delete_table(table_ref)
        except NotFound:
            # Ignore 404 error which may occur if table already deleted
            pass
        except self.http_error as ex:
            self.process_http_error(ex)
294956
def delete_upload_id(cls, tables: I2B2Tables, upload_id: int) -> int:
        
        return cls._delete_upload_id(tables.crc_connection, tables.observation_fact, upload_id)
884056
def delete(self, template_name):
        """"""
        template = db.Template.find_one(template_name=template_name)
        if not template:
            return self.make_response('No such template found', HTTP.NOT_FOUND)

        db.session.delete(template)
        db.session.commit()
        auditlog(event='template.delete', actor=session['user'].username, data={'template_name': template_name})

        return self.make_response({
            'message': 'Template has been deleted',
            'templateName': template_name
        })
829261
async def clear(self, using_db=None) -> None:
        
        db = using_db if using_db else self.model._meta.db
        through_table = Table(self.field.through)
        query = (
            db.query_class.from_(through_table)
            .where(getattr(through_table, self.field.backward_key) == self.instance.id)
            .delete()
        )
        await db.execute_query(str(query))
441332
public void deleteMetadata(String typeName, String scope) {
        URL url = METADATA_URL_TEMPLATE.build(this.getAPI().getBaseURL(), this.getID(), scope, typeName);
        BoxAPIRequest request = new BoxAPIRequest(this.getAPI(), url, "DELETE");
        request.send();
    }
1014940
def delete_unit(unit_id, **kwargs):
    

    try:
        db_unit = db.DBSession.query(Unit).filter(Unit.id==unit_id).one()

        db.DBSession.delete(db_unit)
        db.DBSession.flush()
        return True
    except NoResultFound:
        raise ResourceNotFoundError("Unit (ID=%s) does not exist"%(unit_id))
372062
def delete_source(self, id):
        
        # Set the index
        self.catalog.set_index('id')
        
        # Exclude the unwanted source
        self.catalog = self.catalog[self.catalog.id!=id]
        
        # Remove the records from the catalogs
        for cat_name in self.catalogs:
            new_cat = getattr(self, cat_name)[getattr(self, cat_name).source_id!=id]
            print('{} records removed from {} catalog'.format(int(len(getattr(self, cat_name))-len(new_cat)), cat_name))
            setattr(self, cat_name, new_cat)
1034486
def meta
      collection = connection[meta_collection]
      result = collection.find.first
      result.delete(:_id)
      result
    end
772989
public function delete( $key, $user_id = null, $meta_value = '' ) {
		if ( ! isset( $user_id ) ) {
			$user_id = $this->user_id;
		}
		if ( $user_id <= 0 ) {
			return false;
		}

		return delete_user_meta( $user_id, $this->get_meta_key( $key ), $meta_value );
	}