/// <summary>
/// Creates the scan specification.
/// </summary>
/// <returns>
/// The scan spec.
/// </returns>
public ScanSpec CreateScanSpec()
{
var scanSpec = new ScanSpec {
MaxVersions = 1, ScanAndFilter = true
};
foreach (var entityScanTarget in this.EntityScanTargets)
{
var key = entityScanTarget.Key;
if (!string.IsNullOrEmpty(key.ColumnFamily))
{
if (key.ColumnQualifier == null)
{
scanSpec.AddColumn(key.ColumnFamily);
}
else
{
var sb = new StringBuilder();
sb.Append(key.ColumnFamily);
sb.Append(":");
sb.Append(key.ColumnQualifier);
scanSpec.AddColumn(sb.ToString());
}
}
scanSpec.AddRow(key.Row);
}
return(scanSpec);
}
public void FetchByScanSpec()
{
var ec1 = new EntityC {
A = new EntityA(), B = new EntityB(), X = new EntityX(), Y = new EntityY()
};
TestBase.TestSerialization(ec1);
var ex21 = new EntityX2();
TestBase.TestSerialization(ex21);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
em.Persist(ex21);
}
using (var em = Emf.CreateEntityManager())
{
var _ec = em.Fetch <EntityC>(new ScanSpec(ec1.Id));
Assert.IsNotNull(_ec);
Assert.AreEqual(1, _ec.Count());
Assert.AreEqual(ec1, _ec.First());
var ss = new ScanSpec();
ss.AddColumn("a");
var _ex = em.Fetch <EntityXBase>(ss);
Assert.IsNotNull(_ex);
Assert.AreEqual(2, _ex.Count());
Assert.AreEqual(ec1.X, _ex.OfType <EntityX>().First());
Assert.AreEqual(ex21, _ex.OfType <EntityX2>().First());
}
}
/// <summary>
/// Gets the scan spec for the type specified.
/// </summary>
/// <param name="entityType">
/// The entity type.
/// </param>
/// <returns>
/// The scan spec.
/// </returns>
public ScanSpec ScanSpecForType(Type entityType)
{
if (entityType == null)
{
throw new ArgumentNullException(nameof(entityType));
}
var entityReference = this.EntityReferenceForType(entityType);
if (entityReference == null)
{
throw new PersistenceException(string.Format(CultureInfo.InvariantCulture, @"{0} is not a valid entity",
entityType));
}
entityReference.EstablishColumnSets(() => this.ColumnNames(entityReference));
var scanSpec = new ScanSpec {
MaxVersions = 1
};
scanSpec.AddColumn(entityReference.ColumnSet);
if (scanSpec.ColumnCount == 0)
{
throw new PersistenceException(string.Format(CultureInfo.InvariantCulture, @"{0} is not a valid entity",
entityType));
}
return(scanSpec);
}
/// <summary>
/// Gets the merged scan spec for the types specified.
/// </summary>
/// <param name="entityTypes">
/// The query types.
/// </param>
/// <returns>
/// The merged scan spec.
/// </returns>
public ScanSpec ScanSpecForType(IEnumerable <Type> entityTypes)
{
if (entityTypes == null)
{
throw new ArgumentNullException(nameof(entityTypes));
}
var columnNames = new List <string>();
foreach (var queryType in entityTypes)
{
var entityReference = this.EntityReferenceForType(queryType);
if (entityReference == null)
{
throw new PersistenceException(string.Format(CultureInfo.InvariantCulture,
@"{0} is not a valid query type", queryType));
}
entityReference.EstablishColumnSets(() => this.ColumnNames(entityReference));
columnNames.AddRange(entityReference.ColumnSet);
}
if (columnNames.Count > 5)
{
var registeredColumnNames = this.RegisteredColumnNames();
foreach (var columnName in columnNames.ToList())
{
var split = columnName.Split(':');
if (split.Length > 1)
{
ISet <string> columnQualifiers;
if (registeredColumnNames.TryGetValue(split[0], out columnQualifiers))
{
if (columnQualifiers.Remove(split[1]) && columnQualifiers.Count == 0)
{
columnNames.Add(split[0]);
}
}
}
}
}
var scanSpec = new ScanSpec {
MaxVersions = 1
};
scanSpec.AddColumn(ScanSpec.DistictColumn(columnNames));
if (scanSpec.ColumnCount == 0)
{
throw new PersistenceException("Missing or invalid entity types");
}
return(scanSpec);
}
public void FetchByScanSpec()
{
var ec1 = new EntityC { A = new EntityA(), B = new EntityB(), X = new EntityX(), Y = new EntityY() };
TestBase.TestSerialization(ec1);
var ex21 = new EntityX2();
TestBase.TestSerialization(ex21);
using (var em = Emf.CreateEntityManager())
{
em.Persist(ec1);
em.Persist(ex21);
}
using (var em = Emf.CreateEntityManager())
{
var _ec = em.Fetch<EntityC>(new ScanSpec(ec1.Id));
Assert.IsNotNull(_ec);
Assert.AreEqual(1, _ec.Count());
Assert.AreEqual(ec1, _ec.First());
var ss = new ScanSpec();
ss.AddColumn("a");
var _ex = em.Fetch<EntityXBase>(ss);
Assert.IsNotNull(_ex);
Assert.AreEqual(2, _ex.Count());
Assert.AreEqual(ec1.X, _ex.OfType<EntityX>().First());
Assert.AreEqual(ex21, _ex.OfType<EntityX2>().First());
}
}
public void ScanTableRandomCells()
{
var random = new Random();
const string Cf = "abcdefg";
const int Count = 10000;
using (var _table = EnsureTable("ScanTableRandomCells", Schema)) {
var keys = new List<Key>(Count);
using (var mutator = _table.CreateMutator()) {
for (var i = 0; i < Count; ++i) {
var key = new Key
{
Row = Guid.NewGuid().ToString(),
ColumnFamily = new string(new[] { Cf[random.Next(Cf.Length)] }),
ColumnQualifier = random.Next(Cf.Length).ToString(CultureInfo.InvariantCulture)
};
keys.Add(key);
mutator.Set(key, Encoding.GetBytes(key.Row));
}
}
for (var r = 0; r < 10; ++r) {
var countCells = 10 + random.Next(Count - 10);
var scanSpec = new ScanSpec();
foreach (var k in Shuffle(keys)) {
scanSpec.AddCell(k);
if (scanSpec.CellCount == countCells) {
break;
}
}
var comparer = new KeyComparer(false);
using (var scanner = _table.CreateScanner(scanSpec)) {
Assert.AreSame(scanSpec, scanner.ScanSpec);
var cell = new Cell();
var c = 0;
while( scanner.Move(cell) ) {
Assert.AreEqual(cell.Key.Row, Encoding.GetString(cell.Value));
Assert.IsTrue(comparer.Equals(scanSpec.Cells[c++], cell.Key));
}
Assert.AreEqual(scanSpec.CellCount, c);
}
}
for (var r = 0; r < 10; ++r) {
var countCells = 10 + random.Next(Count - 10);
var scanSpec = new ScanSpec();
foreach (var k in Shuffle(keys)) {
scanSpec.AddRow(k.Row);
if (scanSpec.RowCount == countCells) {
break;
}
}
using (var scanner = _table.CreateScanner(scanSpec)) {
Assert.AreSame(scanSpec, scanner.ScanSpec);
var cell = new Cell();
var c = 0;
while( scanner.Move(cell) ) {
Assert.AreEqual(cell.Key.Row, Encoding.GetString(cell.Value));
Assert.AreEqual(scanSpec.Rows[c++], cell.Key.Row);
}
Assert.AreEqual(scanSpec.RowCount, c);
}
}
for (var r = 0; r < 10; ++r) {
var rows = new HashSet<string>();
var countCells = 10 + random.Next(Count - 10);
var scanSpec = new ScanSpec(true);
foreach (var k in Shuffle(keys)) {
scanSpec.AddRow(k.Row);
rows.Add(k.Row);
if (scanSpec.RowCount == countCells) {
break;
}
}
using (var scanner = _table.CreateScanner(scanSpec)) {
Assert.AreSame(scanSpec, scanner.ScanSpec);
var cell = new Cell();
var c = 0;
while( scanner.Move(cell) ) {
Assert.AreEqual(cell.Key.Row, Encoding.GetString(cell.Value));
Assert.IsTrue(rows.Contains(cell.Key.Row));
++c;
}
Assert.AreEqual(scanSpec.RowCount, c);
}
}
for (var r = 0; r < 10; ++r) {
var rows = new HashSet<string>();
var columnFamily = new string(new[] { Cf[random.Next(Cf.Length)] });
var columnQualifier = random.Next(Cf.Length).ToString(CultureInfo.InvariantCulture);
var countCells = 10 + random.Next(Count / 10);
var scanSpec = new ScanSpec { ScanAndFilter = true };
foreach (var k in Shuffle(keys).Where(k => k.ColumnFamily == columnFamily && k.ColumnQualifier == columnQualifier)) {
Assert.AreEqual(columnFamily, k.ColumnFamily);
Assert.AreEqual(columnQualifier, k.ColumnQualifier);
scanSpec.AddColumn(k.ColumnFamily + ":" + k.ColumnQualifier);
scanSpec.AddRow(k.Row);
rows.Add(k.Row);
if (scanSpec.RowCount == countCells) {
break;
}
}
using (var scanner = _table.CreateScanner(scanSpec)) {
Assert.AreSame(scanSpec, scanner.ScanSpec);
var cell = new Cell();
var c = 0;
while( scanner.Move(cell) ) {
Assert.AreEqual(cell.Key.Row, Encoding.GetString(cell.Value));
Assert.AreEqual(columnFamily, cell.Key.ColumnFamily);
Assert.AreEqual(columnQualifier, cell.Key.ColumnQualifier);
Assert.IsTrue(rows.Contains(cell.Key.Row));
++c;
}
Assert.AreEqual(scanSpec.RowCount, c);
}
}
for (var r = 0; r < 10; ++r) {
var rows = new HashSet<string>();
var columnQualifier = random.Next(Cf.Length).ToString(CultureInfo.InvariantCulture);
var countCells = 10 + random.Next(Count / 10);
var scanSpec = new ScanSpec { ScanAndFilter = true };
foreach (var k in Shuffle(keys).Where(k => k.ColumnQualifier == columnQualifier)) {
Assert.AreEqual(columnQualifier, k.ColumnQualifier);
scanSpec.AddColumn(k.ColumnFamily + ":" + k.ColumnQualifier);
scanSpec.AddRow(k.Row);
rows.Add(k.Row);
if (scanSpec.RowCount == countCells) {
break;
}
}
using (var scanner = _table.CreateScanner(scanSpec)) {
Assert.AreSame(scanSpec, scanner.ScanSpec);
var cell = new Cell();
var c = 0;
while( scanner.Move(cell) ) {
Assert.AreEqual(cell.Key.Row, Encoding.GetString(cell.Value));
Assert.AreEqual(columnQualifier, cell.Key.ColumnQualifier);
Assert.IsTrue(rows.Contains(cell.Key.Row));
++c;
}
Assert.AreEqual(scanSpec.RowCount, c);
}
}
using (var mutator = _table.CreateMutator()) {
var key = new Key { Row = "A", ColumnFamily = "a", ColumnQualifier = "1" };
mutator.Set(key, Encoding.GetBytes(key.Row));
key = new Key { Row = "B", ColumnFamily = "a", ColumnQualifier = "2" };
mutator.Set(key, Encoding.GetBytes(key.Row));
key = new Key { Row = "C", ColumnFamily = "c", ColumnQualifier = "3" };
mutator.Set(key, Encoding.GetBytes(key.Row));
key = new Key { Row = "D", ColumnFamily = "c", ColumnQualifier = "4" };
mutator.Set(key, Encoding.GetBytes(key.Row));
key = new Key { Row = "E", ColumnFamily = "b", ColumnQualifier = "5" };
mutator.Set(key, Encoding.GetBytes(key.Row));
}
{
var scanSpec = new ScanSpec { ScanAndFilter = true };
scanSpec.AddColumn("a:1");
scanSpec.AddColumn("a:2");
scanSpec.AddColumn("b:5");
scanSpec.AddColumn("c:3");
scanSpec.AddColumn("c:4");
scanSpec.AddRow("A");
scanSpec.AddRow("B");
using (var scanner = _table.CreateScanner(scanSpec)) {
Assert.AreSame(scanSpec, scanner.ScanSpec);
var cell = new Cell();
var c = 0;
while( scanner.Move(cell) ) {
Assert.AreEqual(cell.Key.Row, Encoding.GetString(cell.Value));
++c;
}
Assert.AreEqual(scanSpec.RowCount, c);
}
scanSpec = new ScanSpec { ScanAndFilter = true };
scanSpec.AddColumn("a", "b:5", "c");
scanSpec.AddRow("A");
scanSpec.AddRow("C");
scanSpec.AddRow("E");
using (var scanner = _table.CreateScanner(scanSpec)) {
Assert.AreSame(scanSpec, scanner.ScanSpec);
var cell = new Cell();
var c = 0;
while( scanner.Move(cell) ) {
Assert.AreEqual(cell.Key.Row, Encoding.GetString(cell.Value));
++c;
}
Assert.AreEqual(scanSpec.RowCount, c);
}
}
}
}
