public void When_I_Scan_with_a_RandomRowFilter_I_get_the_expected_results()
{
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
// set this large enough so that we get all records back
var filter = new RandomRowFilter(2000.0F);
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(_allExpectedRecords);
}
public void When_I_Scan_with_a_ColumnRangeFilter_I_get_the_expected_results()
{
List <FilterTestRecord> expectedRecords = (from r in _allExpectedRecords select r.WithLineNumberValue(0).WithBValue(null)).ToList();
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
var filter = new ColumnRangeFilter(Encoding.UTF8.GetBytes(ColumnNameA), true, Encoding.UTF8.GetBytes(ColumnNameB), false);
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
public void When_I_Scan_with_a_QualifierFilter_I_get_the_expected_results()
{
List <FilterTestRecord> expectedRecords = (from r in _allExpectedRecords select r.WithAValue(null).WithBValue(null)).ToList();
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
var filter = new QualifierFilter(CompareFilter.CompareOp.Equal, new BinaryComparator(Encoding.UTF8.GetBytes(LineNumberColumnName)));
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
public void TestScannerCreation()
{
var client = new HBaseClient(_credentials);
var batchSetting = new Scanner {
batch = 2
};
ScannerInformation scannerInfo = client.CreateScanner(_testTableName, batchSetting);
Assert.AreEqual(_testTableName, scannerInfo.TableName);
Assert.IsTrue(
scannerInfo.Location.Authority.StartsWith("headnode", StringComparison.Ordinal),
"returned location didn't start with \"headnode\", it was: {0}",
scannerInfo.Location);
}
public void When_I_Scan_with_a_SkipFilter_I_get_the_expected_results()
{
List <FilterTestRecord> expectedRecords = (from r in _allExpectedRecords where r.LineNumber != 0 select r).ToList();
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
var filter = new SkipFilter(new ValueFilter(CompareFilter.CompareOp.NotEqual, new BinaryComparator(BitConverter.GetBytes(0))));
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
public void When_I_Scan_with_a_ColumnCountGetFilter_I_get_the_expected_results()
{
// B column should not be returned, so set the value to null.
List <FilterTestRecord> expectedRecords = (from r in _allExpectedRecords select r.WithBValue(null)).ToList();
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
var filter = new ColumnCountGetFilter(2);
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
public void When_I_Scan_with_a_ColumnPaginationFilter_I_get_the_expected_results()
{
// only grabbing the LineNumber column with (1, 1)
List <FilterTestRecord> expectedRecords = (from r in _allExpectedRecords select r.WithAValue(null).WithBValue(null)).ToList();
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
var filter = new ColumnPaginationFilter(1, 1);
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
private IEnumerable <FilterTestRecord> RetrieveResults(ScannerInformation scanInfo)
{
var rv = new List <FilterTestRecord>();
var client = new HBaseClient(RequestOptionsFactory.GetDefaultOptions());
CellSet next;
while ((next = client.ScannerGetNextAsync(scanInfo).Result) != null)
{
foreach (var row in next.Rows)
{
var rowKey = row.Key.ToStringUtf8();
var cells = row.Values;
string a = null;
string b = null;
var lineNumber = 0;
foreach (var c in cells)
{
var columnName = ExtractColumnName(c.Column);
switch (columnName)
{
case LineNumberColumnName:
lineNumber = c.Data.Length > 0 ? BitConverter.ToInt32(c.Data.ToByteArray(), 0) : 0;
break;
case ColumnNameA:
a = c.Data.ToStringUtf8();
break;
case ColumnNameB:
b = c.Data.ToStringUtf8();
break;
default:
throw new InvalidOperationException("Don't know what to do with column: " + columnName);
}
}
var rec = new FilterTestRecord(rowKey, lineNumber, a, b);
rv.Add(rec);
}
}
return(rv);
}
private IEnumerable <FilterTestRecord> RetrieveResults(ScannerInformation scanInfo)
{
var rv = new List <FilterTestRecord>();
var client = new HBaseClient(_credentials);
CellSet next;
while ((next = client.ScannerGetNext(scanInfo)) != null)
{
foreach (CellSet.Row row in next.rows)
{
string rowKey = _encoding.GetString(row.key);
List <Cell> cells = row.values;
string a = null;
string b = null;
int lineNumber = 0;
foreach (Cell c in cells)
{
string columnName = ExtractColumnName(c.column);
switch (columnName)
{
case LineNumberColumnName:
lineNumber = c.data.Length > 0 ? BitConverter.ToInt32(c.data, 0) : 0;
break;
case ColumnNameA:
a = _encoding.GetString(c.data);
break;
case ColumnNameB:
b = _encoding.GetString(c.data);
break;
default:
throw new InvalidOperationException("Don't know what to do with column: " + columnName);
}
}
var rec = new FilterTestRecord(rowKey, lineNumber, a, b);
rv.Add(rec);
}
}
return(rv);
}
public void When_I_Scan_with_a_KeyOnlyFilter_I_get_the_expected_results()
{
// a key only filter does not return column values
List <FilterTestRecord> expectedRecords =
(from r in _allExpectedRecords select new FilterTestRecord(r.RowKey, 0, string.Empty, string.Empty)).ToList();
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
var filter = new KeyOnlyFilter();
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
public void When_I_Scan_with_a_RowFilter_I_get_the_expected_results()
{
FilterTestRecord example = _allExpectedRecords.First();
List <FilterTestRecord> expectedRecords = (from r in _allExpectedRecords where r.RowKey == example.RowKey select r).ToList();
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
var filter = new RowFilter(CompareFilter.CompareOp.Equal, new BinaryComparator(Encoding.UTF8.GetBytes(example.RowKey)));
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
public IEnumerable <FSTweet> ReadAllTweets()
{
Scanner s = new Scanner()
{
batch = 10
};
ScannerInformation si = client.CreateScanner(HadoopContext.TweetTableName, s);
CellSet next = null;
while ((next = client.ScannerGetNext(si)) != null)
{
foreach (CellSet.Row row in next.rows)
{
}
}
return(null);
}
public override void TestSubsetScan()
{
var client = CreateClient();
const int startRow = 15;
const int endRow = 15 + 13;
StoreTestData(client);
// subset range scan
var scanSettings = new Scanner
{
batch = 10,
startRow = BitConverter.GetBytes(startRow),
endRow = BitConverter.GetBytes(endRow)
};
var scanOptions = RequestOptions.GetDefaultOptions();
scanOptions.AlternativeEndpoint = Constants.RestEndpointBaseZero;
ScannerInformation scannerInfo = null;
try
{
scannerInfo = client.CreateScannerAsync(testTableName, scanSettings, scanOptions).Result;
CellSet next;
var expectedSet = new HashSet <int>(Enumerable.Range(startRow, endRow - startRow));
while ((next = client.ScannerGetNextAsync(scannerInfo, scanOptions).Result) != null)
{
foreach (var row in next.rows)
{
var k = BitConverter.ToInt32(row.key, 0);
expectedSet.Remove(k);
}
}
Assert.Empty(expectedSet);
}
finally
{
if (scannerInfo != null)
{
client.DeleteScannerAsync(testTableName, scannerInfo, scanOptions).Wait();
}
}
}
public void When_I_Scan_with_a_InclusiveStopFilter_I_get_the_expected_results()
{
FilterTestRecord example = (from r in _allExpectedRecords where r.LineNumber == 2 select r).Single();
byte[] rawRowKey = Encoding.UTF8.GetBytes(example.RowKey);
List <FilterTestRecord> expectedRecords = (from r in _allExpectedRecords where r.LineNumber <= 2 select r).ToList();
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
var filter = new InclusiveStopFilter(rawRowKey);
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
public void When_I_Scan_with_a_SingleColumnValueFilter_and_a_BinaryComparator_with_the_operator_not_equal_I_get_the_expected_results()
{
List <FilterTestRecord> expectedRecords = (from r in _allExpectedRecords where r.LineNumber != 1 select r).ToList();
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
var filter = new SingleColumnValueFilter(
Encoding.UTF8.GetBytes(ColumnFamilyName1),
Encoding.UTF8.GetBytes(LineNumberColumnName),
CompareFilter.CompareOp.NotEqual,
BitConverter.GetBytes(1));
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
public override void TestFullScan()
{
var client = CreateClient();
StoreTestData(client);
var scanOptions = RequestOptions.GetDefaultOptions();
scanOptions.AlternativeEndpoint = Constants.RestEndpointBaseZero;
// full range scan
var scanSettings = new Scanner {
batch = 10
};
ScannerInformation scannerInfo = null;
try
{
scannerInfo = client.CreateScannerAsync(testTableName, scanSettings, scanOptions).Result;
CellSet next;
var expectedSet = new HashSet <int>(Enumerable.Range(0, 100));
while ((next = client.ScannerGetNextAsync(scannerInfo, scanOptions).Result) != null)
{
Assert.Equal(10, next.rows.Count);
foreach (var row in next.rows)
{
var k = BitConverter.ToInt32(row.key, 0);
expectedSet.Remove(k);
}
}
Assert.Empty(expectedSet);
}
finally
{
if (scannerInfo != null)
{
client.DeleteScannerAsync(testTableName, scannerInfo, scanOptions).Wait();
}
}
}
public void When_I_Scan_with_a_MultipleColumnPrefixFilter_I_get_the_expected_results()
{
List <FilterTestRecord> expectedRecords = (from r in _allExpectedRecords select r.WithLineNumberValue(0)).ToList();
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
// set this large enough so that we get all records back
var prefixes = new List <byte[]> {
Encoding.UTF8.GetBytes(ColumnNameA), Encoding.UTF8.GetBytes(ColumnNameB)
};
var filter = new MultipleColumnPrefixFilter(prefixes);
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
public void When_I_Scan_with_a_FilterList_with_OR_logic_I_get_the_expected_results()
{
var expectedRecords = (from r in _allExpectedRecords where r.LineNumber <= 2 select r).ToList();
var client = new HBaseClient(RequestOptionsFactory.GetDefaultOptions());
var scanner = new Scanner();
Filter f0 = new SingleColumnValueFilter(
Encoding.UTF8.GetBytes(ColumnFamilyName1),
Encoding.UTF8.GetBytes(LineNumberColumnName),
CompareFilter.CompareOp.Equal,
BitConverter.GetBytes(1));
Filter f1 = new SingleColumnValueFilter(
Encoding.UTF8.GetBytes(ColumnFamilyName1),
Encoding.UTF8.GetBytes(LineNumberColumnName),
CompareFilter.CompareOp.LessThanOrEqualTo,
BitConverter.GetBytes(2));
var filter = new FilterList(FilterList.Operator.MustPassOne, f0, f1);
scanner.Filter = filter.ToEncodedString();
ScannerInformation scanInfo = null;
try
{
scanInfo = client.CreateScannerAsync(_tableName, scanner).Result;
var actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
finally
{
if (scanInfo != null)
{
client.DeleteScannerAsync(_tableName, scanInfo).Wait();
}
}
}
private IEnumerable <long> RetrieveTimestamps(ScannerInformation scanInfo)
{
var rv = new HashSet <long>();
var client = new HBaseClient(RequestOptionsFactory.GetDefaultOptions());
CellSet next;
while ((next = client.ScannerGetNextAsync(scanInfo).Result) != null)
{
foreach (var row in next.Rows)
{
var cells = row.Values;
foreach (var c in cells)
{
rv.Add(c.Timestamp);
}
}
}
return(rv);
}
public void When_I_Scan_with_a_TimestampsFilter_I_get_the_expected_results()
{
List <FilterTestRecord> expectedRecords = _allExpectedRecords;
// scan all and retrieve timestamps
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
ScannerInformation scanAll = client.CreateScanner(_tableName, scanner);
List <long> timestamps = RetrieveTimestamps(scanAll).ToList();
// timestamps scan
scanner = new Scanner();
var filter = new TimestampsFilter(timestamps);
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
private IEnumerable <long> RetrieveTimestamps(ScannerInformation scanInfo)
{
var rv = new HashSet <long>();
var client = new HBaseClient(_credentials);
CellSet next;
while ((next = client.ScannerGetNext(scanInfo)) != null)
{
foreach (CellSet.Row row in next.rows)
{
List <Cell> cells = row.values;
foreach (Cell c in cells)
{
rv.Add(c.timestamp);
}
}
}
return(rv);
}
public IEnumerable <FSWordRelationship> ReadAllWordRelationships()
{
Scanner s = new Scanner()
{
batch = 10
};
ScannerInformation si = client.CreateScanner(HadoopContext.WordRelationTableName, s);
CellSet next = null;
CellSet readRows = new CellSet();
while ((next = client.ScannerGetNext(si)) != null)
{
foreach (CellSet.Row row in next.rows)
{
//convert row into desired domain type....
readRows.rows.Add(row);
}
}
return(null);
}
public void When_I_Scan_with_a_PrefixFilter_I_get_the_expected_results()
{
var example = _allExpectedRecords.First();
var rawRowKey = Encoding.UTF8.GetBytes(example.RowKey);
const int prefixLength = 4;
var prefix = new byte[prefixLength];
Array.Copy(rawRowKey, prefix, prefixLength);
var expectedRecords = (from r in _allExpectedRecords
let rawKey = ByteString.CopyFromUtf8(r.RowKey)
where rawKey[0] == prefix[0] && rawKey[1] == prefix[1] && rawKey[2] == prefix[2] && rawKey[3] == prefix[3]
select r).ToList();
var client = new HBaseClient(RequestOptionsFactory.GetDefaultOptions());
var scanner = new Scanner();
var filter = new PrefixFilter(prefix);
scanner.Filter = filter.ToEncodedString();
ScannerInformation scanInfo = null;
try
{
scanInfo = client.CreateScannerAsync(_tableName, scanner).Result;
var actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
finally
{
if (scanInfo != null)
{
client.DeleteScannerAsync(_tableName, scanInfo).Wait();
}
}
}
public void When_I_Scan_all_I_get_the_expected_results()
{
var client = new HBaseClient(RequestOptionsFactory.GetDefaultOptions());
var scan = new Scanner();
ScannerInformation scanInfo = null;
try
{
scanInfo = client.CreateScannerAsync(_tableName, scan).Result;
var actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(_allExpectedRecords);
}
finally
{
if (scanInfo != null)
{
client.DeleteScannerAsync(_tableName, scanInfo).Wait();
}
}
}
public void TestFullScan()
{
var client = CreateClient();
StoreTestData(client);
// full range scan
var scanSettings = new Scanner {
Batch = 10
};
ScannerInformation scannerInfo = null;
try
{
scannerInfo = client.CreateScannerAsync(TestTableName, scanSettings).Result;
CellSet next;
var expectedSet = new HashSet <int>(Enumerable.Range(0, 100));
while ((next = client.ScannerGetNextAsync(scannerInfo).Result) != null)
{
Assert.Equal(10, next.Rows.Count);
foreach (var row in next.Rows)
{
var k = BitConverter.ToInt32(row.Key.ToByteArray(), 0);
expectedSet.Remove(k);
}
}
Assert.True(0 == expectedSet.Count, $"The expected set wasn't empty! Items left {string.Join(",", expectedSet)}!");
}
finally
{
if (scannerInfo != null)
{
client.DeleteScannerAsync(TestTableName, scannerInfo).Wait();
}
}
}
public void When_I_Scan_with_a_SingleColumnValueFilter_and_a_SubstringComparator_with_the_operator_equal_I_get_the_expected_results()
{
// grab a substring that is guaranteed to match at least one record.
var ss = _allExpectedRecords.First().A.Substring(1, 2);
//Debug.WriteLine("The substring value is: " + ss);
var expectedRecords = (from r in _allExpectedRecords where r.A.Contains(ss) select r).ToList();
var client = new HBaseClient(RequestOptionsFactory.GetDefaultOptions());
var scanner = new Scanner();
var comparer = new SubstringComparator(ss);
var filter = new SingleColumnValueFilter(
Encoding.UTF8.GetBytes(ColumnFamilyName1),
Encoding.UTF8.GetBytes(ColumnNameA),
CompareFilter.CompareOp.Equal,
comparer);
scanner.Filter = filter.ToEncodedString();
ScannerInformation scanInfo = null;
try
{
scanInfo = client.CreateScannerAsync(_tableName, scanner).Result;
var actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
finally
{
if (scanInfo != null)
{
client.DeleteScannerAsync(_tableName, scanInfo).Wait();
}
}
}
public void TestSubsetScan()
{
var client = CreateClient();
const int startRow = 15;
const int endRow = 15 + 13;
StoreTestData(client);
// subset range scan
var scanSettings = new Scanner {
Batch = 10, StartRow = ByteString.CopyFrom(BitConverter.GetBytes(startRow)), EndRow = ByteString.CopyFrom(BitConverter.GetBytes(endRow))
};
ScannerInformation scannerInfo = null;
try
{
scannerInfo = client.CreateScannerAsync(TestTableName, scanSettings).Result;
CellSet next;
var expectedSet = new HashSet <int>(Enumerable.Range(startRow, endRow - startRow));
while ((next = client.ScannerGetNextAsync(scannerInfo).Result) != null)
{
foreach (var row in next.Rows)
{
var k = BitConverter.ToInt32(row.Key.ToByteArray(), 0);
expectedSet.Remove(k);
}
}
Assert.True(0 == expectedSet.Count, $"The expected set wasn't empty! Items left {string.Join(",", expectedSet)}!");
}
finally
{
if (scannerInfo != null)
{
client.DeleteScannerAsync(TestTableName, scannerInfo).Wait();
}
}
}
public void When_I_Scan_with_a_SingleColumnValueExcludeFilter_and_a_BinaryComparator_with_the_operator_equal_I_get_the_expected_results()
{
string bValue = (from r in _allExpectedRecords select r.B).First();
// B column should not be returned, so set the value to null.
List <FilterTestRecord> expectedRecords = (from r in _allExpectedRecords where r.B == bValue select r.WithBValue(null)).ToList();
var client = new HBaseClient(_credentials);
var scanner = new Scanner();
var filter = new SingleColumnValueExcludeFilter(
Encoding.UTF8.GetBytes(ColumnFamilyName2),
Encoding.UTF8.GetBytes(ColumnNameB),
CompareFilter.CompareOp.Equal,
Encoding.UTF8.GetBytes(bValue));
scanner.filter = filter.ToEncodedString();
ScannerInformation scanInfo = client.CreateScanner(_tableName, scanner);
List <FilterTestRecord> actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
public IEnumerable <FSWordRelationship> FindRelationsWithWord(string word)
{
Scanner s = new Scanner()
{
batch = 1000
};
ScannerInformation si = client.CreateScanner(HadoopContext.HBaseWordRelationTableName, s);
CellSet next = null;
CellSet readRows = new CellSet();
List <FSWordRelationship> relations = new List <FSWordRelationship>();
while ((next = client.ScannerGetNext(si)) != null)
{
foreach (CellSet.Row row in next.rows)
{
//convert row into desired domain type....
var w1 = row.values.Find(w => Encoding.UTF8.GetString(w.column) == "d:WordOne");
string wordOne = Encoding.UTF8.GetString(w1.data);
var w1Id = row.values.Find(w => Encoding.UTF8.GetString(w.column) == "d:WordOneId");
int wordOneId = Convert.ToInt32(Encoding.UTF8.GetString(w1Id.data));
var w2 = row.values.Find(w => Encoding.UTF8.GetString(w.column) == "d:WordTwo");
string wordTwo = Encoding.UTF8.GetString(w2.data);
var w2Id = row.values.Find(w => Encoding.UTF8.GetString(w.column) == "d:WordTwoId");
int wordTwoId = Convert.ToInt32(Encoding.UTF8.GetString(w2Id.data));
var rS = row.values.Find(w => Encoding.UTF8.GetString(w.column) == "d:RScore");
var rScore = Convert.ToDouble(Encoding.UTF8.GetString(rS.data));
var id = Encoding.UTF8.GetString(row.key);
if (word.CompareTo(wordOne) == 0 || word.CompareTo(wordTwo) == 0 &&
!(String.IsNullOrWhiteSpace(wordOne) || String.IsNullOrWhiteSpace(wordTwo)))
{
FSWordRelationship rel = new FSWordRelationship(id, wordOne, wordOneId, wordTwo, wordTwoId, rScore);
relations.Add(rel);
}
}
}
return(relations);
}
public void When_I_Scan_with_a_SingleColumnValueFilter_and_a_BinaryPrefixComparator_with_the_operator_equal_I_get_the_expected_results()
{
var expectedRecords = (from r in _allExpectedRecords where r.LineNumber == 3 select r).ToList();
var client = new HBaseClient(RequestOptionsFactory.GetDefaultOptions());
var scanner = new Scanner();
var comparer = new BinaryPrefixComparator(BitConverter.GetBytes(3));
var filter = new SingleColumnValueFilter(
Encoding.UTF8.GetBytes(ColumnFamilyName1),
Encoding.UTF8.GetBytes(LineNumberColumnName),
CompareFilter.CompareOp.Equal,
comparer,
filterIfMissing: false);
scanner.Filter = filter.ToEncodedString();
ScannerInformation scanInfo = null;
try
{
scanInfo = client.CreateScannerAsync(_tableName, scanner).Result;
var actualRecords = RetrieveResults(scanInfo).ToList();
actualRecords.ShouldContainOnly(expectedRecords);
}
finally
{
if (scanInfo != null)
{
client.DeleteScannerAsync(_tableName, scanInfo).Wait();
}
}
}
protected override void Context()
{
target = new ScannerInformation(expectedLocation, expectedTableName, new WebHeaderCollection());
}
protected override void Context()
{
target = new ScannerInformation(expectedLocation, expectedTableName);
}
public void It_should_reject_empty_table_names()
{
object instance = null;
typeof(ArgumentEmptyException).ShouldBeThrownBy(() => instance = new ScannerInformation(validLocation, string.Empty));
instance.ShouldBeNull();
}
public void It_should_reject_null_table_names()
{
object instance = null;
typeof(ArgumentNullException).ShouldBeThrownBy(() => instance = new ScannerInformation(validLocation, null, new WebHeaderCollection()));
instance.ShouldBeNull();
}
public void It_should_reject_null_locations()
{
object instance = null;
typeof(ArgumentNullException).ShouldBeThrownBy(() => instance = new ScannerInformation(null, validTableName));
instance.ShouldBeNull();
}
private IEnumerable<FilterTestRecord> RetrieveResults(ScannerInformation scanInfo, RequestOptions scanOptions)
{
var rv = new List<FilterTestRecord>();
var client = new HBaseClient(_credentials);
CellSet next;
while ((next = client.ScannerGetNextAsync(scanInfo, scanOptions).Result) != null)
{
foreach (CellSet.Row row in next.rows)
{
string rowKey = _encoding.GetString(row.key);
List<Cell> cells = row.values;
string a = null;
string b = null;
int lineNumber = 0;
foreach (Cell c in cells)
{
string columnName = ExtractColumnName(c.column);
switch (columnName)
{
case LineNumberColumnName:
lineNumber = c.data.Length > 0 ? BitConverter.ToInt32(c.data, 0) : 0;
break;
case ColumnNameA:
a = _encoding.GetString(c.data);
break;
case ColumnNameB:
b = _encoding.GetString(c.data);
break;
default:
throw new InvalidOperationException("Don't know what to do with column: " + columnName);
}
}
var rec = new FilterTestRecord(rowKey, lineNumber, a, b);
rv.Add(rec);
}
}
return rv;
}
private IEnumerable<long> RetrieveTimestamps(ScannerInformation scanInfo, RequestOptions scanOptions)
{
var rv = new HashSet<long>();
var client = new HBaseClient(_credentials);
CellSet next;
while ((next = client.ScannerGetNextAsync(scanInfo, scanOptions).Result) != null)
{
foreach (CellSet.Row row in next.rows)
{
List<Cell> cells = row.values;
foreach (Cell c in cells)
{
rv.Add(c.timestamp);
}
}
}
return rv;
}
