Use this API to delete lbmetrictable.
977921
public static base_response delete(nitro_service client, lbmetrictable resource) throws Exception {
		lbmetrictable deleteresource = new lbmetrictable();
		deleteresource.metrictable = resource.metrictable;
		return deleteresource.delete_resource(client);
	}
332229
public void removeTableModelListener(TableModelListener l)
    {
        try   {
            this.updateIfNewRow(-1);    // Update any locked record.
        } catch (DBException ex)    {
            ex.printStackTrace();
        }
        super.removeTableModelListener(l);
    }
1322722
public static void deleteTileScaling(GeoPackageCore geoPackage, String table) {

		TileScalingDao tileScalingDao = geoPackage.getTileScalingDao();
		ExtensionsDao extensionsDao = geoPackage.getExtensionsDao();

		try {
			if (tileScalingDao.isTableExists()) {
				tileScalingDao.deleteById(table);
			}
			if (extensionsDao.isTableExists()) {
				extensionsDao.deleteByExtension(
						TileTableScaling.EXTENSION_NAME, table);
			}
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to delete Tile Scaling. GeoPackage: "
							+ geoPackage.getName() + ", Table: " + table, e);
		}
	}
681334
public static lbmetrictable[] get(nitro_service service) throws Exception{
		lbmetrictable obj = new lbmetrictable();
		lbmetrictable[] response = (lbmetrictable[])obj.get_resources(service);
		return response;
	}
964644
def delete_lbaas_l7rule(self, l7rule, l7policy):
        """"""
        return self.delete(self.lbaas_l7rule_path % (l7policy, l7rule))
336726
private void destroyEndpointMBeans() {
        for (Map.Entry<String, ServiceRegistration<DynamicMBean>> mbean : endpointMBeans.entrySet()) {
            String mbeanName = mbean.getKey();
            endpointMBeans.remove(mbeanName);
            mbean.getValue().unregister();
        }
    }
734307
public static base_response delete(nitro_service client, String monitorname) throws Exception {
		lbmonitor deleteresource = new lbmonitor();
		deleteresource.monitorname = monitorname;
		return deleteresource.delete_resource(client);
	}
1235203
public void cleanTables() {
        try {
            DefaultTableModel algModel = (DefaultTableModel) jTableAlgoritms.getModel();
            DefaultTableModel strModel = (DefaultTableModel) jTableStreams.getModel();
            int rows = jTableAlgoritms.getRowCount();
            int srow = jTableStreams.getRowCount();
            for (int i = 0; i < rows; i++) {
                algModel.removeRow(0);
            }
            for (int i = 0; i < srow; i++) {
                strModel.removeRow(0);
            }

        } catch (Exception e) {
            JOptionPane.showMessageDialog(null, "Error cleaning the table.");
        }
    }
77693
public boolean deleteMetric(Metric metric) {
        String metricName = metric.getName();
        checkMetricIsEmpty(metricName);
        QueryPart<Metric> queryPart = new Query<Metric>("metrics")
                .path(metricName, true);
        return httpClientManager.updateMetaData(queryPart, delete());
    }
1050867
public void free()
    {
        super.free();
        try
        {
            if (this.getHandle(DBConstants.DATA_SOURCE_HANDLE) != null)
                ((BaseBuffer)this.getHandle(DBConstants.DATA_SOURCE_HANDLE)).free();
        } catch (DBException ex)    {
            // Never
        }
        if (m_pTable != null)
            m_pTable.removePTableOwner(this, true);      // Free or decrement the use count of the physical table
        m_pTable = null;
    }
1126310
def delete_table(self, table):
        

        if not self.table_exists(table):
            return

        self.client.tables().delete(projectId=table.project_id,
                                    datasetId=table.dataset_id,
                                    tableId=table.table_id).execute()
306832
public void removeTable(final Table table) {
        final List<Column> columns = table.getColumns();
        for (final Column column : columns) {
            _analysisJobBuilder.removeSourceColumn(column);
        }
    }
175982
def delete_lbaas_port(self, lb_id):
        
        lb_id = lb_id.replace('-', '')
        req = dict(instance_id=lb_id)
        instances = self.get_vms_for_this_req(**req)
        for vm in instances:
            LOG.info("deleting lbaas vm %s " % vm.name)
            self.delete_vm_function(vm.port_id, vm)
663161
public void delete() throws CouchbaseLiteException {
        synchronized (lock) {
            mustBeOpen();

            Log.i(DOMAIN, "Deleting %s at path %s", this, getC4Database().getPath());

            if (activeReplications.size() > 0) {
                throw new CouchbaseLiteException(
                    "Cannot delete the database.  Please stop all of the replicators before closing the database.",
                    CBLError.Domain.CBLITE, CBLError.Code.BUSY);
            }


            if (activeLiveQueries.size() > 0) {
                throw new CouchbaseLiteException(
                    "Cannot delete the database.  Please remove all of the query listeners before closing the "
                        + "database.",
                    CBLError.Domain.CBLITE,
                    CBLError.Code.BUSY);
            }

            // cancel purge timer
            cancelPurgeTimer();

            // delete db
            deleteC4DB();

            // release instances
            freeC4Observers();
            freeC4DB();

            // shutdown executor service
            shutdownExecutorService();
        }
    }
609359
private void removeFromTable(Node node) {
    int last = data.size() - 1;
    table[node.index] = table[last];
    table[node.index].index = node.index;
    table[last] = null;
  }
189734
def delete(self):
        
        cmd = "delete from {table} {where_clause}".format(
            table=self.table_name,
            where_clause=self.where_clause
        ).rstrip()
        Repo.db.execute(cmd, self.where_values)
962989
def DeleteMetricDescriptor(self, request, context):
        
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")