public void Append_ToDictionary_DuplicateAndNonDuplicateKey()
{
Tuple <Table <EntityWithDictionaryType>, List <EntityWithDictionaryType> > tupleDictionaryType = EntityWithDictionaryType.SetupDefaultTable(_session);
Table <EntityWithDictionaryType> table = tupleDictionaryType.Item1;
List <EntityWithDictionaryType> expectedEntities = tupleDictionaryType.Item2;
EntityWithDictionaryType singleEntity = expectedEntities.First();
Dictionary <string, string> dictToAdd = new Dictionary <string, string>()
{
{ "randomKey_" + Randomm.RandomAlphaNum(10), "randomVal_" + Randomm.RandomAlphaNum(10) },
{ "randomKey_" + Randomm.RandomAlphaNum(10), "randomVal_" + Randomm.RandomAlphaNum(10) },
{ singleEntity.DictionaryType.First().Key, singleEntity.DictionaryType.First().Value }
};
EntityWithDictionaryType expectedEntity = singleEntity.Clone();
foreach (var keyValPair in dictToAdd)
{
if (!expectedEntity.DictionaryType.ContainsKey(keyValPair.Key))
{
expectedEntity.DictionaryType.Add(keyValPair.Key, keyValPair.Value);
}
}
// Append the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithDictionaryType {
DictionaryType = CqlOperator.Append(dictToAdd)
}).Update().Execute();
// Validate the final state of the data
var entityList = table.Where(m => m.Id == singleEntity.Id).ExecuteAsync().Result.ToList();
Assert.AreEqual(1, entityList.Count);
Assert.AreNotEqual(expectedEntity.DictionaryType, singleEntity.DictionaryType);
expectedEntity.AssertEquals(entityList[0]);
}
public void SubtractAssign_FromDictionary_NotAllowed()
{
var tupleDictionaryType = EntityWithDictionaryType.SetupDefaultTable(Session);
var table = tupleDictionaryType.Item1;
var expectedEntities = tupleDictionaryType.Item2;
var singleEntity = expectedEntities.First();
var expectedEntity = singleEntity.Clone();
expectedEntity.DictionaryType.Clear();
var dictToDelete = new Dictionary <string, string>()
{
{ singleEntity.DictionaryType.First().Key, singleEntity.DictionaryType.First().Value },
};
// Attempt to remove the data
var updateStatement = table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithDictionaryType
{
// Use incorrect substract assign overload
DictionaryType = CqlOperator.SubstractAssign(dictToDelete)
}).Update();
Assert.Throws <InvalidOperationException>(() => updateStatement.Execute(),
"Use dedicated method to substract assign keys only for maps");
}
public void Prepend_ToList()
{
Tuple <Table <EntityWithListType>, List <EntityWithListType> > tupleListType = EntityWithListType.SetupDefaultTable(_session);
Table <EntityWithListType> table = tupleListType.Item1;
List <EntityWithListType> expectedEntities = tupleListType.Item2;
List <int> listToAdd = new List <int> {
-1, 0, 5, 6
};
List <int> listReversed = new List <int>(listToAdd);
listReversed.Reverse();
EntityWithListType singleEntity = expectedEntities.First();
EntityWithListType expectedEntity = singleEntity.Clone();
expectedEntity.ListType.InsertRange(0, listReversed);
// Append the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithListType {
ListType = CqlOperator.Prepend(listToAdd)
}).Update().Execute();
// Validate final state of the data
var entityList = table.Where(m => m.Id == singleEntity.Id).ExecuteAsync().Result.ToList();
Assert.AreEqual(1, entityList.Count);
Assert.AreNotEqual(expectedEntity.ListType, singleEntity.ListType);
expectedEntity.AssertEquals(entityList[0]);
}
public void Append_ToArray_AppendEmptyArray_QueryUsingCql()
{
Tuple <Table <EntityWithArrayType>, List <EntityWithArrayType> > tupleArrayType = EntityWithArrayType.SetupDefaultTable(_session);
Table <EntityWithArrayType> table = tupleArrayType.Item1;
List <EntityWithArrayType> expectedEntities = tupleArrayType.Item2;
string[] arrToAdd = new string[] { };
EntityWithArrayType singleEntity = expectedEntities.First();
EntityWithArrayType expectedEntity = singleEntity.Clone();
List <string> strValsAsList = new List <string>();
strValsAsList.AddRange(expectedEntity.ArrayType);
strValsAsList.AddRange(arrToAdd);
expectedEntity.ArrayType = strValsAsList.ToArray();
// Append the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithArrayType {
ArrayType = CqlOperator.Append(arrToAdd)
}).Update().Execute();
// Validate the final state of the data
List <Row> rows = _session.Execute("SELECT * from " + table.Name + " where id='" + expectedEntity.Id + "'").GetRows().ToList();
Assert.AreEqual(1, rows.Count);
string[] actualArr = rows[0].GetValue <string[]>("arraytype");
Assert.AreEqual(expectedEntity.ArrayType, actualArr);
}
public void SubtractAssign_FromArray_ValNotInArray()
{
Tuple <Table <EntityWithArrayType>, List <EntityWithArrayType> > tupleArrayType = EntityWithArrayType.SetupDefaultTable(_session);
Table <EntityWithArrayType> table = tupleArrayType.Item1;
List <EntityWithArrayType> expectedEntities = tupleArrayType.Item2;
EntityWithArrayType singleEntity = expectedEntities.First();
string[] valsToDelete = { "9999" };
// make sure this value is not in the array
Assert.AreEqual(1, singleEntity.ArrayType.Length);
Assert.AreNotEqual(valsToDelete[0], singleEntity.ArrayType[0]);
// SubstractAssign the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithArrayType {
ArrayType = CqlOperator.SubstractAssign(valsToDelete)
}).Update().Execute();
// Validate final state of the data
List <Row> rows = _session.Execute("SELECT * from " + table.Name + " where id='" + singleEntity.Id + "'").GetRows().ToList();
Assert.AreEqual(1, rows.Count);
object actualArr = rows[0].GetValue <object>("arraytype");
Assert.AreEqual(singleEntity.ArrayType, actualArr);
}
public void Prepend_ToArray_QueryUsingCql()
{
Tuple <Table <EntityWithArrayType>, List <EntityWithArrayType> > tupleArrayType = EntityWithArrayType.SetupDefaultTable(_session);
Table <EntityWithArrayType> table = tupleArrayType.Item1;
List <EntityWithArrayType> expectedEntities = tupleArrayType.Item2;
string[] arrToAdd = new string[] { "random_" + Randomm.RandomAlphaNum(10), "random_" + Randomm.RandomAlphaNum(10), "random_" + Randomm.RandomAlphaNum(10), };
List <string> listReversed = arrToAdd.ToList();
listReversed.Reverse();
string[] arrReversed = listReversed.ToArray();
EntityWithArrayType singleEntity = expectedEntities.First();
EntityWithArrayType expectedEntity = singleEntity.Clone();
List <string> strValsAsList = new List <string>();
strValsAsList.AddRange(expectedEntity.ArrayType);
strValsAsList.InsertRange(0, arrReversed);
expectedEntity.ArrayType = strValsAsList.ToArray();
// Append the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithArrayType {
ArrayType = CqlOperator.Prepend(arrToAdd)
}).Update().Execute();
// Validate the final state of the data
List <Row> rows = _session.Execute("SELECT * from " + table.Name + " where id='" + expectedEntity.Id + "'").GetRows().ToList();
Assert.AreEqual(1, rows.Count);
Assert.AreNotEqual(expectedEntity.ArrayType, singleEntity.ArrayType);
string[] actualArr = rows[0].GetValue <string[]>("arraytype");
CollectionAssert.AreEquivalent(expectedEntity.ArrayType, actualArr);
}
public void SubtractAssign_FromArray_ValNotInArray()
{
var tupleArrayType = EntityWithArrayType.GetDefaultTable(Session, _tableName);
var table = tupleArrayType.Item1;
var expectedEntities = tupleArrayType.Item2;
var singleEntity = expectedEntities.First();
string[] valsToDelete = { "9999" };
// make sure this value is not in the array
Assert.AreEqual(1, singleEntity.ArrayType.Length);
Assert.AreNotEqual(valsToDelete[0], singleEntity.ArrayType[0]);
// SubstractAssign the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithArrayType
{
ArrayType = CqlOperator.SubstractAssign(valsToDelete)
}).Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET ArrayType = ArrayType - ? WHERE Id = ?",
1,
valsToDelete, singleEntity.Id);
}
public void SubtractAssign_FromList_ValNotInList()
{
Tuple <Table <EntityWithListType>, List <EntityWithListType> > tupleListType = EntityWithListType.SetupDefaultTable(_session);
Table <EntityWithListType> table = tupleListType.Item1;
List <EntityWithListType> expectedEntities = tupleListType.Item2;
EntityWithListType singleEntity = expectedEntities.First();
List <int> valsToDelete = new List <int>()
{
9999
};
// make sure this value is not in the list
Assert.IsFalse(singleEntity.ListType.Contains(valsToDelete.First()));
// SubstractAssign the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithListType {
ListType = CqlOperator.SubstractAssign(valsToDelete)
}).Update().Execute();
// Validate final state of the data
var entityList = table.Where(m => m.Id == singleEntity.Id).ExecuteAsync().Result.ToList();
Assert.AreEqual(1, entityList.Count);
singleEntity.AssertEquals(entityList[0]);
}
public void SubtractAssign_FromArray_Duplicates()
{
var tupleArrayType = EntityWithArrayType.GetDefaultTable(Session, _tableName);
var table = tupleArrayType.Item1;
var expectedEntities = tupleArrayType.Item2;
var singleEntity = expectedEntities.First();
Assert.AreEqual(1, singleEntity.ArrayType.Length); // make sure there's only one value in the list
var indexToRemove = 0;
singleEntity.ArrayType.ToList().AddRange(new[] { singleEntity.ArrayType[indexToRemove], singleEntity.ArrayType[indexToRemove], singleEntity.ArrayType[indexToRemove] });
// Get single value to remove
var valsToDelete = new[] { singleEntity.ArrayType[indexToRemove] };
var expectedEntity = singleEntity.Clone();
expectedEntity.ArrayType = new string[] { };
// SubstractAssign the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithArrayType
{
ArrayType = CqlOperator.SubstractAssign(valsToDelete)
}).Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET ArrayType = ArrayType - ? WHERE Id = ?",
1,
valsToDelete, singleEntity.Id);
}
public void SubtractAssign_FromArray_OneValueOfMany_IndexNonZero()
{
var tupleArrayType = EntityWithArrayType.GetDefaultTable(Session, _tableName);
var table = tupleArrayType.Item1;
var expectedEntities = tupleArrayType.Item2;
var singleEntity = expectedEntities.First();
var tempList = singleEntity.ArrayType.ToList();
tempList.AddRange(new[] { "999", "9999", "99999", "999999" });
singleEntity.ArrayType = tempList.ToArray();
// Get Value to remove
var indexToRemove = 2;
string[] valsToDelete = { singleEntity.ArrayType[indexToRemove] };
var expectedEntity = singleEntity.Clone();
tempList = expectedEntity.ArrayType.ToList();
tempList.RemoveAt(indexToRemove);
expectedEntity.ArrayType = tempList.ToArray();
// SubstractAssign the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithArrayType
{
ArrayType = CqlOperator.SubstractAssign(valsToDelete)
}).Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET ArrayType = ArrayType - ? WHERE Id = ?",
1,
valsToDelete, singleEntity.Id);
}
public void SubtractAssign_FromList_ValNotInList()
{
var tupleListType = EntityWithListType.GetDefaultTable(Session, _tableName);
var table = tupleListType.Item1;
var expectedEntities = tupleListType.Item2;
var singleEntity = expectedEntities.First();
var valsToDelete = new List <int>()
{
9999
};
// make sure this value is not in the list
Assert.IsFalse(singleEntity.ListType.Contains(valsToDelete.First()));
// SubstractAssign the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithListType
{
ListType = CqlOperator.SubstractAssign(valsToDelete)
}).Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET ListType = ListType - ? WHERE Id = ?",
1,
valsToDelete, singleEntity.Id);
}
public void Append_ToArray_TableWithAllCollectionTypes()
{
var(table, expectedEntities) = EntityWithAllCollectionTypes.GetDefaultTable(Session, _tableName);
var singleEntity = expectedEntities.First();
var toAppend = new string[] { "tag1", "tag2", "tag3" };
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithAllCollectionTypes {
ArrayType = CqlOperator.Append(toAppend)
})
.Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET ArrayType = ArrayType + ? WHERE Id = ?",
1,
toAppend, singleEntity.Id);
TestCluster.PrimeFluent(
b => b.WhenQuery(
$"SELECT ArrayType, DictionaryType, Id, ListType FROM {_tableName} WHERE Id = ?",
when => when.WithParam(singleEntity.Id))
.ThenRowsSuccess(
new[] { "ArrayType", "DictionaryType", "Id", "ListType" },
r => r.WithRow(
singleEntity.ArrayType.Concat(toAppend),
singleEntity.DictionaryType,
singleEntity.Id,
singleEntity.ListType)));
var entityList = table.Where(m => m.Id == singleEntity.Id).ExecuteAsync().Result.ToList();
Assert.AreEqual(1, entityList.Count);
CollectionAssert.AreEqual(singleEntity.ArrayType.Concat(toAppend), entityList.First().ArrayType);
}
public void Append_ToDictionary_DuplicateAndNonDuplicateKey()
{
var(table, expectedEntities) = EntityWithDictionaryType.GetDefaultTable(Session, _tableName);
var singleEntity = expectedEntities.First();
var dictToAdd = new Dictionary <string, string>()
{
{ "randomKey_" + Randomm.RandomAlphaNum(10), "randomVal_" + Randomm.RandomAlphaNum(10) },
{ "randomKey_" + Randomm.RandomAlphaNum(10), "randomVal_" + Randomm.RandomAlphaNum(10) },
{ singleEntity.DictionaryType.First().Key, singleEntity.DictionaryType.First().Value }
};
var expectedEntity = singleEntity.Clone();
foreach (var keyValPair in dictToAdd)
{
if (!expectedEntity.DictionaryType.ContainsKey(keyValPair.Key))
{
expectedEntity.DictionaryType.Add(keyValPair.Key, keyValPair.Value);
}
}
// Append the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithDictionaryType {
DictionaryType = CqlOperator.Append(dictToAdd)
})
.Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET DictionaryType = DictionaryType + ? WHERE Id = ?",
1,
dictToAdd, singleEntity.Id);
}
public void Append_ToDictionary_EmptyDictionary()
{
var(table, expectedEntities) = EntityWithDictionaryType.GetDefaultTable(Session, _tableName);
var dictToAdd = new Dictionary <string, string>()
{
};
var singleEntity = expectedEntities.First();
var expectedEntity = singleEntity.Clone();
foreach (var keyValPair in dictToAdd)
{
expectedEntity.DictionaryType.Add(keyValPair.Key, keyValPair.Value);
}
// Append the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithDictionaryType {
DictionaryType = CqlOperator.Append(dictToAdd)
})
.Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET DictionaryType = DictionaryType + ? WHERE Id = ?",
1,
dictToAdd, singleEntity.Id);
}
public void SubtractAssign_FromList_Duplicates()
{
var(table, expectedEntities) = EntityWithListType.GetDefaultTable(Session, _tableName);
var singleEntity = expectedEntities.First();
Assert.AreEqual(1, singleEntity.ListType.Count); // make sure there's only one value in the list
var indexToRemove = 0;
singleEntity.ListType.AddRange(new[] { singleEntity.ListType[indexToRemove], singleEntity.ListType[indexToRemove], singleEntity.ListType[indexToRemove] });
// Get single value to remove
var valsToDelete = new List <int>()
{
singleEntity.ListType[indexToRemove]
};
// SubstractAssign the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithListType
{
ListType = CqlOperator.SubstractAssign(valsToDelete)
}).Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET ListType = ListType - ? WHERE Id = ?",
1,
valsToDelete, singleEntity.Id);
}
public void Append_Operator_Linq_Test()
{
string query = null;
object[] parameters = null;
var session = GetSession((q, v) =>
{
query = q;
parameters = v;
});
//This time is case sensitive
var table = GetTable <CollectionTypesEntity>(session, new Map <CollectionTypesEntity>().TableName("tbl").Column(t => t.Scores, cm => cm.WithName("score_values")));
table
.Select(t => new CollectionTypesEntity {
Scores = CqlOperator.Append(new List <int> {
5, 6
})
})
.Where(t => t.Id == 1L)
.Update()
.Execute();
Assert.AreEqual("UPDATE tbl SET score_values = score_values + ? WHERE Id = ?", query);
CollectionAssert.AreEqual(new object[] { new List <int> {
5, 6
}, 1L }, parameters);
}
public void SubtractAssign_FromList_OneValueOfMany_IndexZero()
{
var(table, expectedEntities) = EntityWithListType.GetDefaultTable(Session, _tableName);
var singleEntity = expectedEntities.First();
singleEntity.ListType.AddRange(new[] { 999, 9999, 99999, 999999 });
// Get value to remove
var indexToRemove = 0;
var valsToDelete = new List <int>()
{
singleEntity.ListType[indexToRemove]
};
var expectedEntity = singleEntity.Clone();
expectedEntity.ListType.RemoveAt(indexToRemove);
// SubstractAssign the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithListType
{
ListType = CqlOperator.SubstractAssign(valsToDelete)
}).Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET ListType = ListType - ? WHERE Id = ?",
1,
valsToDelete, singleEntity.Id);
}
public void SubtractAssign_FromArray_AllValues_QueryUsingCql()
{
Tuple <Table <EntityWithArrayType>, List <EntityWithArrayType> > tupleListType = EntityWithArrayType.SetupDefaultTable(_session);
Table <EntityWithArrayType> table = tupleListType.Item1;
List <EntityWithArrayType> expectedEntities = tupleListType.Item2;
EntityWithArrayType singleEntity = expectedEntities.First();
EntityWithArrayType expectedEntity = singleEntity.Clone();
expectedEntity.ArrayType = new string[] {};
// SubstractAssign the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithArrayType {
ArrayType = CqlOperator.SubstractAssign(singleEntity.ArrayType)
}).Update().Execute();
// Validate final state of the data
List <Row> rows = _session.Execute("SELECT * from " + table.Name + " where id='" + expectedEntity.Id + "'").GetRows().ToList();
Assert.AreEqual(1, rows.Count);
Assert.AreNotEqual(expectedEntity.ArrayType, singleEntity.ArrayType);
object actualArr = rows[0].GetValue <object>("arraytype");
Assert.AreEqual(null, actualArr);
}
public void Prepend_ToArray()
{
var tupleArrayType = EntityWithArrayType.GetDefaultTable(Session, _tableName);
var table = tupleArrayType.Item1;
var expectedEntities = tupleArrayType.Item2;
var arrToAdd = new string[]
{
"random_" + Randomm.RandomAlphaNum(10),
"random_" + Randomm.RandomAlphaNum(10),
"random_" + Randomm.RandomAlphaNum(10),
};
var singleEntity = expectedEntities.First();
// Append the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithArrayType {
ArrayType = CqlOperator.Prepend(arrToAdd)
})
.Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET ArrayType = ? + ArrayType WHERE Id = ?",
1,
arrToAdd, singleEntity.Id);
}
public void SubtractAssign_FromList_OneValueOfMany_IndexZero()
{
Tuple <Table <EntityWithListType>, List <EntityWithListType> > tupleListType = EntityWithListType.SetupDefaultTable(_session);
Table <EntityWithListType> table = tupleListType.Item1;
List <EntityWithListType> expectedEntities = tupleListType.Item2;
EntityWithListType singleEntity = expectedEntities.First();
singleEntity.ListType.AddRange(new[] { 999, 9999, 99999, 999999 });
// Overwrite one of the rows
table.Insert(singleEntity).Execute();
// Get value to remove
int indexToRemove = 0;
List <int> valsToDelete = new List <int>()
{
singleEntity.ListType[indexToRemove]
};
EntityWithListType expectedEntity = singleEntity.Clone();
expectedEntity.ListType.RemoveAt(indexToRemove);
// SubstractAssign the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithListType {
ListType = CqlOperator.SubstractAssign(valsToDelete)
}).Update().Execute();
// Validate final state of the data
var entityList = table.Where(m => m.Id == singleEntity.Id).ExecuteAsync().Result.ToList();
Assert.AreEqual(1, entityList.Count);
Assert.AreNotEqual(expectedEntity.ListType, singleEntity.ListType);
expectedEntity.AssertEquals(entityList[0]);
}
public void Prepend_ToArray_QueryUsingCql()
{
var(table, expectedEntities) = EntityWithArrayType.GetDefaultTable(Session, _tableName);
var arrToAdd = new string[]
{
"random_" + Randomm.RandomAlphaNum(10),
"random_" + Randomm.RandomAlphaNum(10),
"random_" + Randomm.RandomAlphaNum(10),
};
var listReversed = arrToAdd.ToList();
listReversed.Reverse();
var arrReversed = listReversed.ToArray();
var singleEntity = expectedEntities.First();
var expectedEntity = singleEntity.Clone();
var strValsAsList = new List <string>();
strValsAsList.AddRange(expectedEntity.ArrayType);
strValsAsList.InsertRange(0, arrReversed);
expectedEntity.ArrayType = strValsAsList.ToArray();
// Append the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithArrayType {
ArrayType = CqlOperator.Prepend(arrToAdd)
})
.Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET ArrayType = ? + ArrayType WHERE Id = ?",
1,
arrToAdd, singleEntity.Id);
}
public void Prepend_Dictionary()
{
Tuple <Table <EntityWithDictionaryType>, List <EntityWithDictionaryType> > tupleDictionaryType = EntityWithDictionaryType.SetupDefaultTable(_session);
Table <EntityWithDictionaryType> table = tupleDictionaryType.Item1;
List <EntityWithDictionaryType> expectedEntities = tupleDictionaryType.Item2;
Dictionary <string, string> dictToAdd = new Dictionary <string, string>()
{
{ "randomKey_" + Randomm.RandomAlphaNum(10), "randomVal_" + Randomm.RandomAlphaNum(10) },
{ "randomKey_" + Randomm.RandomAlphaNum(10), "randomVal_" + Randomm.RandomAlphaNum(10) },
};
EntityWithDictionaryType singleEntity = expectedEntities.First();
EntityWithDictionaryType expectedEntity = singleEntity.Clone();
expectedEntity.DictionaryType.Clear();
var dictToAddReversed = new Dictionary <string, string>(dictToAdd).Reverse();
foreach (var keyValPair in dictToAddReversed)
{
expectedEntity.DictionaryType.Add(keyValPair.Key, keyValPair.Value);
}
foreach (var keyValPair in singleEntity.DictionaryType)
{
expectedEntity.DictionaryType.Add(keyValPair.Key, keyValPair.Value);
}
// Append the values
string expectedErrMsg = "Invalid operation (dictionarytype = ? - dictionarytype) for non list column dictionarytype";
var err = Assert.Throws <InvalidQueryException>(() => table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithDictionaryType {
DictionaryType = CqlOperator.Prepend(dictToAdd)
}).Update().Execute());
Assert.AreEqual(expectedErrMsg, err.Message);
}
public void Prepend_ToList_StartsOutEmpty()
{
var(table, expectedEntities) = EntityWithListType.GetDefaultTable(Session, _tableName);
// overwrite the row we're querying with empty list
var singleEntity = expectedEntities.First();
singleEntity.ListType.Clear();
table.Insert(singleEntity).Execute();
var listToAdd = new List <int> {
-1, 0, 5, 6
};
var listReversed = new List <int>(listToAdd);
listReversed.Reverse();
var expectedEntity = singleEntity.Clone();
expectedEntity.ListType.InsertRange(0, listReversed);
// Append the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithListType {
ListType = CqlOperator.Prepend(listToAdd)
})
.Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET ListType = ? + ListType WHERE Id = ?",
1,
listToAdd, singleEntity.Id);
}
public void Append_ToArray()
{
Tuple <Table <EntityWithArrayType>, List <EntityWithArrayType> > tupleArrayType = EntityWithArrayType.SetupDefaultTable(_session);
Table <EntityWithArrayType> table = tupleArrayType.Item1;
List <EntityWithArrayType> expectedEntities = tupleArrayType.Item2;
string[] arrToAdd = new string[] { "random_" + Randomm.RandomAlphaNum(10), "random_" + Randomm.RandomAlphaNum(10), "random_" + Randomm.RandomAlphaNum(10), };
EntityWithArrayType singleEntity = expectedEntities.First();
EntityWithArrayType expectedEntity = singleEntity.Clone();
List <string> strValsAsList = new List <string>();
strValsAsList.AddRange(expectedEntity.ArrayType);
strValsAsList.AddRange(arrToAdd);
expectedEntity.ArrayType = strValsAsList.ToArray();
// Append the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithArrayType {
ArrayType = CqlOperator.Append(arrToAdd)
}).Update().Execute();
// Validate the final state of the data
var entityList = table.Where(m => m.Id == singleEntity.Id).ExecuteAsync().Result.ToList();
Assert.AreEqual(1, entityList.Count);
Assert.AreNotEqual(expectedEntity.ArrayType, singleEntity.ArrayType);
expectedEntity.AssertEquals(entityList[0]);
}
public void SubtractAssign_FromArray_AllValues_QueryUsingCql()
{
var tupleListType = EntityWithArrayType.SetupDefaultTable(Session);
var table = tupleListType.Item1;
var expectedEntities = tupleListType.Item2;
var singleEntity = expectedEntities.First();
var expectedEntity = singleEntity.Clone();
expectedEntity.ArrayType = new string[] {};
// SubstractAssign the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithArrayType {
ArrayType = CqlOperator.SubstractAssign(singleEntity.ArrayType)
}).Update().Execute();
// Validate final state of the data
var rows = Session.Execute($"SELECT * from {table.Name} where id=\'{expectedEntity.Id}\'").GetRows().ToList();
Assert.AreEqual(1, rows.Count);
Assert.AreNotEqual(expectedEntity.ArrayType, singleEntity.ArrayType);
var actualArr = rows[0].GetValue <object>("arraytype");
Assert.AreEqual(null, actualArr);
}
public void Append_ToDictionary_EmptyDictionary()
{
Tuple <Table <EntityWithDictionaryType>, List <EntityWithDictionaryType> > tupleDictionaryType = EntityWithDictionaryType.SetupDefaultTable(_session);
Table <EntityWithDictionaryType> table = tupleDictionaryType.Item1;
List <EntityWithDictionaryType> expectedEntities = tupleDictionaryType.Item2;
Dictionary <string, string> dictToAdd = new Dictionary <string, string>()
{
};
EntityWithDictionaryType singleEntity = expectedEntities.First();
EntityWithDictionaryType expectedEntity = singleEntity.Clone();
foreach (var keyValPair in dictToAdd)
{
expectedEntity.DictionaryType.Add(keyValPair.Key, keyValPair.Value);
}
// Append the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithDictionaryType {
DictionaryType = CqlOperator.Append(dictToAdd)
}).Update().Execute();
// Validate the final state of the data
var entityList = table.Where(m => m.Id == singleEntity.Id).ExecuteAsync().Result.ToList();
Assert.AreEqual(1, entityList.Count);
expectedEntity.AssertEquals(entityList[0]);
}
public void Prepend_Operator_Linq_Test()
{
string query = null;
object[] parameters = null;
var session = GetSession((q, v) =>
{
query = q;
parameters = v;
});
//This time is case sensitive
var table = GetTable <CollectionTypesEntity>(session, new Map <CollectionTypesEntity>().TableName("tbl"));
table
.Select(t => new CollectionTypesEntity {
Scores = CqlOperator.Prepend(new List <int> {
50, 60
})
})
.Where(t => t.Id == 10L)
.Update()
.Execute();
Assert.AreEqual("UPDATE tbl SET Scores = ? + Scores WHERE Id = ?", query);
CollectionAssert.AreEqual(new object[] { new List <int> {
50, 60
}, 10L }, parameters);
}
public void Append_ToList_StartsOutEmpty()
{
Tuple <Table <EntityWithListType>, List <EntityWithListType> > tupleListType = EntityWithListType.SetupDefaultTable(_session);
Table <EntityWithListType> table = tupleListType.Item1;
List <EntityWithListType> expectedEntities = tupleListType.Item2;
// overwrite the row we're querying with empty list
EntityWithListType singleEntity = expectedEntities.First();
singleEntity.ListType.Clear();
table.Insert(singleEntity).Execute();
EntityWithListType expectedEntity = singleEntity.Clone();
List <int> listToAdd = new List <int> {
-1, 0, 5, 6
};
expectedEntity.ListType.AddRange(listToAdd);
// Append the values
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithListType {
ListType = CqlOperator.Append(listToAdd)
}).Update().Execute();
// Validate final state of the data
var entityList = table.Where(m => m.Id == singleEntity.Id).ExecuteAsync().Result.ToList();
Assert.AreEqual(1, entityList.Count);
Assert.AreNotEqual(expectedEntity.ListType, singleEntity.ListType);
expectedEntity.AssertEquals(entityList[0]);
}
public void Append_ToArray_AppendEmptyArray_QueryUsingCql()
{
var(table, expectedEntities) = EntityWithArrayType.GetDefaultTable(Session, _tableName);
var arrToAdd = new string[] { };
var singleEntity = expectedEntities.First();
var expectedEntity = singleEntity.Clone();
var strValsAsList = new List <string>();
strValsAsList.AddRange(expectedEntity.ArrayType);
strValsAsList.AddRange(arrToAdd);
expectedEntity.ArrayType = strValsAsList.ToArray();
// Append the values
table.Where(t => t.Id == singleEntity.Id)
.Select(t => new EntityWithArrayType {
ArrayType = CqlOperator.Append(arrToAdd)
})
.Update().Execute();
VerifyBoundStatement(
$"UPDATE {_tableName} SET ArrayType = ArrayType + ? WHERE Id = ?",
1,
arrToAdd, singleEntity.Id);
}
public void Append_ToArray_TableWithAllCollectionTypes()
{
Tuple <Table <EntityWithAllCollectionTypes>, List <EntityWithAllCollectionTypes> > tupleAllCollectionTypes = EntityWithAllCollectionTypes.SetupDefaultTable(_session);
Table <EntityWithAllCollectionTypes> table = tupleAllCollectionTypes.Item1;
List <EntityWithAllCollectionTypes> expectedEntities = tupleAllCollectionTypes.Item2;
EntityWithAllCollectionTypes singleEntity = expectedEntities.First();
var toAppend = new string[] { "tag1", "tag2", "tag3" };
table.Where(t => t.Id == singleEntity.Id).Select(t => new EntityWithAllCollectionTypes {
ArrayType = CqlOperator.Append(toAppend)
}).Update().Execute();
var entityList = table.Where(m => m.Id == singleEntity.Id).ExecuteAsync().Result.ToList();
Assert.AreEqual(1, entityList.Count);
CollectionAssert.AreEqual(singleEntity.ArrayType.Concat(toAppend), entityList.First().ArrayType);
}
