accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mwa...@apache.org
Subject [accumulo-website] 02/07: ACCUMULO-4734 Create a few exercises for the tour
Date Wed, 06 Dec 2017 16:20:44 GMT
This is an automated email from the ASF dual-hosted git repository.

mwalch pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/accumulo-website.git

commit 8aac928989901c3cb84941ee0b41bcaacf943e23
Author: Mike Miller <mmiller@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.
+
+![key value pair]({{ site.url }}/images/docs/key_value.png)
+
+**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.  
+
+![data distribution]({{ site.url }}/images/docs/data_distribution.png)
+
+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>.

Mime
View raw message