This is an automated email from the ASF dual-hosted git repository.
mmiller pushed a commit to branch tour-website
in repository https://gitbox.apache.org/repos/asf/accumulo-website.git
The following commit(s) were added to refs/heads/tour-website by this push:
new e7c6958 ACCUMULO-4734 Create a few exercises for the tour
e7c6958 is described below
commit e7c69584b3c50a930ecef805ebcd24d3fa4e147a
Author: Mike Miller <mmil...@apache.org>
AuthorDate: Tue Nov 28 15:25:03 2017 -0500
ACCUMULO-4734 Create a few exercises for the tour
---
_data/tour.yml | 6 +++++
tour/authorizations-code.md | 64 +++++++++++++++++++++++++++++++++++++++++++++
tour/authorizations.md | 46 ++++++++++++++++++++++++++++++++
tour/basic-read-write.md | 52 ++++++++++++++++++++++++++++++++++--
tour/batch-scanner-code.md | 42 +++++++++++++++++++++++++++++
tour/batch-scanner.md | 35 +++++++++++++++++++++++++
tour/data-model-code.md | 58 ++++++++++++++++++++++++++++++++++++++++
tour/data-model.md | 28 ++++++++++++++++++++
tour/getting-started.md | 29 +++++++++++++++++++-
tour/index.md | 11 ++++----
tour/ranges-splits.md | 36 +++++++++++++++++++++++++
11 files changed, 398 insertions(+), 9 deletions(-)
diff --git a/_data/tour.yml b/_data/tour.yml
index d84b5bb..c7de9ed 100644
--- a/_data/tour.yml
+++ b/_data/tour.yml
@@ -1,6 +1,12 @@
docs:
- getting-started
- basic-read-write
+ - data-model
+ - data-model-code
+ - authorizations
+ - authorizations-code
+ - ranges-splits
- batch-scanner
+ - batch-scanner-code
- conditional-writer
- using-iterators
diff --git a/tour/authorizations-code.md b/tour/authorizations-code.md
new file mode 100644
index 0000000..04ea47b
--- /dev/null
+++ b/tour/authorizations-code.md
@@ -0,0 +1,64 @@
+---
+title: Authorizations Code
+---
+```java
+ // start writing your code here
+ // Connect to Mini Accumulo as the root user and create a table called
"GothamPD".
+ Connector conn = mac.getConnector("root", "tourguide");
+ conn.tableOperations().create("GothamPD");
+
+ // Create a "secretIdentity" authorization & visibility
+ final String secId = "secretIdentity";
+ Authorizations auths = new Authorizations(secId);
+ ColumnVisibility visibility = new ColumnVisibility(secId);
+
+ // Create a user with the "secretIdentity" authorization and grant him
read permissions on our table
+ conn.securityOperations().createLocalUser("commissioner", new
PasswordToken("gordanrocks"));
+ conn.securityOperations().changeUserAuthorizations("commissioner",
auths);
+ conn.securityOperations().grantTablePermission("commissioner",
"GothamPD", TablePermission.READ);
+
+ // Create 3 Mutation objects, securing the proper columns.
+ Mutation mutation1 = new Mutation("id0001");
+ mutation1.put("hero","alias", "Batman");
+ mutation1.put("hero","name", visibility, "Bruce Wayne");
+ mutation1.put("hero","wearsCape?", "true");
+ Mutation mutation2 = new Mutation("id0002");
+ mutation2.put("hero","alias", "Robin");
+ mutation2.put("hero","name", visibility,"Dick Grayson");
+ mutation2.put("hero","wearsCape?", "true");
+ Mutation mutation3 = new Mutation("id0003");
+ mutation3.put("villain","alias", "Joker");
+ mutation3.put("villain","name", "Unknown");
+ mutation3.put("villain","wearsCape?", "false");
+
+ // Create a BatchWriter to the GothamPD table and add your mutations
to it.
+ // Once the BatchWriter is closed by the try w/ resources, data will
be available to scans.
+ try(BatchWriter writer = conn.createBatchWriter("GothamPD", new
BatchWriterConfig())) {
+ writer.addMutation(mutation1);
+ writer.addMutation(mutation2);
+ writer.addMutation(mutation3);
+ }
+
+ // Read and print all rows of the commissioner can see. Pass Scanner
proper authorizations
+ Connector commishConn = mac.getConnector("commissioner",
"gordanrocks");
+ try(Scanner scan = commishConn.createScanner("GothamPD", auths)) {
+ System.out.println("Gotham Police Department Persons of
Interest:");
+ for (Map.Entry<Key, Value> entry : scan) {
+ System.out.printf("Key : %-60s Value : %s\n", entry.getKey(),
entry.getValue());
+ }
+ }
+```
+
+The code above will print (timestamp will differ):
+```commandline
+Gotham Police Department Persons of Interest:
+Key : id0001 hero:alias [] 1511900180231 false Value :
Batman
+Key : id0001 hero:name [secretIdentity] 1511900180231 false Value :
Bruce Wayne
+Key : id0001 hero:wearsCape? [] 1511900180231 false Value :
true
+Key : id0002 hero:alias [] 1511900180231 false Value :
Robin
+Key : id0002 hero:name [secretIdentity] 1511900180231 false Value :
Dick Grayson
+Key : id0002 hero:wearsCape? [] 1511900180231 false Value :
true
+Key : id0003 villain:alias [] 1511900180231 false Value :
Joker
+Key : id0003 villain:name [] 1511900180231 false Value :
Unknown
+Key : id0003 villain:wearsCape? [] 1511900180231 false Value :
false
+```
\ No newline at end of file
diff --git a/tour/authorizations.md b/tour/authorizations.md
new file mode 100644
index 0000000..ac45ffe
--- /dev/null
+++ b/tour/authorizations.md
@@ -0,0 +1,46 @@
+---
+title: Authorizations
+---
+Authorizations are a set of Strings that enable a user to read protected data.
A column visibility is a boolean expression
+that is evaluated using the authorizations provided by a scanner. If it
evaluates to true, then the data is visible.
+
+For example:
+* Bob scans with authorizations = { IT, User }
+* Tina scans with authorizations = { Admin, IT, User }
+* Row1:family1:qualifier1 has Visibility = { Admin && IT && User }
+* Bob will **not** see Row1:family1:qualifier1
+* Tina will see Row1:family1:qualifier1
+
+We now want to secure our secret identities of the heroes so that only users
with the proper authorizations can read their names.
+
+1. Using the code from the previous exercise, add the following to the
beginning of the _exercise_ method (after we get the Connector).
+```java
+ // Create a "secretIdentity" authorization & visibility
+ final String secId = "secretIdentity";
+ Authorizations auths = new Authorizations(secId);
+ ColumnVisibility visibility = new ColumnVisibility(secId);
+
+ // Create a user with the "secretIdentity" authorization and grant him
read permissions on our table
+ conn.securityOperations().createLocalUser("commissioner", new
PasswordToken("gordanrocks"));
+ conn.securityOperations().changeUserAuthorizations("commissioner",
auths);
+ conn.securityOperations().grantTablePermission("commissioner",
"GothamPD", TablePermission.READ);
+```
+
+2. The Mutation API allows you to set the visibility on a column. Find the
proper method for setting a column visibility in
+the [Mutation API][mut] and modify the code so the visibility created above
will secure the two "name" columns.
+
+3. Build and run. What data do you see?
+* You should see all of the data except the secret identities of Batman and
Robin. This is because the Scanner was created
+ from the root user Connector.
+* Replace the _Authorizations.EMPTY_ in the Scanner with the _auths_ created
above and run it again.
+* This should result in an error since the root user doesn't have the
authorizations we tried to pass to the Scanner.
+
+4. Get a connector for the "commissioner" and from it create a Scanner with
the authorizations needed to view the secret identities.
+
+5. Build and run. You should see all the rows in the GothamPD table printed,
including these secured key/value pairs:
+```commandline
+Key : id0001 hero:name [secretIdentity] 1511900180231 false Value :
Bruce Wayne
+Key : id0002 hero:name [secretIdentity] 1511900180231 false Value :
Dick Grayson
+```
+
+[mut]:
https://accumulo.apache.org/1.8/apidocs/org/apache/accumulo/core/data/Mutation.html
\ No newline at end of file
diff --git a/tour/basic-read-write.md b/tour/basic-read-write.md
index 6eb1c5c..a9f1451 100644
--- a/tour/basic-read-write.md
+++ b/tour/basic-read-write.md
@@ -1,5 +1,53 @@
---
-title: Basic Reading & Writing
+title: Writing and Reading
---
+Accumulo is a big data key/value store. Writing data to Accumulo is flexible
and fast. Like any database, Accumulo stores
+data in tables and rows. Each row in an Accumulo table can hold many
key/value pairs.
-Talk about reading and writing.
+Here are the steps for writing to a table and then reading from it. Copy and
paste the code below into the _exercise_ method. Note each step is commented.
+```java
+ // 1. Connect to Mini Accumulo as the root user and create a table
called "GothamPD".
+ Connector conn = mac.getConnector("root", "tourguide");
+ conn.tableOperations().create("GothamPD");
+
+ // 2. Create a Mutation object to hold all changes to a row in a
table. Each row has a unique row ID.
+ Mutation mutation = new Mutation("id0001");
+
+ // 3. Create key/value pairs for Batman. Put them in the "hero"
family.
+ mutation.put("hero","alias", "Batman");
+ mutation.put("hero","name", "Bruce Wayne");
+ mutation.put("hero","wearsCape?", "true");
+
+ // 4. Create a BatchWriter to the GothamPD table and add your mutation
to it. Try w/ resources will close for us.
+ try(BatchWriter writer = conn.createBatchWriter("GothamPD", new
BatchWriterConfig())) {
+ writer.addMutation(mutation);
+ }
+
+ // 5. Read and print all rows of the "GothamPD" table. Try w/
resources will close for us.
+ try(Scanner scan = conn.createScanner("GothamPD",
Authorizations.EMPTY)) {
+ System.out.println("Gotham Police Department Persons of
Interest:");
+ // A Scanner is an extension of java.lang.Iterable so behaves just
like one.
+ for (Map.Entry<Key, Value> entry : scan) {
+ System.out.println("Key:" + entry.getKey());
+ System.out.println("Value:" + entry.getValue());
+ }
+ }
+```
+
+Build and run your code
+```commandline
+mvn -q clean compile exec:java
+```
+
+Good job! That is all it takes to write and read from Accumulo.
+
+Notice a lot of other information was printed from the Keys we created.
Accumulo is flexible because hidden within its
+Key is a rich data model that can be broken up into different parts. We will
cover the [Data Model][dmodel] in the next lesson.
+
+### But wait... I thought Accumulo was all about Security?
+Spoiler Alert: it is! Did you notice the _Authorizations.EMPTY_ we passed to
the Scanner on step 5? The data
+we created in this first lesson was not secured with Authorizations so the
Scanner didn't require any Authorizations
+to read it. More to come later in the [Authorizations][auths] lesson!
+
+[dmodel]: /tour/data-model
+[auths]: /tour/authorizations
\ No newline at end of file
diff --git a/tour/batch-scanner-code.md b/tour/batch-scanner-code.md
new file mode 100644
index 0000000..bb06de4
--- /dev/null
+++ b/tour/batch-scanner-code.md
@@ -0,0 +1,42 @@
+---
+title: Batch Scanner Code
+---
+```java
+ // Connect to Mini Accumulo as the root user and create a table called
"GothamPD".
+ Connector conn = mac.getConnector("root", "tourguide");
+ conn.tableOperations().create("GothamPD");
+
+ // Generate 10,000 rows of henchman data
+ try(BatchWriter writer = conn.createBatchWriter("GothamPD", new
BatchWriterConfig())) {
+ for(int i = 0; i < 10_000; i++) {
+ Mutation m = new Mutation(String.format("id%04d", i));
+ m.put("villain", "alias", "henchman" + i);
+ m.put("villain", "yearsOfService", "" + (new
Random().nextInt(50)));
+ m.put("villain", "wearsCape?", "false");
+ writer.addMutation(m);
+ }
+ }
+
+ // 1. Create a BatchScanner with 5 query threads
+ try(BatchScanner batchScanner = conn.createBatchScanner("GothamPD",
Authorizations.EMPTY, 5)) {
+ // 2. Create a collection of 2 sample ranges and set it to the
batchScanner
+ List ranges = new ArrayList<Range>();
+ ranges.add(new Range("id1000", "id1999"));
+ ranges.add(new Range("id9000", "id9999"));
+ batchScanner.setRanges(ranges);
+
+ // 3. Fetch just the columns we want
+ batchScanner.fetchColumn(new Text("villain"), new
Text("yearsOfService"));
+
+ // 4. Calculate average years of service
+ Long totalYears = 0L;
+ Long entriesRead = 0L;
+ for (Map.Entry<Key, Value> entry : batchScanner) {
+ totalYears += Long.valueOf(entry.getValue().toString());
+ entriesRead++;
+ }
+ System.out.println("Out of " + entriesRead + " entries, average
years of a henchman: " + totalYears / entriesRead);
+ }
+```
+
+The average years of a henchman should be 24.
\ No newline at end of file
diff --git a/tour/batch-scanner.md b/tour/batch-scanner.md
index 2eb8eb1..21a15f3 100644
--- a/tour/batch-scanner.md
+++ b/tour/batch-scanner.md
@@ -1,3 +1,38 @@
---
title: Batch Scanner
---
+Running on a single thread, a Scanner will retrieve a single Range of data and
return Keys in sorted order. A [BatchScanner]
+will retrieve multiple Ranges of data using multiple threads. A BatchScanner
can be more efficient but does not guarantee Keys will be returned in sorted
order.
+
+For this exercise, we need to generate a bunch of data to test BatchScanner.
Copy the code below into the _exercise_ method.
+```java
+ // Connect to Mini Accumulo as the root user and create a table called
"GothamPD".
+ Connector conn = mac.getConnector("root", "tourguide");
+ conn.tableOperations().create("GothamPD");
+
+ // Generate 10,000 rows of henchman data, each with a different number
yearsOfService
+ try(BatchWriter writer = conn.createBatchWriter("GothamPD", new
BatchWriterConfig())) {
+ for(int i = 0; i < 10_000; i++) {
+ Mutation m = new Mutation(String.format("id%04d", i));
+ m.put("villain", "alias", "henchman" + i);
+ m.put("villain", "yearsOfService", "" + (new
Random().nextInt(50)));
+ m.put("villain", "wearsCape?", "false");
+ writer.addMutation(m);
+ }
+ }
+```
+We want to calculate the average years of service of a sample of the henchman
data. A BatchScanner would be good for this task because we
+don't need the returned keys to be sorted. Follow these steps to efficiently
scan the table with 10,000 entries.
+
+1. After the above code, create a BatchScanner with 5 query threads. Similar
to a Scanner, use the [createBatchScanner] method.
+
+2. Create an ArrayList of 2 sample Ranges (id1000 to id1999 and id9000 to
id9999) and set the ranges of the BatchScanner using _setRanges_.
+
+3. We can make the scan more efficient by only bringing back the columns we
want. Use [fetchColumn] to get the "villain" family
+and "yearsOfService" qualifier.
+
+4. Finally, use the BatchScanner to calculate the average years of service of
the henchmen.
+
+[BatchScanner]:
https://accumulo.apache.org/1.8/apidocs/org/apache/accumulo/core/client/BatchScanner.html
+[createBatchScanner]:
https://accumulo.apache.org/1.8/apidocs/org/apache/accumulo/core/client/Connector.html#createBatchScanner(java.lang.String,%20org.apache.accumulo.core.security.Authorizations,%20int)
+[fetchColumn]:
https://accumulo.apache.org/1.8/apidocs/org/apache/accumulo/core/client/ScannerBase.html#fetchColumn(org.apache.hadoop.io.Text,%20org.apache.hadoop.io.Text)
\ No newline at end of file
diff --git a/tour/data-model-code.md b/tour/data-model-code.md
new file mode 100644
index 0000000..4a0d0e8
--- /dev/null
+++ b/tour/data-model-code.md
@@ -0,0 +1,58 @@
+---
+title: Data Model Code
+---
+
+```java
+ // Connect to Mini Accumulo as the root user and create a table called
"GothamPD".
+ Connector conn = mac.getConnector("root", "tourguide");
+ conn.tableOperations().create("GothamPD");
+
+ // Create a row for Batman
+ Mutation mutation1 = new Mutation("id0001");
+ mutation1.put("hero","alias", "Batman");
+ mutation1.put("hero","name", "Bruce Wayne");
+ mutation1.put("hero","wearsCape?", "true");
+
+ // Create a row for Robin
+ Mutation mutation2 = new Mutation("id0002");
+ mutation2.put("hero","alias", "Robin");
+ mutation2.put("hero","name", "Dick Grayson");
+ mutation2.put("hero","wearsCape?", "true");
+
+ // Create a row for Joker
+ Mutation mutation3 = new Mutation("id0003");
+ mutation3.put("villain","alias", "Joker");
+ mutation3.put("villain","name", "Unknown");
+ mutation3.put("villain","wearsCape?", "false");
+
+ // Create a BatchWriter to the GothamPD table and add your mutations
to it.
+ // Once the BatchWriter is closed by the try w/ resources, data will
be available to scans.
+ try(BatchWriter writer = conn.createBatchWriter("GothamPD", new
BatchWriterConfig())) {
+ writer.addMutation(mutation1);
+ writer.addMutation(mutation2);
+ writer.addMutation(mutation3);
+ }
+
+ // Read and print all rows of the "GothamPD" table. Try w/ resources
will close for us.
+ try(Scanner scan = conn.createScanner("GothamPD",
Authorizations.EMPTY)) {
+ System.out.println("Gotham Police Department Persons of
Interest:");
+ // A Scanner is an extension of java.lang.Iterable so behaves just
like one.
+ for (Map.Entry<Key, Value> entry : scan) {
+ System.out.printf("Key : %30s Value : %s\n", entry.getKey(),
entry.getValue());
+ }
+ }
+```
+
+The code above will print (timestamp will differ):
+```commandline
+Gotham Police Department Persons of Interest:
+Key : id0001 hero:alias [] 1511306370025 false Value : Batman
+Key : id0001 hero:name [] 1511306370025 false Value : Bruce Wayne
+Key : id0001 hero:wearsCape? [] 1511306370025 false Value : true
+Key : id0002 hero:alias [] 1511306370025 false Value : Robin
+Key : id0002 hero:name [] 1511306370025 false Value : Dick Grayson
+Key : id0002 hero:wearsCape? [] 1511306370025 false Value : true
+Key : id0003 villain:alias [] 1511306370025 false Value : Joker
+Key : id0003 villain:name [] 1511306370025 false Value : Unknown
+Key : id0003 villain:wearsCape? [] 1511306370025 false Value : false
+```
\ No newline at end of file
diff --git a/tour/data-model.md b/tour/data-model.md
new file mode 100644
index 0000000..5580cb4
--- /dev/null
+++ b/tour/data-model.md
@@ -0,0 +1,28 @@
+---
+title: Data Model
+---
+Data is stored in Accumulo in a distributed sorted map. The Keys of the map
are broken up logically into a few different parts,
+as seen in the image below.
+
+
+
+**Row ID** - Unique identifier for the row.<br/>
+**Column Family** - Logical grouping of the key. This field can be used to
partition data within a node.<br/>
+**Column Qualifier** - More specific attribute of the key.<br/>
+**Column Visibility** - Security label controlling access to the key/value
pair.<br/>
+**Timestamp** - Generated automatically and used for versioning.
+
+The **value** is where the actual data is stored. For brevity, we often refer
to the 3 parts of the column as the family, qualifier and visibility.
+
+Take a closer look at the Mutation object created in the first exercise:
+```java
+Mutation mutation = new Mutation("id0001");
+mutation.put("hero","alias", "Batman");
+```
+It can be broken down as follows: <br/>
+**Row ID**: id0001 **Column Family**: hero **Column Qualifier**: alias
**Value**: Batman
+
+For this exercise add a few more rows to the GothamDB table. Create a row for
Robin (id0002), who is a hero that also wears a cape
+and his name is "Dick Grayson". Create a row for Joker (id0003), who is a
villain with an "Unknown" name and doesn't wear a cape. Build and run.
+
+Notice how the data is printed in sorted order. Accumulo sorts by Row ID then
family and then qualifier.
\ No newline at end of file
diff --git a/tour/getting-started.md b/tour/getting-started.md
index 0b076c1..50bc980 100644
--- a/tour/getting-started.md
+++ b/tour/getting-started.md
@@ -2,4 +2,31 @@
title: Getting Started
---
-Talk about how to get started.
+First make sure you have Java, Maven and Git installed on your machine. Oh
you are already rocking? OK let's go!
+
+1. Clone the tour onto your machine:
+```commandline
+git clone -b tour https://github.com/apache/accumulo-website.git tour
+cd tour
+```
+2. Open [Main.java] in your favorite editor.
+```commandline
+vim ./src/main/java/tour/Main.java
+```
+Notice the main method creates a MiniAccumuloCluster with a root password of
"tourguide". MiniAccumuloCluster is a mini
+version of Accumulo that runs on your local filesystem. It should only be
used for development purposes but will work
+great here on the tour. Files and logs used by MiniAccumuloCluster can be
seen in the _target/mac######_ directory.
+
+3. Modify the _exercise_ method to print a hello message. You will put your
code in this method for each lesson.
+```java
+private static void exercise(MiniAccumuloCluster mac) {
+ // start writing your code here
+ System.out.println("Hello world");
+}
+```
+4. Build and run to make sure everything is cool.
+```commandline
+mvn -q clean compile exec:java
+```
+
+[Main.java]:
https://github.com/apache/accumulo-website/blob/tour/src/main/java/tour/Main.java
diff --git a/tour/index.md b/tour/index.md
index 9217637..2aac4f2 100644
--- a/tour/index.md
+++ b/tour/index.md
@@ -9,13 +9,12 @@ skiph1fortitle: true
{% assign first_url = tour_pages[0] | prepend: '/tour/' | append: '/' %}
{% assign first_page = site.pages | where:'url',first_url | first %}
-Welcome to the Accumulo tour! The tour offers a hands on introduction to
Accumulo, broken down into
-independent steps and an exercise. The exercise gives you a chance to apply
what you have learned.
-The tour starts with a [{{ first_page.title }}]({{ first_url }}) page that
will help you set up
-the exercise on your machine.
+Welcome to the Accumulo tour! The tour offers a hands on introduction to the
Accumulo Java API, broken down into
+independent steps and exercises. The exercises give you a chance to apply what
you have learned by writing code on your
+own. The answers to an exercise are typically provided in the next step. The
tour starts with a
+[{{ first_page.title }}]({{ first_url }}) page that will help you get set up.
-We recommend following the tour in order. However, all pages are listed below
for review. When on a
-tour page, the left and right keys on the keyboard can be used to navigate. If
you have any questions
+When on a tour page, the left and right keys on the keyboard can be used to
navigate. If you have any questions
or suggestions while going through the tour, please send an email to our
[mailing list][mlist]
or [create an issue][issue].
diff --git a/tour/ranges-splits.md b/tour/ranges-splits.md
new file mode 100644
index 0000000..327d703
--- /dev/null
+++ b/tour/ranges-splits.md
@@ -0,0 +1,36 @@
+---
+title: Ranges and Splits
+---
+
+A Range is a specified group of Keys. There are many different ways to create
a Range. Here are a few examples:
+```java
+new Range(Key startKey, Key endKey) // Creates a range from startKey
inclusive to endKey inclusive.
+new Range(CharSequence row) // Creates a range that covers an entire row.
+new Range(CharSequence startRow, CharSequence endRow) // Creates a range from
startRow inclusive to endRow inclusive.
+```
+
+A Scanner by default will scan all Keys in a table but this can be
inefficient. It is a good practice to set a range on a Scanner.
+```java
+scanner.setRange(new Range("id0000", "id0010")); // returns rows from id0000
to id0010
+```
+
+As your data grows larger, Accumulo will split tables into smaller pieces
called Tablets. Tablets can then be distributed across multiple Tablet
Servers.
+By default a table will get split into Tablets on row boundaries, guaranteeing
an entire row to be on one Tablet Server. We have the ability to
+tell Accumulo were to split tables by setting split points. This is done using
_addSplits_ in the [TableOperations] API. The image below
+demonstrates how Accumulo splits data.
+
+
+
+Take a minute to learn these Accumulo terms:
+* **Tablet** - A partition of a table.
+* **Split** - A point where tables are partitioned into separate tablets.
+* **Flush** - Action taken when data is written from memory to disk.
+* **Compact** - Action taken when files on disk are consolidated.
+* **Iterator** - A server side mechanism that can filter and modify Key/Value
pairs.
+
+Knowing these terms are critical when working closely with Accumulo.
Iterators are especially unique and powerful. More on them later.
+
+When working with large amounts of data across many Tablet Servers, a simple
Scanner might not do the trick. Next lesson we learn about the power of
+the multi-threaded BatchScanner!
+
+[TableOperations]:
https://accumulo.apache.org/1.8/apidocs/org/apache/accumulo/core/client/admin/TableOperations.html
\ No newline at end of file
--
To stop receiving notification emails like this one, please contact
['"commits@accumulo.apache.org" <commits@accumulo.apache.org>'].
