update readme

Author: giometrix

README.md

@@ -188,6 +188,40 @@ Note that our table store was ```PocoTableStore<Employee, int, int>```, but that
 ```var record = tableStore.GetRecord(142, "user");```
 which is both clear and provides type safety.
 
+#### Sequential Keys
+`SequentialKeyMapper` was introduced in v2.6 and is a bit different from other key mappers because the output isn't meant for point lookups.  This key mapper assigns keys in sequential order (forward or backward).  Because Azure Table Storage orders rows by row key, a sequential key allows you to use Azure Table Storage as a log.  
+
+Coupled with TODO , you can do things like saving a historical record when mutating your main table entity.
+
+Example:
+```csharp
+var pKeyMapper = new KeyMapper<Employee, int>(e => e.Id.ToString(), int.Parse, e => e.Id, id => id.ToString());
+
+var rKeyMapper = new SequentialKeyMapper<Employee, int>(true);
+
+var keysConverter = new CalculatedKeysConverter<Employee, int, int>(pKeyMapper, rKeyMapper);
+
+tableStore = new PocoTableStore<Employee, int, int>("TestEmployee", "UseDevelopmentStorage=true", keysConverter);
+
+var employee = new Employee
+			{
+				CompanyId = 1,
+				Id = 242443,
+				Name = "1",
+				Department = new Department { Id = 22, Name = "Executive" }
+			};
+
+tableStore.Insert(employee);
+
+employee.Name = "2";
+tableStore.Insert(employee);
+
+employee.Name = "3";
+tableStore.Insert(employee);
+
+// order will be 3, 2, 1 because we are sorting in sequential order						
+```
+
 ### Further Filtering (Beyond Partition & Row Keys)
 New to v1.2, we now include the ability to filter on properties outside of partition and row keys.  Please note that this filtering occurs outside of table storage, so please consider using at least the partition key for best results.
 

src/TableStorage.Abstractions.POCO.SecondaryIndexes/README.md

@@ -0,0 +1,101 @@
+# TableStorage.Abstractions.POCO.SecondaryIndexes
+[![Build status](https://ci.appveyor.com/api/projects/status/fx9j8yc06s9ib4n9?svg=true)]
+
+This project builds on top of [TableStorage.Abstractions.POCO](https://github.com/giometrix/TableStorage.Abstractions.POCO) to introduce "secondary indexes" to [Azure Table Storage](https://github.com/giometrix/TableStorage.Abstractions.POCO). Internally this library uses an [intra/inter partition (or table) secondary index pattern](https://docs.microsoft.com/en-us/azure/storage/tables/table-storage-design-patterns).  When data gets mutated on your table store, the library takes care of reflecting the change in your secondary indexes.
+
+## Caveats And Notes
+1. Indexes are managed through a library, _not_ Table Storage, thus data mutated outside of the library will not automatically be reflected in your indexes.
+2. Though Azure Table Storage does offer transactions within partitions, this library does not leverage this at this time.
+3. This library is intended for Azure Table Storage, not CosmosDB, which offers an Azure Table Storage API.  CosmosDB does offer secondary indexes, so this library may not be as useful there.
+
+## Examples
+Note that it may be useful to read about [TableStorage.Abstractions.POCO](https://github.com/giometrix/TableStorage.Abstractions.POCO) to better understand the examples below.
+
+All of the examples will use the following classes:
+```csharp
+public class Employee
+{
+	public int CompanyId { get; set; }
+	public int Id { get; set; }
+	public string Name { get; set; }
+	public Department Department { get; set; }
+}
+
+public class Department
+{
+	public int Id { get; set; }
+	public string Name { get; set; }
+}
+```
+### Instantiation
+Indexes are just regular `PocoTableStore`s so you instantiate them like any other `PocoTableStore`.  Here we instantiate the entity store and an index store.  The `PocoTableStore` named `TableStore` will store records using `CompanyId` as a partition key, and `Id` as the row key.  The `PocoTableStore` named `IndexStore` will store records using `CompanyId` as the partition key, and `Name` as the row key.  In this example they use different tables.
+
+``` csharp
+TableStore = new PocoTableStore<Employee, int, int>("IXTestEmployee", "UseDevelopmentStorage=true", e => e.CompanyId, e => e.Id);
+
+IndexStore = new PocoTableStore<Employee, int, string>("IXTestEmployeeNameIndex", "UseDevelopmentStorage=true", e => e.CompanyId, e => e.Name);
+```
+
+Next we tie them together by using `AddIndex()`.  Indexes must be given a name so that you can specify which index to use when querying.  Hete we name our index "Name."
+
+``` charp
+TableStore.AddIndex("Name", IndexStore);
+```
+After adding the index, mutations that happen on `TableStore` will result in mutations in `IndexStore`.  For instance, if we insert a record as seen below, we can expect to find a corresponding record in `IndexStore.`
+
+``` charp
+var employee = new Employee
+{
+	Name = "Test",
+	CompanyId = 99,
+	Id = 99,
+	Department = new Department { Id = 5, Name = "Test" }
+};
+TableStore.Insert(employee);
+```
+
+### Fetching Data
+To fetch a single data point from the index, we use the `GetRecordByIndex` (or `GetRecordByIndexAsync`) extension method on the entity `PocoTableStore` (note that we are doing this on the main data store, not on the index, as a convenience):
+``` charp
+var e = TableStore.GetRecordByIndex("Name", 99, "Test");
+```
+
+Sometimes it may be useful to fetch all of the records from a partition for an index, such as historical data (described later).  Example:
+``` csharp
+var records = await TableStore.GetByIndexPartitionKeyAsync("Name", 99);
+```
+
+One use of this pattern can be to store the current entity in the main entity store, and to keep historical data in a separate table.  Here is an example of this pattern:
+``` csharp
+var pKeyMapper = new KeyMapper<Employee, int>(e => e.Id.ToString(), int.Parse, e => e.Id, id => id.ToString());
+
+var rKeyMapper = new SequentialKeyMapper<Employee, int>(true);
+
+var keysConverter = new CalculatedKeysConverter<Employee, int, int>(pKeyMapper, rKeyMapper);
+
+var logStore =
+				new PocoTableStore<Employee, int, int>("IXLogIndex", "UseDevelopmentStorage=true", keysConverter);
+
+TableStore.AddIndex("Log", logStore);
+
+```
+In the example above we create an index called "Log", which will use `Id` as the partition key and a decreasing sequence number for row key (so that the most recent record is always on top).  
+
+If we want to fetch the history for employee 99, we do the following:
+``` csharp
+var records = TableStore.GetByPartitionKey(99);
+```
+
+### Removing An Index
+To remove an index without deleting data, use the `Reindex()` or `ReindexAsync()` extension method.
+
+### Dropping An Index
+To remove _and_ drop an index without deleting data, use the `DropIndex()` or `DropIndexAsync()` extension method.  Deleting the original table will also drop all indexes on that table.
+
+### Seeding Or Reindexing
+If you are adding an index to an existing table that already has data, or if for some reason data gets out of sync, you can use the `Reindex()` extension method, shown below.  Note that this method is not  yet optimized (for instance no batching is currently used).  On my machine home internet connection, and data size, it took 22 minutes to index 1 million rows.
+
+``` charp
+await TableStore.ReindexAsync("Name", maxDegreeOfParallelism: 20, recordsIndexedCallback: i=>count = i);
+```
+Call backs are available to get status updates and errors.

tests/TableStorage.Abstractions.POCO.Tests/PocoTableStoreTests.cs

@@ -1894,26 +1894,11 @@ public void insert_record_with_sequential_row_key_sorts_correctly()
 
 			Clock.AsMockClock().Adjust(1000);
 
-			employee = new Employee
-			{
-				CompanyId = 1,
-				Id = 242443,
-				Name = "2",
-				Department = new Department { Id = 22, Name = "Executive" }
-			};
-
+			employee.Name = "2";
 			tableStore.Insert(employee);
 			Clock.AsMockClock().Adjust(1000);
 
-			employee = new Employee
-			{
-				CompanyId = 1,
-				Id = 242443,
-				Name = "3",
-				Department = new Department { Id = 22, Name = "Executive" }
-			};
-
-
+			employee.Name = "3";
 			tableStore.Insert(employee);
 			Clock.AsMockClock().Adjust(1000);