Delete the shard for the given application, including all of its data. This method
is a no-op if the given shard does not exist or has no data.

@param appDef    {@link ApplicationDefinition} of application.
@param shard     Shard name.
18461
public void deleteShard(ApplicationDefinition appDef, String shard) {
        checkServiceState();
        m_olap.deleteShard(appDef, shard);
    }
79592
def drop_app_cache(self, appid):
        ''' 
        '''
        with shelve.open(self.shelve_path) as appshelve:
            try:
                del appshelve[str(appid)]
            except KeyError:
                # No such key in shelve, ignore
                pass
        for imgtype in ('icon', 'logosmall'):
            filename = '%d_%s.jpg' % (appid, imgtype)
            imagepath = os.path.join(self.image_path, filename)
            if os.path.exists(imagepath):
                os.unlink(imagepath)
756310
public void deletePropertyDefinition(CmsDbContext dbc, String name) throws CmsException {

        CmsPropertyDefinition propertyDefinition = null;

        try {
            // first read and then delete the metadefinition.
            propertyDefinition = readPropertyDefinition(dbc, name);
            getVfsDriver(dbc).deletePropertyDefinition(dbc, propertyDefinition);
            getHistoryDriver(dbc).deletePropertyDefinition(dbc, propertyDefinition);
        } finally {

            // fire an event that a property of a resource has been deleted
            OpenCms.fireCmsEvent(
                new CmsEvent(
                    I_CmsEventListener.EVENT_PROPERTY_DEFINITION_MODIFIED,
                    Collections.<String, Object> singletonMap("propertyDefinition", propertyDefinition)));
        }
    }
325164
public void setApplicationId(String applicationId) {
		// Set the application id as a GeoPackage
		int applicationIdInt = ByteBuffer.wrap(applicationId.getBytes())
				.asIntBuffer().get();
		execSQL(String.format("PRAGMA application_id = %d;", applicationIdInt));
	}
387179
private void deleteAppProperties(ApplicationDefinition appDef) {
        Tenant tenant = Tenant.getTenant(appDef);
        DBTransaction dbTran = DBService.instance(tenant).startTransaction();
        dbTran.deleteRow(SchemaService.APPS_STORE_NAME, appDef.getAppName());
        DBService.instance(tenant).commit(dbTran);
    }
1008881
def delete_app_id(self, app_id, mount_point='app-id'):
        
        return self._adapter.delete('/v1/auth/{0}/map/app-id/{1}'.format(mount_point, app_id))
1163891
public void api_application_applicationId_DELETE(Long applicationId) throws IOException {
		String qPath = "/me/api/application/{applicationId}";
		StringBuilder sb = path(qPath, applicationId);
		exec(qPath, "DELETE", sb.toString(), null);
	}
762361
private void cacheShardValue(TableDefinition tableDef,
                                 Integer         shardNumber,
                                 Date            shardStart) {
        // Get or create the app name -> table map
        String appName = tableDef.getAppDef().getAppName();
        Map<String, Map<Integer, Date>> tableShardNumberMap = m_appShardMap.get(appName);
        if (tableShardNumberMap == null) {
            tableShardNumberMap = new HashMap<String, Map<Integer,Date>>();
            m_appShardMap.put(appName, tableShardNumberMap);
        }
        
        // Get or create the table name -> shard number map
        String tableName = tableDef.getTableName();
        Map<Integer, Date> shardNumberMap = tableShardNumberMap.get(tableName);
        if (shardNumberMap == null) {
            shardNumberMap = new HashMap<Integer, Date>();
            tableShardNumberMap.put(tableName, shardNumberMap);
        }
        
        // Add the shard number -> start date
        shardNumberMap.put(shardNumber, shardStart);
        m_logger.debug("Sharding date for {}.{} shard #{} set to: {} ({})",
                       new Object[]{appName, tableName, shardNumber, shardStart.getTime(), Utils.formatDateUTC(shardStart)});
    }
612425
public void deleteAtlasTypeDefs(final AtlasTypesDef typesDef) throws AtlasServiceException {
        callAPI(DELETE_ALL_TYPE_DEFS, AtlasTypesDef.class, AtlasType.toJson(typesDef));
    }
1090343
@Override
	public Response deleteApplication( String applicationName ) {

		this.logger.fine( "Request: delete application " + applicationName + "." );
		Response result = Response.ok().build();
		try {
			ManagedApplication ma = this.manager.applicationMngr().findManagedApplicationByName( applicationName );
			if( ma == null )
				result = handleError(
						Status.NOT_FOUND,
						new RestError( REST_INEXISTING, application( applicationName )),
						lang( this.manager )).build();
			else
				this.manager.applicationMngr().deleteApplication( ma );

		} catch( UnauthorizedActionException | IOException e ) {
			result = handleError(
					Status.FORBIDDEN,
					new RestError( REST_DELETION_ERROR, e, application( applicationName )),
					lang( this.manager )).build();
		}

		return result;
	}
843814
public boolean deleteBulkDocs(String index, String type) {
        return executeBulkRequest(buildDeleteBulkRequestBuilder(
                buildAllDeleteRequestBuilderList(index, type))).hasFailures();
    }
814401
final Deferred<Object> delete(final byte[] key, final byte[][] qualifiers) {
    return client.delete(new DeleteRequest(table, key, FAMILY, qualifiers));
  }
158506
def delete(self, **kwargs):
        
        if self._dxid is not None:
            return dxpy.api.app_delete(self._dxid, **kwargs)
        else:
            return dxpy.api.app_delete('app-' + self._name, alias=self._alias, **kwargs)
872230
public static void deleteAllFromSharedTable(String appid) {
		if (StringUtils.isBlank(appid) || !isSharedAppid(appid)) {
			return;
		}
		Pager pager = new Pager(25);
		PageIterable<Item, QueryOutcome> pages;
		Map<String, AttributeValue> lastKey = null;
		do {
			// read all phase
			pages = queryGSI(appid, pager);
			if (pages == null) {
				break;
			}
			List<WriteRequest> deletePage = new LinkedList<>();
			for (Page<Item, QueryOutcome> page : pages) {
				for (Item item : page) {
					String key = item.getString(Config._KEY);
					// only delete rows which belong to the given appid
					if (StringUtils.startsWith(key, appid.trim())) {
						logger.debug("Preparing to delete '{}' from shared table, appid: '{}'.", key, appid);
						pager.setLastKey(item.getString(Config._ID));
						deletePage.add(new WriteRequest().withDeleteRequest(new DeleteRequest().
								withKey(Collections.singletonMap(Config._KEY, new AttributeValue(key)))));
					}
				}
				lastKey = page.getLowLevelResult().getQueryResult().getLastEvaluatedKey();
			}
			// delete all phase
			logger.info("Deleting {} items belonging to app '{}', from shared table...", deletePage.size(), appid);
			if (!deletePage.isEmpty()) {
				batchWrite(Collections.singletonMap(getTableNameForAppid(appid), deletePage), 1);
			}
		} while (lastKey != null && !lastKey.isEmpty());
	}
1277284
function cleanup() {

  var ds = application.dataStore;

  //delete the application's directory.  This will auto-delete any contained accounts and groups:
  ds.getResource(application.defaultAccountStoreMapping.href, function(err, mapping) {
    if (err) throw err;

    console.log('Retrieved application accountStoreMapping for deletion:');
    console.log(mapping);

    ds.deleteResource(mapping.accountStore, function(err) {
      if(err) throw err;

      console.log('Deleted application directory.');

      application.delete(function(err) {
        if (err) throw err;
        console.log('Deleted application.');
      });
    });
  });
}
71601
public void deleteKey(String key) throws IOException {
        File keyDir = getKeyDir(key);
        LocalFsBlobStoreFile pf = new LocalFsBlobStoreFile(keyDir, BlobStoreFile.BLOBSTORE_DATA_FILE);
        pf.delete();
        delete(keyDir);
    }
678770
private void loadShardCache(TableDefinition tableDef) {
        String appName = tableDef.getAppDef().getAppName();
        String tableName = tableDef.getTableName();
        m_logger.debug("Loading shard cache for {}.{}", appName, tableName);
        
        Date cacheDate = new Date();
        String cacheKey = appName + "/" + tableName;
        m_cacheMap.put(cacheKey, cacheDate);
        
        Map<String, Map<Integer, Date>> tableMap = m_appShardMap.get(appName);
        if (tableMap == null) {
            tableMap = new HashMap<>();
            m_appShardMap.put(appName, tableMap);
        }
        
        Map<Integer, Date> shardMap = tableMap.get(tableName);
        if (shardMap == null) {
            shardMap = new HashMap<>();
            tableMap.put(tableName, shardMap);
        }
        
        Tenant tenant = Tenant.getTenant(tableDef);
        String storeName = SpiderService.termsStoreName(tableDef);
        for(DColumn col: DBService.instance(tenant).getAllColumns(storeName, SpiderTransaction.SHARDS_ROW_KEY)) {
            Integer shardNum = Integer.parseInt(col.getName());
            Date shardDate = new Date(Long.parseLong(col.getValue()));
            shardMap.put(shardNum, shardDate);
        }
    }