public void Can_get_data_from_TableWithNamigStrategy_with_query_by_example()
{
OrmLiteConfig.DialectProvider.NamingStrategy =
OrmLiteConfig.DialectProvider.NamingStrategy = new PrefixNamingStrategy
{
TablePrefix = "tab_",
ColumnPrefix = "col_",
};
using (var db = OpenDbConnection())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
var m = new ModelWithOnlyStringFields
{
Id = "998",
AlbumId = "112",
AlbumName = "ElectroShip",
Name = "QueryByExample"
};
db.Save(m);
var modelFromDb = db.Where <ModelWithOnlyStringFields>(new { Name = "QueryByExample" })[0];
Assert.AreEqual(m.Name, modelFromDb.Name);
}
OrmLiteConfig.DialectProvider.NamingStrategy = new OrmLiteNamingStrategyBase();
}
public void Transaction_commits_inserts_to_different_tables()
{
using (var db = new OrmLiteConnectionFactory(ConnectionString, FirebirdDialect.Provider).Open())
{
db.CreateTable <ModelWithIdAndName>(true);
db.CreateTable <ModelWithFieldsOfDifferentTypes>(true);
db.CreateTable <ModelWithOnlyStringFields>(true);
db.DeleteAll <ModelWithIdAndName>();
db.Insert(new ModelWithIdAndName(0));
using (var dbTrans = db.BeginTransaction())
{
db.Insert(new ModelWithIdAndName(0));
db.Insert(ModelWithFieldsOfDifferentTypes.Create(3));
db.Insert(ModelWithOnlyStringFields.Create("id3"));
Assert.That(db.Select <ModelWithIdAndName>(), Has.Count.EqualTo(2));
Assert.That(db.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(1));
Assert.That(db.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(1));
dbTrans.Commit();
}
Assert.That(db.Select <ModelWithIdAndName>(), Has.Count.EqualTo(2));
Assert.That(db.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(1));
Assert.That(db.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(1));
}
}
public void Can_loop_each_with_filter_from_ModelWithOnlyStringFields_table()
{
using (var db = OpenDbConnection())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var filterRow = ModelWithOnlyStringFields.Create("id-4");
filterRow.AlbumName = "FilteredName";
db.Insert(filterRow);
db.GetLastSql().Print();
var dbRowIds = new List <string>();
var rows = db.SelectLazyFmt <ModelWithOnlyStringFields>("\"album_name\" = {0}", filterRow.AlbumName);
foreach (var row in rows)
{
dbRowIds.Add(row.Id);
}
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
}
}
public void Transaction_rollsback_transactions_to_different_tables()
{
using (var db = OpenDbConnection())
{
db.CreateTable <ModelWithIdAndName>(true);
db.CreateTable <ModelWithFieldsOfDifferentTypes>(true);
db.CreateTable <ModelWithOnlyStringFields>(true);
db.Insert(new ModelWithIdAndName(1));
using (var dbTrans = db.BeginTransaction())
{
db.Insert(new ModelWithIdAndName(2));
db.Insert(ModelWithFieldsOfDifferentTypes.Create(3));
db.Insert(ModelWithOnlyStringFields.Create("id3"));
Assert.That(db.Select <ModelWithIdAndName>(), Has.Count.EqualTo(2));
Assert.That(db.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(1));
Assert.That(db.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(1));
}
Assert.That(db.Select <ModelWithIdAndName>(), Has.Count.EqualTo(1));
Assert.That(db.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(0));
Assert.That(db.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(0));
}
}
public void TransactionScope_rollsback_transactions_to_different_tables()
{
using (var db1 = OpenDbConnection())
{
db1.CreateTable <ModelWithIdAndName>(true);
db1.CreateTable <ModelWithFieldsOfDifferentTypes>(true);
db1.CreateTable <ModelWithOnlyStringFields>(true);
db1.Insert(new ModelWithIdAndName(1));
using (var scope = new TransactionScope())
using (var db = _dialectProvider.CreateConnection(ConnectionString))
{
db.Open();
db.Insert(new ModelWithIdAndName(2));
db.Insert(ModelWithFieldsOfDifferentTypes.Create(3));
db.Insert(ModelWithOnlyStringFields.Create("id3"));
Assert.That(db.Select <ModelWithIdAndName>(), Has.Count.EqualTo(2));
Assert.That(db.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(1));
Assert.That(db.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(1));
}
Assert.That(db1.Select <ModelWithIdAndName>(), Has.Count.EqualTo(1));
Assert.That(db1.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(0));
Assert.That(db1.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(0));
}
}
public void Transaction_rollsback_transactions_to_different_tables()
{
if (Dialect == Dialect.Firebird)
{
return; //Keeps Table locked
}
using (var db = OpenDbConnection())
{
db.DropAndCreateTable <ModelWithIdAndName>();
db.DropAndCreateTable <ModelWithFieldsOfDifferentTypes>();
db.DropAndCreateTable <ModelWithOnlyStringFields>();
db.Insert(new ModelWithIdAndName(1));
using (var dbTrans = db.OpenTransaction())
{
db.Insert(new ModelWithIdAndName(2));
db.Insert(ModelWithFieldsOfDifferentTypes.Create(3));
db.Insert(ModelWithOnlyStringFields.Create("id3"));
Assert.That(db.Select <ModelWithIdAndName>(), Has.Count.EqualTo(2));
Assert.That(db.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(1));
Assert.That(db.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(1));
}
Assert.That(db.Select <ModelWithIdAndName>(), Has.Count.EqualTo(1));
Assert.That(db.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(0));
Assert.That(db.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(0));
}
}
public void Can_loop_each_with_filter_from_ModelWithOnlyStringFields_table()
{
using (var db = new OrmLiteConnectionFactory(ConnectionString, FirebirdDialect.Provider).Open())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var filterRow = ModelWithOnlyStringFields.Create("id-4");
filterRow.AlbumName = "FilteredName";
db.Insert(filterRow);
var dbRowIds = new List <string>();
var rows = db.EachWhere <ModelWithOnlyStringFields>(new { filterRow.AlbumName });
foreach (var row in rows)
{
dbRowIds.Add(row.Id);
}
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
}
}
public void TransactionScope_commits_inserts_to_different_tables()
{
using (var db = OpenDbConnection())
{
db.CreateTable <ModelWithIdAndName>(true);
db.CreateTable <ModelWithFieldsOfDifferentTypes>(true);
db.CreateTable <ModelWithOnlyStringFields>(true);
db.Insert(new ModelWithIdAndName(1));
using (var scope = new TransactionScope())
{
db.Insert(new ModelWithIdAndName(2));
db.Insert(ModelWithFieldsOfDifferentTypes.Create(3));
db.Insert(ModelWithOnlyStringFields.Create("id3"));
Assert.That(db.Select <ModelWithIdAndName>(), Has.Count.EqualTo(2));
Assert.That(db.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(1));
Assert.That(db.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(1));
scope.Complete();
}
Assert.That(db.Select <ModelWithIdAndName>(), Has.Count.EqualTo(2));
Assert.That(db.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(1));
Assert.That(db.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(1));
}
}
public void Can_GetSingle_with_filter_from_ModelWithOnlyStringFields_table()
{
using (var db = OpenDbConnection())
{
db.DropAndCreateTable <ModelWithOnlyStringFields>();
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var filterRow = ModelWithOnlyStringFields.Create("id-4");
filterRow.AlbumName = "FilteredName";
db.Insert(filterRow);
var row = db.Single <ModelWithOnlyStringFields>(new { filterRow.AlbumName });
Assert.That(row.Id, Is.EqualTo(filterRow.Id));
row = db.Single <ModelWithOnlyStringFields>(new { filterRow.AlbumName });
Assert.That(row.AlbumName, Is.EqualTo(filterRow.AlbumName));
row = db.Single <ModelWithOnlyStringFields>(new { AlbumName = "Junk", Id = (object)null });
Assert.That(row, Is.Null);
}
}
public void Can_loop_each_with_filter_from_ModelWithOnlyStringFields_table()
{
using (var db = OpenDbConnection())
{
db.DropAndCreateTable <ModelWithOnlyStringFields>();
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var filterRow = ModelWithOnlyStringFields.Create("id-4");
filterRow.AlbumName = "FilteredName";
db.Insert(filterRow);
var dbRowIds = new List <string>();
var rows = db.WhereLazy <ModelWithOnlyStringFields>(new { filterRow.AlbumName });
foreach (var row in rows)
{
dbRowIds.Add(row.Id);
}
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
}
}
public void Transaction_commits_inserts_to_different_tables()
{
using (var db = ConnectionString.OpenDbConnection())
using (var dbCmd = db.CreateCommand())
{
dbCmd.CreateTable <ModelWithIdAndName>(true);
dbCmd.CreateTable <ModelWithFieldsOfDifferentTypes>(true);
dbCmd.CreateTable <ModelWithOnlyStringFields>(true);
dbCmd.DeleteAll <ModelWithIdAndName>();
dbCmd.Insert(new ModelWithIdAndName(0));
using (var dbTrans = dbCmd.BeginTransaction())
{
dbCmd.Insert(new ModelWithIdAndName(0));
dbCmd.Insert(ModelWithFieldsOfDifferentTypes.Create(3));
dbCmd.Insert(ModelWithOnlyStringFields.Create("id3"));
Assert.That(dbCmd.Select <ModelWithIdAndName>(), Has.Count.EqualTo(2));
Assert.That(dbCmd.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(1));
Assert.That(dbCmd.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(1));
dbTrans.Commit();
}
Assert.That(dbCmd.Select <ModelWithIdAndName>(), Has.Count.EqualTo(2));
Assert.That(dbCmd.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(1));
Assert.That(dbCmd.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(1));
}
}
public void Can_get_data_from_TableWithNamigStrategy_with_GetById()
{
OrmLiteConfig.DialectProvider.NamingStrategy =
OrmLiteConfig.DialectProvider.NamingStrategy = new PrefixNamingStrategy
{
TablePrefix = "tab_",
ColumnPrefix = "col_",
};
using (var db = OpenDbConnection())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
var m = new ModelWithOnlyStringFields
{
Id = "999",
AlbumId = "112",
AlbumName = "ElectroShip",
Name = "MyNameIsBatman"
};
db.Save(m);
var modelFromDb = db.GetById <ModelWithOnlyStringFields>("999");
Assert.AreEqual(m.Name, modelFromDb.Name);
}
OrmLiteConfig.DialectProvider.NamingStrategy = new OrmLiteNamingStrategyBase();
}
public void Transaction_commits_inserts_to_different_tables()
{
using (var db = Config.OpenDbConnection())
{
db.DropAndCreateTable <ModelWithIdAndName>();
db.DropAndCreateTable <ModelWithFieldsOfDifferentTypes>();
db.DropAndCreateTable <ModelWithOnlyStringFields>();
db.Insert(new ModelWithIdAndName(1));
using (var dbTrans = db.OpenTransaction())
{
db.Insert(new ModelWithIdAndName(2));
db.Insert(ModelWithFieldsOfDifferentTypes.Create(3));
db.Insert(ModelWithOnlyStringFields.Create("id3"));
Assert.That(db.Select <ModelWithIdAndName>(), Has.Count.EqualTo(2));
Assert.That(db.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(1));
Assert.That(db.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(1));
dbTrans.Commit();
}
Assert.That(db.Select <ModelWithIdAndName>(), Has.Count.EqualTo(2));
Assert.That(db.Select <ModelWithFieldsOfDifferentTypes>(), Has.Count.EqualTo(1));
Assert.That(db.Select <ModelWithOnlyStringFields>(), Has.Count.EqualTo(1));
}
}
public void Can_get_data_from_TableWithNamigStrategy_AfterChangingNamingStrategy()
{
using (new TemporaryNamingStrategy(new PrefixNamingStrategy {
TablePrefix = "tab_", ColumnPrefix = "col_"
}))
using (var db = OpenDbConnection())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
ModelWithOnlyStringFields m = new ModelWithOnlyStringFields()
{
Id = "998", AlbumId = "112", AlbumName = "ElectroShip", Name = "QueryByExample"
};
db.Save <ModelWithOnlyStringFields>(m);
var modelFromDb = db.Where <ModelWithOnlyStringFields>(new { Name = "QueryByExample" })[0];
Assert.AreEqual(m.Name, modelFromDb.Name);
modelFromDb = db.SingleById <ModelWithOnlyStringFields>("998");
Assert.AreEqual(m.Name, modelFromDb.Name);
}
using (var db = OpenDbConnection())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
ModelWithOnlyStringFields m = new ModelWithOnlyStringFields()
{
Id = "998", AlbumId = "112", AlbumName = "ElectroShip", Name = "QueryByExample"
};
db.Save <ModelWithOnlyStringFields>(m);
var modelFromDb = db.Where <ModelWithOnlyStringFields>(new { Name = "QueryByExample" })[0];
Assert.AreEqual(m.Name, modelFromDb.Name);
modelFromDb = db.SingleById <ModelWithOnlyStringFields>("998");
Assert.AreEqual(m.Name, modelFromDb.Name);
}
using (new TemporaryNamingStrategy(new PrefixNamingStrategy {
TablePrefix = "tab_", ColumnPrefix = "col_"
}))
using (var db = OpenDbConnection())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
ModelWithOnlyStringFields m = new ModelWithOnlyStringFields()
{
Id = "998", AlbumId = "112", AlbumName = "ElectroShip", Name = "QueryByExample"
};
db.Save <ModelWithOnlyStringFields>(m);
var modelFromDb = db.Where <ModelWithOnlyStringFields>(new { Name = "QueryByExample" })[0];
Assert.AreEqual(m.Name, modelFromDb.Name);
modelFromDb = db.SingleById <ModelWithOnlyStringFields>("998");
Assert.AreEqual(m.Name, modelFromDb.Name);
}
}
public void Populate_Different_Objects_with_different_property_types()
{
var toObj = ModelWithFieldsOfDifferentTypes.Create(1);
var fromObj = ModelWithOnlyStringFields.Create("2");
var obj3 = AutoMappingUtils.PopulateWith(toObj, fromObj);
Assert.IsTrue(obj3 == toObj);
Assert.That(obj3.Id, Is.EqualTo(2));
Assert.That(obj3.Name, Is.EqualTo(fromObj.Name));
}
public void Can_GetById_string_from_ModelWithOnlyStringFields_table()
{
using (var db = OpenDbConnection())
{
db.DropAndCreateTable <ModelWithOnlyStringFields>();
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var row = db.SingleById <ModelWithOnlyStringFields>("id-1");
Assert.That(row.Id, Is.EqualTo("id-1"));
}
}
public void Can_GetById_string_from_ModelWithOnlyStringFields_table()
{
using (var db = new OrmLiteConnectionFactory(ConnectionString, FirebirdDialect.Provider).Open())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var row = db.SingleById <ModelWithOnlyStringFields>("id-1");
Assert.That(row.Id, Is.EqualTo("id-1"));
}
}
public void Can_GetByIds_string_from_ModelWithOnlyStringFields_table()
{
using (var db = new OrmLiteConnectionFactory(ConnectionString, FirebirdDialect.Provider).Open())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var rows = db.SelectByIds <ModelWithOnlyStringFields>(rowIds);
var dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Is.EquivalentTo(rowIds));
}
}
public void Can_GetById_string_from_ModelWithOnlyStringFields_table()
{
using (var db = ConnectionString.OpenDbConnection())
using (var dbCmd = db.CreateCommand())
{
dbCmd.CreateTable <ModelWithOnlyStringFields>(true);
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => dbCmd.Insert(ModelWithOnlyStringFields.Create(x)));
var row = dbCmd.GetById <ModelWithOnlyStringFields>("id-1");
Assert.That(row.Id, Is.EqualTo("id-1"));
}
}
public void Can_GetByIds_string_from_ModelWithOnlyStringFields_table()
{
using (var db = OpenDbConnection())
{
db.DropAndCreateTable <ModelWithOnlyStringFields>();
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var rows = db.SelectByIds <ModelWithOnlyStringFields>(rowIds);
var dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Is.EquivalentTo(rowIds));
}
}
public void Populate_From_Properties_With_Attribute()
{
var originalToObj = ModelWithOnlyStringFields.Create("id-1");
var toObj = ModelWithOnlyStringFields.Create("id-1");
var fromObj = ModelWithOnlyStringFields.Create("id-2");
AutoMappingUtils.PopulateFromPropertiesWithAttribute(toObj, fromObj,
typeof(IndexAttribute));
Assert.That(toObj.Id, Is.EqualTo(originalToObj.Id));
Assert.That(toObj.AlbumId, Is.EqualTo(originalToObj.AlbumId));
//Properties with IndexAttribute
Assert.That(toObj.Name, Is.EqualTo(fromObj.Name));
Assert.That(toObj.AlbumName, Is.EqualTo(fromObj.AlbumName));
}
public void Can_get_data_from_TableWithUnderscoreSeparatedCompoundNamingStrategy_with_ReadConnectionExtension()
{
using (new TemporaryNamingStrategy(new UnderscoreSeparatedCompoundNamingStrategy()))
using (var db = OpenDbConnection())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
var m = new ModelWithOnlyStringFields
{
Id = "997",
AlbumId = "112",
AlbumName = "ElectroShip",
Name = "ReadConnectionExtensionFirst"
};
db.Save(m);
var modelFromDb = db.Single <ModelWithOnlyStringFields>(x => x.Name == "ReadConnectionExtensionFirst");
Assert.AreEqual(m.AlbumName, modelFromDb.AlbumName);
}
}
public void Can_get_data_from_TableWithNamingStrategy_with_GetById()
{
using (new TemporaryNamingStrategy(new PrefixNamingStrategy {
TablePrefix = "tab_", ColumnPrefix = "col_"
}))
using (var db = OpenDbConnection())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
var m = new ModelWithOnlyStringFields {
Id = "999", AlbumId = "112", AlbumName = "ElectroShip", Name = "MyNameIsBatman"
};
db.Save(m);
var modelFromDb = db.SingleById <ModelWithOnlyStringFields>("999");
Assert.AreEqual(m.Name, modelFromDb.Name);
}
}
public void Can_select_with_filter_from_ModelWithOnlyStringFields_table()
{
using (var db = OpenDbConnection())
{
db.DropAndCreateTable <ModelWithOnlyStringFields>();
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var filterRow = ModelWithOnlyStringFields.Create("id-4");
filterRow.AlbumName = "FilteredName";
db.Insert(filterRow);
var rows = db.Where <ModelWithOnlyStringFields>(new { filterRow.AlbumName });
var dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
rows = db.Where <ModelWithOnlyStringFields>(new { filterRow.AlbumName });
dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
var queryByExample = new ModelWithOnlyStringFields {
AlbumName = filterRow.AlbumName
};
rows = db.SelectNonDefaults(queryByExample);
dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
SuppressIfOracle("Oracle provider is not smart enough to substitute ':' for '@' parameter delimiter.");
rows = db.Select <ModelWithOnlyStringFields>(
"SELECT * FROM {0} WHERE {1} = @AlbumName"
.Fmt("ModelWithOnlyStringFields".SqlTable(), "AlbumName".SqlColumn()),
new { filterRow.AlbumName });
dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
}
}
public void Can_get_data_from_TableWithNamigStrategy_with_query_by_example()
{
using (new TemporaryNamingStrategy(new PrefixNamingStrategy {
TablePrefix = "tab_", ColumnPrefix = "col_"
}))
using (var db = new OrmLiteConnectionFactory(ConnectionString, FirebirdDialect.Provider).Open())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
ModelWithOnlyStringFields m = new ModelWithOnlyStringFields()
{
Id = "998", AlbumId = "112", AlbumName = "ElectroShip", Name = "QueryByExample"
};
db.Save <ModelWithOnlyStringFields>(m);
var modelFromDb = db.Where <ModelWithOnlyStringFields>(new { Name = "QueryByExample" })[0];
Assert.AreEqual(m.Name, modelFromDb.Name);
}
}
public void Can_loop_each_string_from_ModelWithOnlyStringFields_table()
{
using (var db = new OrmLiteConnectionFactory(ConnectionString, FirebirdDialect.Provider).Open())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var dbRowIds = new List <string>();
foreach (var row in db.SelectLazy <ModelWithOnlyStringFields>())
{
dbRowIds.Add(row.Id);
}
Assert.That(dbRowIds, Is.EquivalentTo(rowIds));
}
}
public void Can_loop_each_string_from_ModelWithOnlyStringFields_table()
{
using (var db = OpenDbConnection())
{
db.DropAndCreateTable <ModelWithOnlyStringFields>();
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var dbRowIds = new List <string>();
foreach (var row in db.SelectLazy <ModelWithOnlyStringFields>())
{
dbRowIds.Add(row.Id);
}
Assert.That(dbRowIds, Is.EquivalentTo(rowIds));
}
}
public void Can_loop_each_string_from_ModelWithOnlyStringFields_table()
{
using (var db = ConnectionString.OpenDbConnection())
using (var dbCmd = db.CreateCommand())
{
dbCmd.CreateTable <ModelWithOnlyStringFields>(true);
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => dbCmd.Insert(ModelWithOnlyStringFields.Create(x)));
var dbRowIds = new List <string>();
foreach (var row in dbCmd.Each <ModelWithOnlyStringFields>())
{
dbRowIds.Add(row.Id);
}
Assert.That(dbRowIds, Is.EquivalentTo(rowIds));
}
}
public void Can_select_with_filter_from_ModelWithOnlyStringFields_table()
{
using (var db = ConnectionString.OpenDbConnection())
using (var dbCmd = db.CreateCommand())
{
dbCmd.CreateTable <ModelWithOnlyStringFields>(true);
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => dbCmd.Insert(ModelWithOnlyStringFields.Create(x)));
var filterRow = ModelWithOnlyStringFields.Create("id-4");
filterRow.AlbumName = "FilteredName";
dbCmd.Insert(filterRow);
var rows = dbCmd.Where <ModelWithOnlyStringFields>(new { filterRow.AlbumName });
var dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
rows = dbCmd.Where <ModelWithOnlyStringFields>(new { filterRow.AlbumName });
dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
var queryByExample = new ModelWithOnlyStringFields {
AlbumName = filterRow.AlbumName
};
rows = dbCmd.ByExampleWhere <ModelWithOnlyStringFields>(queryByExample);
dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
rows = dbCmd.Query <ModelWithOnlyStringFields>(
"SELECT * FROM ModelWithOnlyStringFields WHERE AlbumName = @AlbumName", new { filterRow.AlbumName });
dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
}
}
public void Can_select_with_filter_from_ModelWithOnlyStringFields_table()
{
using (var db = new OrmLiteConnectionFactory(ConnectionString, FirebirdDialect.Provider).Open())
{
db.CreateTable <ModelWithOnlyStringFields>(true);
var rowIds = new List <string>(new[] { "id-1", "id-2", "id-3" });
rowIds.ForEach(x => db.Insert(ModelWithOnlyStringFields.Create(x)));
var filterRow = ModelWithOnlyStringFields.Create("id-4");
filterRow.AlbumName = "FilteredName";
db.Insert(filterRow);
var rows = db.Where <ModelWithOnlyStringFields>(new { filterRow.AlbumName });
var dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
rows = db.Where <ModelWithOnlyStringFields>(new { filterRow.AlbumName });
dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
var queryByExample = new ModelWithOnlyStringFields {
AlbumName = filterRow.AlbumName
};
rows = db.SelectNonDefaults(queryByExample);
dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
rows = db.Select <ModelWithOnlyStringFields>(
"SELECT * FROM ModelWithOnlyStringFields WHERE AlbumName = @AlbumName", new { filterRow.AlbumName });
dbRowIds = rows.ConvertAll(x => x.Id);
Assert.That(dbRowIds, Has.Count.EqualTo(1));
Assert.That(dbRowIds[0], Is.EqualTo(filterRow.Id));
}
}
