Delete a subscription.

@param name Subscription name
@param database Database to use
6843
public void delete(String name, String database) {
        RequestExecutor requestExecutor = _store.getRequestExecutor(ObjectUtils.firstNonNull(database, _store.getDatabase()));

        DeleteSubscriptionCommand command = new DeleteSubscriptionCommand(name);
        requestExecutor.execute(command);
    }
1372135
public void delete_server_info(Database database, String serverName) throws DevFailed {
        if (!database.isAccess_checked()) checkAccess(database);

        DeviceData argIn = new DeviceData();
        argIn.insert(serverName);
        command_inout(database, "DbDeleteServerInfo", argIn);
    }
195156
private void delete(String name) {
        File f = new File(name);
        if (f.exists()) {
            f.delete();
        }
    }
851445
private void deleteTable(String tableName) {
        m_logger.info("Deleting table: {}", tableName);
        try {
            m_ddbClient.deleteTable(new DeleteTableRequest(tableName));
            for (int seconds = 0; seconds < 10; seconds++) {
                try {
                    m_ddbClient.describeTable(tableName);
                    Thread.sleep(1000);
                } catch (ResourceNotFoundException e) {
                    break;  // Success
                }   // All other exceptions passed to outer try/catch
            }
        } catch (ResourceNotFoundException e) {
            // Already deleted.
        } catch (Exception e) {
            throw new RuntimeException("Error deleting table: " + tableName, e);
        }
    }
1189988
public void delete(String name) throws IOException {
        Object obj = map.get(name);
        if (obj == null) {
            throw new IOException("No extension found with name " + name);
        }
        map.remove(name);
    }
196017
@Override
	public void unsubscribe(String subscriptionName) throws JMSException
    {
    	externalAccessLock.readLock().lock();
    	try
		{
	        checkNotClosed();
	        if (StringTools.isEmpty(subscriptionName))
	            throw new FFMQException("Empty subscription name","INVALID_SUBSCRIPTION_NAME");
	
	        // Remove remaining subscriptions on all topics
	        engine.unsubscribe(connection.getClientID(), subscriptionName);
		}
    	finally
    	{
    		externalAccessLock.readLock().unlock();
    	}
    }
544891
public void deleteProduct(final String name) {
        final DbProduct dbProduct = getProduct(name);
        repositoryHandler.deleteProduct(dbProduct.getName());
    }
668123
private void unregisterMBeanInService(String name) {
        ServiceRegistration<DynamicMBean> existingMBean = endpointMBeans.remove(name);
        if (existingMBean != null) {
            existingMBean.unregister();
        }
    }
1128192
public void unsubscribeDurable(String subscriptionName)
            throws MessagingException {
        try {
            Session session =
                connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            MessageConsumer consumer = durableSubscriptions.get(subscriptionName);
            if(consumer != null) {
                consumer.close();
            }
            session.unsubscribe(subscriptionName);
        } catch (JMSException jmse) {
            String errMsg = "Unable to unsubscribe from subscription with name: "
                          + subscriptionName + " due to exception: "
                          + jmse.getMessage();
            logger.debug(errMsg, jmse);
            throw new MessagingException(errMsg, jmse);
        }
    }
19209
public function deleteByKey($name) : void
    {
        if(!$this->keyExists($name)) {
            return;
        }

        parent::deleteByKey($name);
        unset($_SESSION[$name]);
    }
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);
    }
1234154
public int deleteByTableName(String tableName) throws SQLException {
		DeleteBuilder<FeatureTileLink, FeatureTileLinkKey> db = deleteBuilder();

		db.where().eq(FeatureTileLink.COLUMN_FEATURE_TABLE_NAME, tableName)
				.or().eq(FeatureTileLink.COLUMN_TILE_TABLE_NAME, tableName);

		PreparedDelete<FeatureTileLink> deleteQuery = db.prepare();
		int deleted = delete(deleteQuery);
		return deleted;
	}
980694
public void unsubscribe(final Subscription subscription) {
        for (final ArrayList<Subscription> list : SUBSCRIPTION_MAP.values()) {
            list.remove(subscription);
        }
    }
183659
@Override
  public final void deleteDatabase(final String pDbName) throws Exception {
    String dbNm = this.databasePrefix + pDbName + ".sqlite";
    if (!dbNm.equals(this.factoryAppBeans.getDatabaseName())) {
      File dbFile = new File(this.databaseDir + File.separator + dbNm);
      if (dbFile.exists() && !dbFile.delete()) {
        throw new ExceptionWithCode(ExceptionWithCode.SOMETHING_WRONG,
          "Can't delete file: " + dbFile);
      }
    }
  }
1304254
function(subscription_name) {
    if (Subscriber.prototype.subscriptions[subscription_name]) {
      var sub_id = Subscriber.prototype.subscriptions[subscription_name];
      request.del(this._endpoint, {
          qs: this.unsubscribeParams(sub_id)
        }, function(error, response, body) {
          if (!error && response.statusCode == 200) {
            logger.info('instagram -', subscription_name, 'unsubscribed successfully');
            delete Subscriber.prototype.subscriptions[subscription_name];
          }
        }
      );
    }
  }
219300
public function delete($name)
    {
        if (array_key_exists($name, $this->getData())) {
            $this->_db->createCommand()->delete($this->tableName, 'name = :name', [':name' => $name])->execute();
            unset($this->_data[$name]);
        }

        $this->_setCache();
    }
1090967
@Override
	public void deleteSession(String sessionName) {
		logger.debug("deleteSession " + sessionName);
	    if (databaseServer == null) {
	    	return;
	    }
        databaseServer = null;
    }