@Override public int run() throws IOException { DatasetRepository repo = getDatasetRepository(); if (targets == null || targets.isEmpty()) { throw new IllegalArgumentException("No views or datasets were specified."); } for (String uriOrName : targets) { if (isViewUri(uriOrName)) { View view = Datasets.load(uriOrName); Preconditions.checkArgument( viewMatches(view.getUri(), uriOrName), "Resolved view does not match requested view: " + view.getUri()); view.deleteAll(); } else if (isDatasetUri(uriOrName)) { Datasets.delete(uriOrName); } else { repo.delete(namespace, uriOrName); } console.debug("Deleted {}", uriOrName); } return 0; }
/** * Delete a {@link Dataset} identified by the given dataset URI. * * <p>When you call this method using a dataset URI, both data and metadata are deleted. After you * call this method, the dataset no longer exists, unless an exception is thrown. * * <p>When you call this method using a view URI, data in that view is deleted. The dataset's * metadata is not changed. This can throw an {@code UnsupportedOperationException} if the delete * requires additional work. For example, if some, but not all, of the data in an underlying data * file must be removed, then the implementation is allowed to reject the deletion rather than * copy the remaining records to a new file. An implementation must document under what conditions * it accepts deletes, and under what conditions it rejects them. * * <p>URIs must begin with {@code dataset:}. The remainder of the URI is implementation specific, * depending on the dataset scheme. * * @param uri a {@code Dataset} URI * @return {@code true} if any data or metadata is removed, {@code false} otherwise * @throws NullPointerException if {@code uri} is null * @throws IllegalArgumentException if {@code uri} is not a dataset URI */ public static boolean delete(URI uri) { Preconditions.checkArgument( URIBuilder.DATASET_SCHEME.equals(uri.getScheme()), "Not a dataset URI: " + uri); Pair<DatasetRepository, Map<String, String>> pair = Registration.lookupDatasetUri(URI.create(uri.getRawSchemeSpecificPart())); DatasetRepository repo = pair.first(); Map<String, String> uriOptions = pair.second(); return repo.delete( uriOptions.get(URIBuilder.NAMESPACE_OPTION), uriOptions.get(URIBuilder.DATASET_NAME_OPTION)); }
@Test public void testWriteModeCheckpoint() throws Exception { Dataset<Record> inputDataset = repo.create("ns", "in", new DatasetDescriptor.Builder().schema(USER_SCHEMA).build()); Dataset<Record> outputDataset = repo.create("ns", "out", new DatasetDescriptor.Builder().schema(USER_SCHEMA).build()); writeTestUsers(inputDataset, 1, 0); Thread.sleep( 1000); // ensure output is newer than input on local filesystems with 1s granularity runCheckpointPipeline(inputDataset, outputDataset); // under hadoop1 the issues with LocalJobRunner (MAPREDUCE-2350) require that we // manually ready the output dataset if (Hadoop.isHadoop1()) { ((Signalable) outputDataset).signalReady(); } checkTestUsers(outputDataset, 1); long lastModified = ((LastModifiedAccessor) outputDataset).getLastModified(); // re-run without changing input and output should not change runCheckpointPipeline(inputDataset, outputDataset); checkTestUsers(outputDataset, 1); Assert.assertEquals(lastModified, ((LastModifiedAccessor) outputDataset).getLastModified()); // re-write input then re-run and output should be re-written Thread.sleep(1000); // ensure new input is newer than output repo.delete("ns", "in"); inputDataset = repo.create("ns", "in", new DatasetDescriptor.Builder().schema(USER_SCHEMA).build()); writeTestUsers(inputDataset, 1, 0); runCheckpointPipeline(inputDataset, outputDataset); checkTestUsers(outputDataset, 1); Assert.assertTrue(((LastModifiedAccessor) outputDataset).getLastModified() > lastModified); }
@Before public void setUp() throws Exception { this.repo = newRepo(); repo.delete("ns", "in"); repo.delete("ns", "out"); }