private static IEmbeddedConfiguration Db4oConfig(IEmbeddedConfiguration db4oConfig
)
{
db4oConfig.Common.ReflectWith(Platform4.ReflectorForType(typeof (Data
)));
return db4oConfig;
}
public virtual void Querydb(IEmbeddedConfiguration config, int[] count, Type class1
, Type class2)
{
IEmbeddedObjectContainer database = Db4oEmbedded.OpenFile(config, TempFile());
try
{
IList list = database.Query(class1);
Assert.AreEqual(count[0], list.Count, "Unexpected result querying for " + class1.
Name);
if (count[0] > 0)
{
}
// System.out.println("Querying for " + class1.getSimpleName() + " getting " + list.get(0).getClass().getSimpleName());
IList list1 = database.Query(class2);
Assert.AreEqual(count[1], list1.Count, "Unexpected result querying for " + class2
.Name);
if (count[1] > 0)
{
}
}
finally
{
// System.out.println("Querying for " + class2.getSimpleName() + " getting " + list1.get(0).getClass().getSimpleName());
database.Close();
}
}
internal void Verify(IEmbeddedConfiguration config, IEmbeddedObjectContainer container
)
{
Assert.AreSame(config, _config);
Assert.AreSame(container, _container);
Assert.AreEqual(1, _prepareCount);
Assert.AreEqual(1, _applyCount);
}
public static DefragmentConfig DefragConfig(string sourceFile, IEmbeddedConfiguration
db4oConfig, bool forceBackupDelete)
{
var defragConfig = new DefragmentConfig(sourceFile, DefragmentTestCaseBase
.BackupFileNameFor(sourceFile));
defragConfig.ForceBackupDelete(forceBackupDelete);
defragConfig.Db4oConfig(Db4oConfig(db4oConfig));
return defragConfig;
}
private void Read(IEmbeddedConfiguration config)
{
IObjectContainer oc = Open(config);
IObjectSet objectSet = AllItems(oc);
while (objectSet.HasNext())
{
Item item = (Item)objectSet.Next();
}
oc.Close();
}
private void Configure(IEmbeddedConfiguration config)
{
config.Common.Diagnostic.AddListener(this);
config.File.GenerateCommitTimestamps = true;
config.File.GenerateUUIDs = ConfigScope.Globally;
config.Common.ObjectClass(typeof (Item)).ObjectField
("_itemName").Indexed(true);
config.Common.ObjectClass(typeof (Parent)).ObjectField
("_parentName").Indexed(true);
}
private long StoreItemAndGetCommitTimestamp(IEmbeddedConfiguration config)
{
var db = OpenContainer(config);
var item = new Item
();
db.Store(item);
db.Commit();
var commitTimestamp = db.Ext().GetObjectInfo(item).GetCommitTimestamp();
db.Close();
return commitTimestamp;
}
public static void CreateFile(string fileName, IEmbeddedConfiguration config)
{
IObjectContainer db = Db4oEmbedded.OpenFile(config, fileName);
Data data = null;
for (var value = Value - 1; value <= Value + 1; value++)
{
data = new Data(value, data);
db.Store(data);
}
db.Close();
}
private long StoreItemAndGetCommitTimestamp(IEmbeddedConfiguration config)
{
IEmbeddedObjectContainer db = OpenContainer(config);
CommitTimestampDefragmentTestCase.Item item = new CommitTimestampDefragmentTestCase.Item
();
db.Store(item);
db.Commit();
long commitTimestamp = db.Ext().GetObjectInfo(item).GetCommitTimestamp();
db.Close();
return commitTimestamp;
}
private void AssertVersionAfterDefrag(long version, IEmbeddedConfiguration afterDefragConfig
)
{
IEmbeddedObjectContainer db = OpenContainer(afterDefragConfig);
CommitTimestampDefragmentTestCase.Item retrievedItem = ((CommitTimestampDefragmentTestCase.Item
)db.Query(typeof(CommitTimestampDefragmentTestCase.Item)).Next());
long retrievedVersion = db.Ext().GetObjectInfo(retrievedItem).GetCommitTimestamp(
);
Assert.AreEqual(version, retrievedVersion);
db.Close();
}
/// <exception cref="Db4objects.Db4o.Ext.OldFormatException"></exception>
public static IEmbeddedObjectContainer OpenObjectContainer(IEmbeddedConfiguration
config, string databaseFileName)
{
IConfiguration legacyConfig = Db4oLegacyConfigurationBridge.AsLegacy(config);
Config4Impl.AssertIsNotTainted(legacyConfig);
EmitDebugInfo();
IEmbeddedObjectContainer oc = new IoAdaptedObjectContainer(legacyConfig, databaseFileName
);
((EmbeddedConfigurationImpl)config).ApplyConfigurationItems(oc);
Db4objects.Db4o.Internal.Messages.LogMsg(legacyConfig, 5, databaseFileName);
return oc;
}
private void Update(IEmbeddedConfiguration config)
{
IObjectContainer oc = Open(config);
IObjectSet objectSet = AllItems(oc);
while (objectSet.HasNext())
{
Item item = (Item)objectSet.Next();
item.Change();
oc.Store(item);
}
oc.Close();
}
private void WithDatabase(IEmbeddedConfiguration config, IDatabaseAction
action)
{
IObjectContainer db = Db4oEmbedded.OpenFile(config, TempFile());
try
{
action.RunWith(db);
}
finally
{
db.Close();
}
}
private void Delete(IEmbeddedConfiguration config)
{
IObjectContainer oc = Open(config);
IObjectSet objectSet = AllItems(oc);
while (objectSet.HasNext())
{
oc.Delete(objectSet.Next());
// adding commit results in more syncs in the log,
// which is necessary for meaningful statistics!
oc.Commit();
}
oc.Close();
}
public virtual void QueryDb(IEmbeddedConfiguration config, Type clazz, int count)
{
IEmbeddedObjectContainer database = Db4oEmbedded.OpenFile(config, TempFile());
try
{
IList list = database.Query(clazz);
Assert.AreEqual(count, list.Count);
}
finally
{
database.Close();
}
}
public static FileUsageStats RunStats(string dbPath, bool collectSlots, IEmbeddedConfiguration
config)
{
IEmbeddedObjectContainer db = Db4oEmbedded.OpenFile(config, dbPath);
try
{
return new Db4objects.Db4o.Filestats.FileUsageStatsCollector(db, collectSlots).CollectStats
();
}
finally
{
db.Close();
}
}
private void Create(int itemCount, IEmbeddedConfiguration config)
{
IObjectContainer oc = Open(config);
for (int i = 0; i < itemCount; i++)
{
oc.Store(Item.NewItem(i));
// preventing heap space problems by committing from time to time
if (i % 100000 == 0)
{
oc.Commit();
}
}
oc.Commit();
oc.Close();
}
/// <summary>
/// 获取数据库对象
/// </summary>
/// <param name="_claobj">更新的对象</param>
/// <returns></returns>
public IObjectContainer GetDbObj(object _claobj)
{
IObjectContainer db = null;
try
{
configuration = Db4oEmbedded.NewConfiguration();
// Update all referenced objects for the Driver class
configuration.Common.ObjectClass(_claobj).CascadeOnUpdate(true);
db = Db4oEmbedded.OpenFile(configuration, DbSavePath);
}
catch(Exception ex)
{
}
return db;
}
private void QueriesInSivlerlight()
{
IEmbeddedConfiguration configuration = Db4oEmbedded.NewConfiguration();
configuration.File.Storage = new IsolatedStorageStorage();
IObjectContainer container = Db4oEmbedded.OpenFile(configuration, "database.db4o");
// #example: Queries in Silverlight
var persons = from Person p in container
where p.FirstName.Contains("Roman")
select p;
foreach (Person person in persons)
{
// do something with the person
}
// #end example
}
public static void ForceIndex(string databaseFileName, IEmbeddedConfiguration config
)
{
config.Common.ObjectClass(typeof (Data)).ObjectField(PrimitiveFieldname
).Indexed(true);
config.Common.ObjectClass(typeof (Data)).ObjectField(WrapperFieldname
).Indexed(true);
config.Common.ObjectClass(typeof (Data)).ObjectField(TypedobjectFieldname
).Indexed(true);
IObjectContainer db = Db4oEmbedded.OpenFile(config, databaseFileName);
Assert.IsTrue(db.Ext().StoredClass(typeof (Data)).StoredField
(PrimitiveFieldname, typeof (int)).HasIndex());
Assert.IsTrue(db.Ext().StoredClass(typeof (Data)).StoredField
(WrapperFieldname, typeof (int)).HasIndex());
Assert.IsTrue(db.Ext().StoredClass(typeof (Data)).StoredField
(TypedobjectFieldname, typeof (Data)).HasIndex());
db.Close();
}
private static void IncreaseUpdateDepth()
{
// #example: Increase the update depth to 2
IEmbeddedConfiguration configuration = Db4oEmbedded.NewConfiguration();
configuration.Common.UpdateDepth = 2;
// #end example
using (IObjectContainer container = Db4oEmbedded.OpenFile(configuration, DatabaseFile))
{
Driver driver = QueryForDriver(container);
driver.Name = "Joe";
driver.MostLovedCar.CarName = "Red Ferrari";
driver.AddOwnedCar(new Car("Fiat Punto"));
container.Store(driver);
}
PrintOutContent();
}
private static void StoreItems(PagingMemoryStorage storage)
{
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.File.Storage = storage;
IEmbeddedObjectContainer container = Db4oEmbedded.OpenFile(config, "benchmark.db4o"
);
try
{
for (int i = 0; i < ObjectCount; ++i)
{
container.Store(new SodaQueryComparatorBenchmark.Item(i, "Item " + i, new SodaQueryComparatorBenchmark.ItemChild
("Child " + i)));
}
}
finally
{
container.Close();
}
}
public static void AddRooms(int roomID, int RoomNum, int Persons, string Beds)
{
string path = Directory.GetCurrentDirectory() + "\\database.srph";
IObjectContainer db;
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.ObjectClass(typeof(Rooms)).CascadeOnUpdate(true);
config.Common.ObjectClass(typeof(Rooms)).CascadeOnDelete(true);
config.Common.ObjectClass(typeof(Rooms)).CascadeOnActivate(true);
db = Db4oEmbedded.OpenFile(config, path);
var room = new Rooms(RoomNum, Persons, Beds);
db.Store(room);
db.Commit();
db.Close();
}
public static List <Reservation> GetReservations()
{
string path = Directory.GetCurrentDirectory() + "\\database.srph";
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.ObjectClass(typeof(Reservation)).CascadeOnUpdate(true);
config.Common.ObjectClass(typeof(Reservation)).CascadeOnDelete(true);
config.Common.ObjectClass(typeof(Reservation)).CascadeOnActivate(true);
List <Reservation> Reservations;
using (IObjectContainer db = Db4oEmbedded.OpenFile(config, path))
{
Reservations = (from Reservation r in db select r).ToList();
}
return(Reservations.ToList <Reservation>());
}
public static void DeleteAll()
{
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.ObjectClass(typeof(Car)).CascadeOnDelete(true);
using (IObjectContainer db = Db4oEmbedded.OpenFile(config, YapFileName))
{
var result = db.QueryByExample(new Car(null, null));
foreach (object car in result)
{
db.Delete(car);
}
var readouts = db.QueryByExample(new SensorReadout(null, DateTime.MinValue, null));
foreach (object readout in readouts)
{
db.Delete(readout);
}
}
}
public static void ForceIndex(string databaseFileName, IEmbeddedConfiguration config
)
{
config.Common.ObjectClass(typeof(Data)).ObjectField(PrimitiveFieldname
).Indexed(true);
config.Common.ObjectClass(typeof(Data)).ObjectField(WrapperFieldname
).Indexed(true);
config.Common.ObjectClass(typeof(Data)).ObjectField(TypedobjectFieldname
).Indexed(true);
IObjectContainer db = Db4oEmbedded.OpenFile(config, databaseFileName);
Assert.IsTrue(db.Ext().StoredClass(typeof(Data)).StoredField
(PrimitiveFieldname, typeof(int)).HasIndex());
Assert.IsTrue(db.Ext().StoredClass(typeof(Data)).StoredField
(WrapperFieldname, typeof(int)).HasIndex());
Assert.IsTrue(db.Ext().StoredClass(typeof(Data)).StoredField
(TypedobjectFieldname, typeof(Data)).HasIndex());
db.Close();
}
private static void MarkTransient()
{
CleanUp();
// #example: add an transient marker annotatin
IEmbeddedConfiguration configuration = Db4oEmbedded.NewConfiguration();
configuration.Common.MarkTransient(typeof(TransientMarkerAttribute).FullName);
// #end example
IObjectContainer container = Db4oEmbedded.OpenFile(configuration, DatabaseFile);
container.Store(new WithTransient());
container.Close();
ReadWithTransientMarker();
CleanUp();
}
private static void ActivationJustWorks()
{
// #example: Configure transparent persistence
IEmbeddedConfiguration configuration = Db4oEmbedded.NewConfiguration();
configuration.Common.Add(new TransparentPersistenceSupport(new DeactivatingRollbackStrategy()));
using (IObjectContainer container = Db4oEmbedded.OpenFile(configuration, DatabaseFileName))
// #end example
{
//#example: Transparent persistence manages activation
Driver driver = QueryForDriver(container);
// Transparent persistence will activate objects as needed
Console.WriteLine("Is activated? " + container.Ext().IsActive(driver));
string nameOfDriver = driver.Name;
Console.WriteLine("The name is " + nameOfDriver);
Console.WriteLine("Is activated? " + container.Ext().IsActive(driver));
//#end example
}
}
public static void DeleteDeepRevisited()
{
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.ObjectClass(typeof(Car)).CascadeOnDelete(true);
using (IObjectContainer db = Db4oEmbedded.OpenFile(config, YapFileName))
{
IObjectSet result = db.QueryByExample(new Pilot("Michael Schumacher", 0));
Pilot pilot = (Pilot)result.Next();
Car car1 = new Car("Ferrari");
Car car2 = new Car("BMW");
car1.Pilot = pilot;
car2.Pilot = pilot;
db.Store(car1);
db.Store(car2);
db.Delete(car2);
result = db.QueryByExample(new Car(null));
ListResult(result);
}
}
/// <summary>
/// 初始化DB引擎
/// </summary>
/// <param name="fileName">默认在应用程序启动目录,只用写文件名</param>
/// <returns></returns>
public static IObjectContainer InitDB4O(string fileName, Type t)
{
IObjectContainer _db;
try
{
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
string YapFileName = System.IO.Path.Combine(CommonHelper.GetAssemblyPath(), fileName);
config.Common.ObjectClass(t).CascadeOnActivate(true);
config.Common.ObjectClass(t).CascadeOnDelete(true);
config.Common.ObjectClass(t).CascadeOnUpdate(true);
config.Common.ActivationDepth = 20;
_db = Db4oEmbedded.OpenFile(config, YapFileName);
}
catch (Exception ex)
{
throw ex;
}
return(_db);
}
public static void ModifySnapshotHistory()
{
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.Add(new TransparentPersistenceSupport());
using (IObjectContainer db = Db4oEmbedded.OpenFile(config, YapFileName))
{
System.Console.WriteLine("Read all sensors and modify the description:");
IObjectSet result = db.QueryByExample(typeof(Car));
Car car = (Car)result.Next();
SensorReadout readout = car.History;
while (readout != null)
{
System.Console.WriteLine(readout);
readout.Description = "Modified: " + readout.Description;
readout = readout.Next;
}
db.Commit();
}
}
public static void DemonstrateTransparentActivation()
{
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.Add(new TransparentActivationSupport());
using(IObjectContainer db = Db4oEmbedded.OpenFile(config, YapFileName)){
IObjectSet result = db.QueryByExample(typeof (Car));
Car car = (Car) result.Next();
Console.WriteLine("#PilotWithoutActivation before the car is activated");
Console.WriteLine(car.PilotWithoutActivation);
Console.WriteLine("accessing 'Pilot' property activates the car object");
Console.WriteLine(car.Pilot);
Console.WriteLine("Accessing PilotWithoutActivation property after the car is activated");
Console.WriteLine(car.PilotWithoutActivation);
}
}
public static void DeleteReservation(int ResID)
{
string path = Directory.GetCurrentDirectory() + "\\database.srph";
//IObjectContainer db;
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.ObjectClass(typeof(Reservation)).CascadeOnUpdate(true);
config.Common.ObjectClass(typeof(Reservation)).CascadeOnDelete(true);
config.Common.ObjectClass(typeof(Reservation)).CascadeOnActivate(true);
using (IObjectContainer db = Db4oEmbedded.OpenFile(config, path))
{
var result = db.Query <Reservation>(x => x.ReservationID == ResID);
db.Delete(result);
db.Commit();
db.Close();
}
// db = Db4oEmbedded.OpenFile(config, path);
}
private void AssertInconsistencyDetected(IProcedure4 proc)
{
IEmbeddedConfiguration config = NewConfiguration();
LocalObjectContainer db = (LocalObjectContainer)Db4oEmbedded.OpenFile(config, TempFile
());
try
{
ConsistencyCheckerTestCase.Item item = new ConsistencyCheckerTestCase.Item();
db.Store(item);
db.Commit();
Assert.IsTrue(new ConsistencyChecker(db).CheckSlotConsistency().Consistent());
proc.Apply(new Pair(db, item));
db.Commit();
Assert.IsFalse(new ConsistencyChecker(db).CheckSlotConsistency().Consistent());
}
finally
{
db.Close();
}
}
public static Reservation GetReservation(int ResNumber)
{
string path = Directory.GetCurrentDirectory() + "\\database.srph";
// IObjectContainer db;
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.ObjectClass(typeof(Reservation)).CascadeOnUpdate(true);
config.Common.ObjectClass(typeof(Reservation)).CascadeOnDelete(true);
config.Common.ObjectClass(typeof(Reservation)).CascadeOnActivate(true);
//db = Db4oEmbedded.OpenFile(config, path);
using (IObjectContainer db = Db4oEmbedded.OpenFile(config, path))
{
var results = db.Query <Reservation>(x => x.ReservationID == ResNumber);
Reservation Reserv = results.First();
return(Reserv);
}
//jak jest puste to się wywala, trzeba to jakoś obudować
//try catch łapiesz i wywalasz komuniakt ex brak rezerwacji o danym idp-
}
public virtual void TestOpenWithNonStaticConfiguration()
{
IEmbeddedConfiguration config1 = NewConfiguration();
config1.File.ReadOnly = true;
Assert.Expect(typeof(DatabaseReadOnlyException), new _ICodeBlock_30(this, config1
));
IEmbeddedConfiguration config2 = NewConfiguration();
IObjectContainer db2 = Db4oEmbedded.OpenFile(config2, TempFile());
try
{
db2.Store(new GlobalVsNonStaticConfigurationTestCase.Data(2));
Assert.AreEqual(1, db2.Query(typeof(GlobalVsNonStaticConfigurationTestCase.Data))
.Count);
}
finally
{
db2.Close();
}
}
protected void Configure(IEmbeddedConfiguration config)
{
config.Common.Add(new JavaSupport());
config.Common.AddAlias(new TypeAlias("CollectionHolder", TypeName(typeof(CollectionHolder))));
config.Common.AddAlias(new TypeAlias("java.util.ArrayList", TypeName(typeof(ArrayList))));
config.Common.AddAlias(new TypeAlias("java.util.AbstractCollection",
TypeName(typeof(DummyAbstractCollection))));
config.Common.AddAlias(new TypeAlias("java.util.AbstractList", TypeName(typeof(DummyAbstractList))));
config.Common.AddAlias(new TypeAlias("com.db4o.typehandlers.IgnoreFieldsTypeHandler",
TypeName(typeof(IgnoreFieldsTypeHandler))));
config.Common.AddAlias(new TypeAlias("com.db4o.typehandlers.CollectionTypeHandler",
TypeName(typeof(IgnoreFieldsTypeHandler))));
config.Common.RegisterTypeHandler(new SingleClassTypeHandlerPredicate(typeof(DummyAbstractList)),
IgnoreFieldsTypeHandler.Instance);
config.Common.RegisterTypeHandler(new SingleClassTypeHandlerPredicate(typeof(DummyAbstractCollection)),
IgnoreFieldsTypeHandler.Instance);
}
protected override void StartRun()
{
string dbPath = Settings.Default.GetAppDataPath() + "xgobjects.db4o";
bool loadFromSqlite = false;
if (!System.IO.File.Exists(dbPath) && System.IO.File.Exists(Settings.Default.GetAppDataPath() + "xgobjects.db"))
{
loadFromSqlite = true;
}
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.StringEncoding = StringEncodings.Utf8();
config.Common.Add(new TransparentActivationSupport());
config.Common.Add(new TransparentPersistenceSupport());
/*if (System.IO.File.Exists(dbPath))
* {
* DefragmentConfig defragmentConfig = new DefragmentConfig(dbPath);
* defragmentConfig.Db4oConfig(config);
* Defragment.Defrag(defragmentConfig);
* }*/
_db = Db4oEmbedded.OpenFile(config, dbPath);
if (loadFromSqlite)
{
var sqliteConverter = new SqliteConverter();
sqliteConverter.Load();
_db.Store(sqliteConverter.Servers);
_db.Store(sqliteConverter.Files);
_db.Store(sqliteConverter.Searches);
_db.Store(sqliteConverter.ApiKeys);
_db.Commit();
}
Load();
}
public virtual void TestEmbedded()
{
IList missingClasses = new ArrayList();
IEmbeddedConfiguration excludingConfig = Db4oEmbedded.NewConfiguration();
PrepareHost(excludingConfig.File, excludingConfig.Common, missingClasses);
ExcludeClasses(excludingConfig.Common, new Type[] { typeof(MissingClassDiagnosticsTestCase.Pilot
), typeof(MissingClassDiagnosticsTestCase.Car) });
IEmbeddedObjectContainer excludingContainer = Db4oEmbedded.OpenFile(excludingConfig
, DbUri);
try
{
excludingContainer.Query(new MissingClassDiagnosticsTestCase.AcceptAllPredicate()
);
}
finally
{
excludingContainer.Close();
}
AssertPilotAndCarMissing(missingClasses);
}
public static void Main(string[] args)
{
// #example: Configure rollback strategy
IEmbeddedConfiguration configuration = Db4oEmbedded.NewConfiguration();
configuration.Common
.Add(new TransparentPersistenceSupport(new DeactivatingRollbackStrategy()));
// #end example
using (IObjectContainer container = Db4oEmbedded.OpenFile(configuration, "database.db4o"))
{
StorePilot(container);
// #example: Rollback with rollback strategy
Pilot pilot = container.Query <Pilot>()[0];
pilot.Name = "NewName";
// Rollback
container.Rollback();
// Now the pilot has the old name again
Console.Out.WriteLine(pilot.Name);
// #end example
}
}
public static void IndividualUUID()
{
// #example: Enable db4o uuids for certain classes
IEmbeddedConfiguration configuration = Db4oEmbedded.NewConfiguration();
configuration.File.GenerateUUIDs = ConfigScope.Individually;
configuration.Common.ObjectClass(typeof(SpecialClass)).GenerateUUIDs(true);
// #end example
IObjectContainer container = Db4oEmbedded.OpenFile(configuration, "database.db4o");
SpecialClass withUUID = new SpecialClass();
container.Store(withUUID);
NormalClass withoutUUID = new NormalClass();
container.Store(withoutUUID);
AssertNotNull(container.Ext().GetObjectInfo(withUUID).GetUUID());
AssertNull(container.Ext().GetObjectInfo(withoutUUID).GetUUID());
container.Close();
}
protected override void OpenDatabase()
{
if (string.IsNullOrEmpty(fileName))
{
throw new Exception("File name required");
}
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.UpdateDepth = 2;
foreach (IPropertyRepository repo in Collections)
{
foreach (PropertyInfo pi in repo.ContentsType.GetProperties().Where(p => p.PropertyType == typeof(DbImage)))
{
config.Common.ObjectClass(repo.ContentsType).ObjectField(pi.Name).CascadeOnUpdate(true);
config.Common.ObjectClass(repo.ContentsType).ObjectField(pi.Name).CascadeOnDelete(true);
}
}
OnConfigCreate(config);
container = Db4oEmbedded.OpenFile(config, fileName);
}
/// <summary>
/// Conecta com base de dados, caso não exista conexão ativa
/// </summary>
public void Conectar()
{
if (container == null)
{
//Cria configuração para container
config = Db4oEmbedded.NewConfiguration();
//TODO:REMOVER
config.Common.DetectSchemaChanges = true;
//Configura indices paras as models
//ConfigurarIndices();
//Profundidade de ativacao
config.Common.ActivationDepth = 8;
//Cria Instância para leitura do arquivo de configuração
cap = new AppSettingsReader();
//Cria instância para container TODO:: cap.GetValue("BasePath", typeof(String)).ToString()
container = Db4oEmbedded.OpenFile(config, Config.BancoDadosURL);
}
}
public static void AssertDataClassKnown(string databaseFileName, IEmbeddedConfiguration
config, bool expected)
{
IObjectContainer db = Db4oEmbedded.OpenFile(config, databaseFileName);
try
{
var storedClass = db.Ext().StoredClass(typeof(Data
));
if (expected)
{
Assert.IsNotNull(storedClass);
}
else
{
Assert.IsNull(storedClass);
}
}
finally
{
db.Close();
}
}
public void SetIndex(ArrayList fieldnames, string className, ArrayList Indexed, string path, bool customConfig)
{
IObjectContainer con = null;
try
{
IEmbeddedConfiguration embeddedConfig = !customConfig?Db4oEmbedded.NewConfiguration() : Config();
for (int i = 0; i < fieldnames.Count; i++)
{
embeddedConfig.Common.ObjectClass(className).ObjectField(fieldnames[i].ToString()).Indexed(
Convert.ToBoolean(Indexed[i]));
}
con = Db4oEmbedded.OpenFile(embeddedConfig, path);
IReflectClass clazz = con.Ext().Reflector().ForName(className);
con.QueryByExample(clazz);
}
finally
{
con.Close();
}
}
public static void SaveStandards(List <BoolStringClass> standards)
{
string path = Directory.GetCurrentDirectory() + "\\database.srph";
//IObjectContainer db;
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.ObjectClass(typeof(BoolStringClass)).CascadeOnUpdate(true);
config.Common.ObjectClass(typeof(BoolStringClass)).CascadeOnDelete(true);
config.Common.ObjectClass(typeof(BoolStringClass)).CascadeOnActivate(true);
//db = Db4oEmbedded.OpenFile(config, path);
using (IObjectContainer db = Db4oEmbedded.OpenFile(config, path))
{
foreach (var item in standards)
{
var standard = new BoolStringClass(item.StandardName, item.StandardPrice, item.IsPermamentOrIsNotPermament);
db.Store(standard);
db.Commit();
db.Close();
}
}
}
public static void UpdateCollection()
{
IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
config.Common.ObjectClass(typeof(Car)).CascadeOnUpdate(true);
using (IObjectContainer db = Db4oEmbedded.OpenFile(config, YapFileName))
{
IQuery query = db.Query();
query.Constrain(typeof(Car));
var result = query.Descend("_history").Execute();
IList history = (IList)result.Next();
history.RemoveAt(0);
db.Store(history);
Car proto = new Car(null, null);
var result2 = db.QueryByExample(proto);
foreach (Car car in result2)
{
foreach (object readout in car.History)
{
Console.WriteLine(readout);
}
}
}
}
public virtual void Test()
{
MemoryStorage origStorage = new MemoryStorage();
IEmbeddedConfiguration origConfig = Config(origStorage);
IObjectContainer origDb = Db4oEmbedded.OpenFile(origConfig, BinUri);
origDb.Store(new MemoryBinIsReusableTestCase.Item(ItemName));
origDb.Close();
MemoryBin origBin = origStorage.Bin(BinUri);
byte[] data = origBin.Data();
Assert.AreEqual(data.Length, origBin.Length());
MemoryBin newBin = new MemoryBin(data, new DoublingGrowthStrategy());
MemoryStorage newStorage = new MemoryStorage();
newStorage.Bin(BinUri, newBin);
IObjectContainer newDb = Db4oEmbedded.OpenFile(Config(newStorage), BinUri);
IObjectSet result = newDb.Query(typeof(MemoryBinIsReusableTestCase.Item));
Assert.AreEqual(1, result.Count);
Assert.AreEqual(ItemName, ((MemoryBinIsReusableTestCase.Item)result.Next())._name
);
newDb.Close();
}
private static void UniqueViolation()
{
IEmbeddedConfiguration configuration = Db4oEmbedded.NewConfiguration();
configuration.Common.ObjectClass(typeof(UniqueId)).ObjectField("id").Indexed(true);
configuration.Common.Add(new UniqueFieldValueConstraint(typeof(UniqueId), "id"));
using (IObjectContainer container = Db4oEmbedded.OpenFile(configuration, "database.db4o"))
{
// #example: Violation of the unique constraint
container.Store(new UniqueId(42));
container.Store(new UniqueId(42));
try
{
container.Commit();
}
catch (UniqueFieldValueConstraintViolationException e)
{
// Violated the unique-constraint!
// Retry with a new value or handle this gracefully
container.Rollback();
}
// #end example
}
}
private IConfiguration LegacyConfigFor(IEmbeddedConfiguration configuration)
{
EmbeddedConfigurationImpl configImpl = (EmbeddedConfigurationImpl)configuration;
return(configImpl.Legacy());
}
/// <summary>
/// opens an
/// <see cref="Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
/// on the specified database file for local use.
/// <br/>
/// <br/>
/// A database file can only be opened once, subsequent attempts to
/// open another
/// <see cref="Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
/// against the same file will result in a
/// <see cref="Db4objects.Db4o.Ext.DatabaseFileLockedException"> DatabaseFileLockedException</see>
/// .
/// <br/>
/// <br/>
/// Database files can only be accessed for readwrite access from one
/// process at one time. All versions except for db4o mobile edition
/// use an internal mechanism to lock the database file for other
/// processes.
/// <br/>
/// <br/>
/// </summary>
/// <param name="config">
/// a custom
/// <see cref="Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
/// instance to be obtained via
/// <see cref="newConfiguration">newConfiguration</see>
/// </param>
/// <param name="databaseFileName">an absolute or relative path to the database
/// file</param>
/// <returns>
/// an open
/// <see cref="Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
/// </returns>
/// <seealso cref="Db4objects.Db4o.Config.IConfiguration.ReadOnly">
/// Db4objects.Db4o.Config.IConfiguration.ReadOnly</seealso>
/// <seealso cref="Db4objects.Db4o.Config.IConfiguration.Encrypt"> Db4objects.Db4o.Config.IConfiguration.Encrypt
/// </seealso>
/// <seealso cref="Db4objects.Db4o.Config.IConfiguration.Password">
/// Db4objects.Db4o.Config.IConfiguration.Password</seealso>
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"> I/O operation failed or was unexpectedly
/// interrupted.</exception>
/// <exception cref="Db4objects.Db4o.Ext.DatabaseFileLockedException"> the required database file is locked by
/// another process.</exception>
/// <exception cref="Db4objects.Db4o.Ext.IncompatibleFileFormatException">
/// runtime
/// <see cref="Db4objects.Db4o.Config.IConfiguration">configuration</see>
/// is not compatible with the configuration of the database file.
/// </exception>
/// <exception cref="Db4objects.Db4o.Ext.OldFormatException">
/// open operation failed because the database file is in old format
/// and
/// <see cref="Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates">
/// Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates</see>
/// is set to false.
/// </exception>
/// <exception cref="Db4objects.Db4o.Ext.DatabaseReadOnlyException"> database was configured as read-only.
/// </exception>
public static IEmbeddedObjectContainer OpenFile(IEmbeddedConfiguration config, string
databaseFileName)
{
if (null == config)
{
throw new ArgumentNullException();
}
return ObjectContainerFactory.OpenObjectContainer(config, databaseFileName);
}
public void Configure(IEmbeddedConfiguration configuration)
{
ConfigureReflector(configuration, info.DyanmicTypesRepresentation);
}
public void Prepare(IEmbeddedConfiguration configuration)
{
configuration.File.Storage = new IsolatedStorageStorage();
}
private IConfiguration LegacyConfigFor(IEmbeddedConfiguration configuration)
{
var configImpl = (EmbeddedConfigurationImpl) configuration;
return configImpl.Legacy();
}
private IEmbeddedObjectContainer OpenContainer(IEmbeddedConfiguration config)
{
if (config == null)
{
config = NewConfiguration();
}
config.Common.ReflectWith(Platform4.ReflectorForType(typeof(CommitTimestampDefragmentTestCase.Item
)));
return config == null ? Db4oEmbedded.OpenFile(SourceFile()) : Db4oEmbedded.OpenFile
(config, SourceFile());
}
public virtual void Prepare(IEmbeddedConfiguration configuration)
{
_prepareCount++;
}
public void Prepare(IEmbeddedConfiguration configuration)
{
_config = configuration;
_prepareCount++;
}
public static void AssertDataClassKnown(string databaseFileName, IEmbeddedConfiguration
config, bool expected)
{
IObjectContainer db = Db4oEmbedded.OpenFile(config, databaseFileName);
try
{
var storedClass = db.Ext().StoredClass(typeof (Data
));
if (expected)
{
Assert.IsNotNull(storedClass);
}
else
{
Assert.IsNull(storedClass);
}
}
finally
{
db.Close();
}
}
public _ICodeBlock_14(IEmbeddedConfiguration embeddedConfiguration)
{
this.embeddedConfiguration = embeddedConfiguration;
}
/// <param name="config">
/// The db4o
/// <see cref="Db4objects.Db4o.Config.IEmbeddedConfiguration">IEmbeddedConfiguration</see>
/// to be applied
/// during the defragment process.
/// </param>
/// <since>7.9</since>
public virtual void Db4oConfig(IEmbeddedConfiguration config)
{
_config = ((EmbeddedConfigurationImpl)config).Legacy();
}
