public static IEnumerable<ITypeDescription> Read(IObjectContainer database, TypeResolver typeResolver) { new {database, typeResolver}.CheckNotNull(); var reader = new MetaDataReader(typeResolver, ExtractStoredClasses(database.Ext().StoredClasses())); return reader.CreateTypes(database.Ext()).ToList(); }
public ObjectDetails(long id) { this.id = id; objectContainer = Db4oClient.Client; m_genObject = objectContainer.Ext().GetByID(id); objectContainer.Ext().Activate(m_genObject, 1); }
private static void TraverseIndex(IObjectContainer container) { // #example: Traverse index IStoredField storedField = container.Ext() .StoredClass(typeof (Item)).StoredField("data", typeof (int)); storedField.TraverseValues(new IndexVisitor()); // #end example }
private void IndexDatabase(IndexWriter writer, IObjectContainer container) { IEnumerable<Versiculo> versiculos = container.Query<Versiculo>(); foreach(Versiculo versiculo in versiculos){ Document doc = CreateVersiculoDoc(container.Ext().GetID(versiculo), versiculo); writer.AddDocument(doc); } }
public static void ListRefreshedResult(IObjectContainer container, IObjectSet items, int depth) { Console.WriteLine(items.Count); foreach (object item in items) { container.Ext().Refresh(item, depth); Console.WriteLine(item); } }
private static void Refresh(IObjectContainer db, IList<Person> allPersons) { foreach (Person objToRefresh in allPersons) { // #example: refresh a object db.Ext().Refresh(objToRefresh, int.MaxValue); // #end example } }
// #example: An object container for this unit of work private void ListAllPeople(IObjectContainer rootContainer) { using (IObjectContainer container = rootContainer.Ext().OpenSession()) { foreach (Person person in from Person p in container select p) { Console.WriteLine(person.Name); } } }
public void RunWith(IObjectContainer db) { IStoredClass storedClass = db.Ext().StoredClass(targetClazz); IStoredField storedField = storedClass.StoredField(fieldName, fieldType); IObjectSet result = db.Query(targetClazz); Assert.AreEqual(1, result.Count); object obj = result.Next(); object value = (object)storedField.Get(obj); Assert.AreEqual(fieldValue, value); }
public static void CarSnapshotRollbackRefresh(IObjectContainer db) { IObjectSet result=db.QueryByExample(new Car("BMW")); Car car=(Car)result.Next(); car.Snapshot(); db.Store(car); db.Rollback(); db.Ext().Refresh(car, int.MaxValue); Console.WriteLine(car); }
// #end example: private void StoreInitialObjects(IObjectContainer rootContainer) { using (IObjectContainer container = rootContainer.Ext().OpenSession()) { container.Store(new Person("Joe")); container.Store(new Person("Jan")); container.Store(new Person("Joanna")); container.Store(new Person("Phil")); } }
public Db4oEmbeddedReplicationProvider(IObjectContainer objectContainer, string name ) { // TODO: Add additional query methods (whereModified ) IConfiguration cfg = objectContainer.Ext().Configure(); cfg.Callbacks(false); _name = name; _container = (ExternalObjectContainer)objectContainer; _reflector = _container.Reflector(); _signatureMap = new Db4oSignatureMap(_container); _activationStrategy = CreateActivationStrategy(); }
private static void RefreshAfterRollback(IObjectContainer container) { // #example: Refresh objects after rollback Pilot pilot = container.Query<Pilot>()[0]; pilot.Name = "New Name"; container.Store(pilot); container.Rollback(); // use refresh to return the in memory objects back // to the state in the database. container.Ext().Refresh(pilot, int.MaxValue); // #end example }
// #end example // #example: An object container for the background task private void UpdateSomePeople(IObjectContainer rootContainer) { using (IObjectContainer container = rootContainer.Ext().OpenSession()) { var people = from Person p in container where p.Name.Equals("Joe") select p; foreach (Person joe in people) { joe.Name = "New Joe"; container.Store(joe); } } }
private void AssertChangesHaveBeenStored(IObjectContainer container) { var session = container.Ext().OpenSession(); try { var item = ((NamedItem ) session.Query(typeof (NamedItem))[0]); Assert.AreEqual("New Name", item.GetName()); } finally { session.Close(); } }
private void AssertChangesHaveBeenStored(IObjectContainer container) { IObjectContainer session = container.Ext().OpenSession(); try { CommitTimeStampsWithTPTestCase.NamedItem item = ((CommitTimeStampsWithTPTestCase.NamedItem )session.Query(typeof(CommitTimeStampsWithTPTestCase.NamedItem))[0]); Assert.AreEqual("New Name", item.GetName()); } finally { session.Close(); } }
private void ScanThroughKnownClassesInfo(IObjectContainer db) { IReflectClass[] clazzArray = db.Ext().KnownClasses(); for (int clazzIndex = 0; clazzIndex < clazzArray.Length; ++clazzIndex) { IReflectClass clazz = clazzArray[clazzIndex]; IReflectField[] fieldArray = clazz.GetDeclaredFields(); for (int fieldIndex = 0; fieldIndex < fieldArray.Length; ++fieldIndex) { IReflectField field = fieldArray[fieldIndex]; field.GetName(); field.GetFieldType(); } } }
private static void RegisterObjectIdUpdaterEvent(IObjectContainer db, ObjectEventHandler activationTracker) { IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(db); eventRegistry.Activated += activationTracker; activationCount = 0; eventRegistry.Instantiated += delegate(object sender, ObjectEventArgs args) { SupportObjectId obj = args.Object as SupportObjectId; if (obj != null) { obj.ObjectId = db.Ext().GetID(obj); } }; }
private void RenderCollection(TreeGridNode rootNode, object currObj, IReflectField field) { container = Db4oClient.Client; object value = field.Get(currObj); if (value != null) { container.Ext().Activate(value, 2); ICollection coll = (ICollection)value; CreateCollectionNode(field, value, ref rootNode, coll.Count.ToString()); } else { CreateCollectionNode(field, value, ref rootNode, "0"); } }
public ActionResult FlushDb() { foreach (var o in _db.Ext().StoredClasses()) { try { var type = typeof(Instructor).Assembly.GetType(o.GetName()); foreach (var thing in _db.Query(type)) { _db.Delete(thing); } } catch (Exception) { } } return(Content("DONE")); }
public static bool IsCollection(object expandedObj) { try { if (expandedObj != null) { IObjectContainer objectContainer = Db4oClient.Client; IReflectClass refClass = objectContainer.Ext().Reflector().ForObject(expandedObj); return(refClass.IsCollection()); } return(false); } catch (Exception oEx) { LoggingHelper.HandleException(oEx); return(false); } }
/// <summary> /// Counts all entities in the attached data store, or if it's null then all entities from all all stores. /// </summary> /// <returns>The total number of entities counted.</returns> public override int CountEntities() { int total = 0; List <IDataStore> stores = new List <IDataStore>(); // Count the list of stores // If the DataStore property is null then get all stores. if (DataStore == null) { foreach (string dataStoreName in DataAccess.Data.GetDataStoreNames()) { stores.Add(Provider.Stores[dataStoreName]); } } // Otherwise use the single store attached to this adapter else { stores.Add(DataStore); } // Load data from the stores foreach (IDataStore store in stores) { if (!store.IsClosed) { IObjectContainer container = ((Db4oDataStore)store).ObjectContainer; if (!container.Ext().IsClosed()) { IQuery query = container.Query(); query.Constrain(typeof(IEntity)); IObjectSet os = query.Execute(); total = os.Count; } } } return(total); }
public static void SaveCollections(long id, int level) { try { IObjectContainer objectContainer = Db4oClient.Client; if (id == 0) { return; } object topObject = objectContainer.Ext().GetByID(id); Db4oClient.Client.Ext().Activate(topObject, level); Db4oClient.Client.Ext().Store(topObject, level); Db4oClient.Client.Commit(); } catch (Exception oEx) { Db4oClient.Client.Rollback(); LoggingHelper.HandleException(oEx); } }
public void TraverseObjTree(ref TreeGridNode rootNode, object currObj, string classname) { container = Db4oClient.Client; IReflectClass refClass = DataLayerCommon.ReflectClassForName(classname); if (refClass == null) { return; } string type1 = refClass.ToString(); if (!String.IsNullOrEmpty(type1)) { try { IType type = Db4oClient.TypeResolver.Resolve(refClass); if (type.IsPrimitive) { TreeGridNode node = new TreeGridNode(); rootNode.Nodes.Add(node); node.Cells[0].Value = ClassNameFor(container.Ext().Reflector().ForObject(currObj).GetName()); node.Cells[1].Value = currObj.ToString(); node.Cells[1].ReadOnly = checkReadonlyStatus(); SetFieldType(node, type); node.Tag = currObj; node.ImageIndex = 2; return; } IReflectField[] fieldArr = DataLayerCommon.GetDeclaredFieldsInHeirarchy(refClass); rootNode = TraverseFields(rootNode, currObj, fieldArr); } catch (Exception oEx) { LoggingHelper.HandleException(oEx); } } }
public long GetFreeSizeofDatabase() { IObjectContainer objectContainer = Db4oClient.Client; long freeSizeOfDB; try { freeSizeOfDB = objectContainer.Ext().SystemInfo().FreespaceSize(); } catch (NotImplementedException) { freeSizeOfDB = -1; } catch (Exception oEx) { freeSizeOfDB = -1; LoggingHelper.HandleException(oEx); } return(freeSizeOfDB); }
public void AddProxyInfoToDb(ProxyAuthentication proxyAuthObj) { if (Db4oClient.RecentConnFile == null) { Db4oClient.RecentConnFile = Config.OMNConfigDatabasePath(); } _proxyAuthObj = proxyAuthObj; _container = Db4oClient.RecentConn; ProxyAuthenticator proxyobj = ReturnProxyAuthenticationInfo(); if (proxyobj == null) { _container.Store(this); } else { proxyobj._proxyAuthObj = proxyAuthObj; _container.Store(proxyobj); } _container.Commit(); _container.Ext().Refresh(proxyobj, 1); }
private void AssertItemStoredField(object expectedValue) { IObjectContainer db = OpenContainer(); try { IObjectSet objectSet = db.Query(typeof(FieldsToTypeHandlerMigrationTestCase.Item) ); Assert.AreEqual(1, objectSet.Count); FieldsToTypeHandlerMigrationTestCase.Item item = (FieldsToTypeHandlerMigrationTestCase.Item )objectSet.Next(); IStoredField storedField = db.Ext().StoredClass(typeof(FieldsToTypeHandlerMigrationTestCase.Item )).StoredField("_id", null); object actualValue = storedField.Get(item); Assert.AreEqual(expectedValue, actualValue); } finally { db.Close(); } }
protected void Add_Document_for_User_Click(object sender, EventArgs e) { int count; string docname; float versionOfDoc; System.Web.HttpContext context = System.Web.HttpContext.Current; string docname_versionOfDoc = (String)context.Session["docNameVersionNo"]; List <String> compare = new List <string>(); compare = docname_versionOfDoc.Split(':').ToList(); docname = compare[0]; versionOfDoc = float.Parse(compare[1]); string username = (string)Session["UserName"]; try { Config path = new Config(); DB = Db4oFactory.OpenFile(path.addressOfDocument); IObjectSet result = DB.QueryByExample(new Document_model(docname, versionOfDoc)); Document_model docmodel = (Document_model)result.Next(); count = docmodel.Count_document_reviever - 1; docmodel.Count_document_reviever = count; docmodel.List_reviever.Remove(username); if (docmodel.Count_document_reviever == 0) { docmodel.DocumentStatus = "Complete"; } DB.Ext().Store(docmodel, 3); DB.Close(); Page.RegisterStartupScript("Alert&Redirect", "<script>alert('Review Successfull!!'); location.href='./Document_page.aspx';</script>"); } catch { } }
private void btnOpenDb4o_Click(object sender, RoutedEventArgs e) { OpenFileDialog dlg = new OpenFileDialog(); dlg.DefaultExt = ".yap"; dlg.Filter = "db4o file (*.yap)|*.yap"; dlg.InitialDirectory = AppDomain.CurrentDomain.BaseDirectory; if ((bool)dlg.ShowDialog()) { if (db != null) { db.Close(); } originFile = dlg.FileName; tbFilePath.Text = originFile; db = Db4oFactory.OpenFile(originFile); var ext = db.Ext(); PopulateCombos(db); } }
/// <summary> /// Search and return a project in the database. Returns null if the /// project is not found /// </summary> /// <param name="filename"> /// A <see cref="System.String"/> with the project's video file name /// </param> /// <returns> /// A <see cref="LongoMatch.DB.Project"/> /// </returns> public Project GetProject(Guid id) { Project ret = null; IObjectContainer db = Db4oFactory.OpenFile(DBFile); Log.Debug("Getting project with ID: " + id); try { IQuery query = GetQueryProjectById(db, id); IObjectSet result = query.Execute(); ret = (Project)db.Ext().PeekPersisted(result.Next(), 10, true); } catch (Exception e) { Log.Error("Could not get project with ID: " + id); Log.Exception(e); } finally { CloseDB(db); } if (ret != null && FixProjectCoordinates(ret)) { UpdateProject(ret); } return(ret); }
private void comboType_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e) { if (comboType.SelectedIndex < 0) { return; } comboIds.Items.Clear(); objList.Clear(); IStoredClass c = clzList[comboType.SelectedIndex]; var ids = c.GetIDs(); foreach (var id in ids) { var o = db.Ext().GetByID(id); objList.Add(o); comboIds.Items.Add(string.Format("{0} - {1}", id, o)); } Msg(string.Format("{0} objects for class [{1}] are listed.\n", ids.Length, c.GetName())); }
internal void RenameFolderInDatabase(FavouriteFolder oldFavFolder, FavouriteFolder newFavFolder) { try { container = Db4oClient.RecentConn; FavouriteList favList = FetchAllFavouritesForAConnection(); List <FavouriteFolder> lstFavFolder = favList.lstFavFolder; bool check = false; FavouriteFolder temp = null; foreach (FavouriteFolder str in lstFavFolder) { if (str != null) { if (str.FolderName.Equals(oldFavFolder.FolderName)) { temp = str; check = true; break; } } } if (check == true) { lstFavFolder.Remove(temp); container.Delete(temp); temp.FolderName = newFavFolder.FolderName; lstFavFolder.Add(temp); favList.lstFavFolder = lstFavFolder; container.Ext().Store(favList, 5); container.Commit(); } } catch (Exception oEx) { LoggingHelper.HandleException(oEx); } }
public override bool RunJob() { bool bError = false; try { if (servidor.IsRunning()) { IObjectContainer dbcliente = Db4oFactory.OpenClient(this.sServer, Convert.ToInt32(this.sPort), this.sUsuario, this.sPassword); dbcliente.Ext().Backup(sBackupFile); dbcliente.Close(); } } catch (Exception ex) { bError = true; Log.AddToLog(sJobName, ex.Message); } return(bError); }
private void AssertHasIndexInfo(IObjectContainer db) { IStoredClass[] scArray = db.Ext().StoredClasses(); for (int scIndex = 0; scIndex < scArray.Length; ++scIndex) { IStoredClass sc = scArray[scIndex]; if (!sc.GetName().Equals(typeof(KnownClassesIndexTestCase.WithIndex).FullName)) { continue; } IStoredField[] sfArray = sc.GetStoredFields(); for (int sfIndex = 0; sfIndex < sfArray.Length; ++sfIndex) { IStoredField sf = sfArray[sfIndex]; if (sf.HasIndex()) { return; } } Assert.Fail("no index found"); } }
public static void DeleteObject(long id) { IObjectContainer objectContainer = Db4oClient.Client; try { if (id == 0) { return; } object obj = objectContainer.Ext().GetByID(id); Db4oClient.Client.Delete(obj); Db4oClient.Client.Ext().Purge(); Db4oClient.Client.Commit(); ObjectCache.RemoveObject(id); } catch (Exception oEx) { objectContainer.Rollback(); LoggingHelper.HandleException(oEx); } }
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(); } }
static public List <Disponibilidad> Buscar(Disponibilidad DisponibilidadBuscar) { using (IObjectContainer db = Connect.getDataBase()) { long id = DisponibilidadBuscar.Id; List <Disponibilidad> lRes = new List <Disponibilidad>(); try { DisponibilidadBuscar.dbId = DisponibilidadBuscar.Id; //db.Ext().Bind(DisponibilidadBuscar, id); Connect.setdbId(db, DisponibilidadBuscar); object o2 = db.Ext().GetByID(id); DisponibilidadBuscar = (Disponibilidad)o2; /*DisponibilidadBuscar.dbId = DisponibilidadBuscar.Id; * if (DisponibilidadBuscar.Id>0) * { * DisponibilidadBuscar.dbId = null; * }*/ IObjectSet result = db.QueryByExample(DisponibilidadBuscar); while (result.HasNext()) { Disponibilidad o = (Disponibilidad)result.Next(); Connect.getdbId(db, (object)o); lRes.Add(o); } return(lRes); } finally { db.Close(); } } return(null); }
/// <summary> /// Counts all entities of the specified type from the corresponding data store. /// </summary> /// <param name="type">The type of entity to retrieve.</param> /// <returns>The total number of entities counted.</returns> public override int CountEntities(Type type) { int total = 0; using (LogGroup logGroup = LogGroup.StartDebug("Counting entities of the specified type.")) { IObjectContainer objectContainer = ((Db4oDataStore)GetDataStore(type)).ObjectContainer; // If the object container is closed then skip the query if (objectContainer != null && !objectContainer.Ext().IsClosed()) { IQuery query = objectContainer.Query(); query.Constrain(type); IObjectSet os = query.Execute(); total = os.Count; LogWriter.Debug("Total: " + total.ToString()); } } return(total); }
public void deleteRecentQueriesForAConnection() { List <OMQuery> qList = new List <OMQuery>(); IObjectSet objSet = null; try { container = Db4oClient.RecentConn; IQuery query = container.Query(); query.Constrain(typeof(RecentQueries)); query.Descend("m_connParam").Descend("m_connection").Constrain(m_connParam.Connection); objSet = query.Execute(); if (objSet != null) { RecentQueries recQueries = (RecentQueries)objSet.Next(); for (int i = 0; i < recQueries.QueryList.Count; i++) { OMQuery q = recQueries.m_queryList[0]; if (q != null) { // m_queryList.Remove(q); container.Delete(q); } } recQueries.m_queryList.Clear(); recQueries.m_TimeOfCreation = Sharpen.Runtime.CurrentTimeMillis(); container.Ext().Store(recQueries, 5); container.Commit(); } } catch (Exception oEx) { LoggingHelper.HandleException(oEx); } }
private static void ReferenceCacheExample() { using (IObjectContainer client1 = Db4oClientServer.OpenClient("localhost", 1337, "sa", "sa"), client2 = Db4oClientServer.OpenClient("localhost", 1337, "sa", "sa")) { // #example: Reference cache in client server Person personOnClient1 = QueryForPerson(client1); Person personOnClient2 = QueryForPerson(client2); Console.Write(QueryForPerson(client2).Name); personOnClient1.Name = ("New Name"); client1.Store(personOnClient1); client1.Commit(); // The other client still has the old data in the cache Console.Write(QueryForPerson(client2).Name); client2.Ext().Refresh(personOnClient2, int.MaxValue); // After refreshing the date is visible Console.Write(QueryForPerson(client2).Name); // #end example } }
protected virtual void SetMessageRecipient(IObjectContainer container, IMessageRecipient recipient) { SetMessageRecipient(container.Ext().Configure(), recipient); }
protected virtual IMessageSender MessageSender(IObjectContainer client) { return(client.Ext().Configure().ClientServer().GetMessageSender()); }
public List <UsuarioModel> ListarUsuarios() { List <UsuarioModel> lista = new List <UsuarioModel>(); foreach (var a in db.Query <Usuario>()) { lista.Add(new UsuarioModel() { Id = db.Ext().GetID(a), Nombre = a.Nombre }); } return(lista); }
private void RenderArray(TreeGridNode rootNode, object currObj, IReflectField field) { container = Db4oClient.Client; object obj = field.Get(currObj); if (obj != null) { container.Ext().Activate(obj, 2); int length = container.Ext().Reflector().Array().GetLength(obj); CreateCollectionNode(field, obj, ref rootNode, length.ToString()); } else { CreateCollectionNode(field, obj, ref rootNode, "0"); } }
internal void RenameFolderInDatabase(FavouriteFolder oldFavFolder, FavouriteFolder newFavFolder) { try { container = Db4oClient.RecentConn; FavouriteList favList = FetchAllFavouritesForAConnection(); List<FavouriteFolder> lstFavFolder = favList.lstFavFolder; bool check = false; FavouriteFolder temp = null; foreach (FavouriteFolder str in lstFavFolder) { if (str != null) { if (str.FolderName.Equals(oldFavFolder.FolderName)) { temp = str; check = true; break; } } } if (check == true) { lstFavFolder.Remove(temp); container.Delete(temp); temp.FolderName = newFavFolder.FolderName; lstFavFolder.Add(temp); favList.lstFavFolder = lstFavFolder; container.Ext().Store(favList, 5); container.Commit(); } } catch (Exception oEx) { LoggingHelper.HandleException(oEx); } }
private bool OnlyNeedUpdate(IObjectContainer container) { return(container.Ext().IsStored(state)); }
private static void StoreEntry(IObjectContainer rootContainer) { using (var container = rootContainer.Ext().OpenSession()) { var toTest = new WithAutoIDs(); container.Store(toTest); } }
protected virtual IMessageSender MessageSender(IObjectContainer client) { return client.Ext().Configure().ClientServer().GetMessageSender(); }
private void PrintStats(IObjectContainer con, string filename) { Tree unavailable = new TreeString(Remove); Tree noConstructor = new TreeString(Remove); // one element too many, substract one in the end IStoredClass[] internalClasses = con.Ext().StoredClasses(); for (int i = 0; i < internalClasses.Length; i++) { string internalClassName = internalClasses[i].GetName(); Type clazz = ReflectPlatform.ForName(internalClassName); if (clazz == null) { unavailable = unavailable.Add(new TreeString(internalClassName)); } else { if (!CanCallConstructor(internalClassName)) { noConstructor = noConstructor.Add(new TreeString(internalClassName)); } } } unavailable = unavailable.RemoveLike(new TreeString(Remove)); noConstructor = noConstructor.RemoveLike(new TreeString(Remove)); if (unavailable != null) { PrintHeader("UNAVAILABLE"); unavailable.Traverse(new _IVisitor4_80()); } if (noConstructor != null) { PrintHeader("NO PUBLIC CONSTRUCTOR"); noConstructor.Traverse(new _IVisitor4_88()); } PrintHeader("CLASSES"); Sharpen.Runtime.Out.WriteLine("Number of objects per class:"); ByRef ids = ByRef.NewInstance(new TreeInt(0)); if (internalClasses.Length > 0) { Tree all = new TreeStringObject(internalClasses[0].GetName(), internalClasses[0]); for (int i = 1; i < internalClasses.Length; i++) { all = all.Add(new TreeStringObject(internalClasses[i].GetName(), internalClasses[ i])); } all.Traverse(new _IVisitor4_107(ids)); } PrintHeader("SUMMARY"); Sharpen.Runtime.Out.WriteLine("File: " + filename); Sharpen.Runtime.Out.WriteLine("Stored classes: " + internalClasses.Length); if (unavailable != null) { Sharpen.Runtime.Out.WriteLine("Unavailable classes: " + unavailable.Size()); } if (noConstructor != null) { Sharpen.Runtime.Out.WriteLine("Classes without public constructors: " + noConstructor .Size()); } Sharpen.Runtime.Out.WriteLine("Total number of objects: " + (((Tree)ids.value).Size () - 1)); }
private void CloseDB(IObjectContainer db) { db.Ext().Purge(); db.Close(); }
/// <summary>deactivates each object.</summary> /// <remarks>deactivates each object.</remarks> public virtual void Rollback(IObjectContainer container, object obj) { container.Ext().Deactivate(obj); }
public IExtObjectContainer Ext() { return(session.Ext()); }
private void PopulateCombos(IObjectContainer db) { comboType.Items.Clear(); clzList.Clear(); var clzs = db.Ext().StoredClasses(); foreach (var c in clzs) { //if (c.GetName().StartsWith("Unionless")) { comboType.Items.Add(c.GetName() + " - " + c.GetIDs().Length); clzList.Add(c); } } Msg(string.Format("{0} classes are listed.\n", clzs.Length)); }
internal void AddFolderToDatabase(FavouriteFolder favFolder) { try { container = Db4oClient.RecentConn; if (m_lstFavfolder != null) { FavouriteList favList = FetchAllFavouritesForAConnection(); if (favList == null) { favList = new FavouriteList(m_connParam); List<FavouriteFolder> lstFavfolder = new List<FavouriteFolder>(); favList.m_TimeOfCreation = Sharpen.Runtime.CurrentTimeMillis(); lstFavfolder.Add(favFolder); container.Store(favList); container.Commit(); return; } container.Activate(favList, 5); List<FavouriteFolder> lstFavFolder = favList.lstFavFolder; bool check = false; FavouriteFolder temp = null; foreach (FavouriteFolder str in lstFavFolder) { if (str != null) { if (str.FolderName.Equals(favFolder.FolderName)) { temp = str; check = true; break; } } } if (check == false) { lstFavFolder.Add(favFolder); } else { lstFavFolder.Remove(temp); lstFavFolder.Add(favFolder); container.Delete(temp); } favList.lstFavFolder = lstFavFolder; container.Ext().Store(favList, 5); container.Commit(); } } catch (Exception oEx) { LoggingHelper.HandleException(oEx); } }
public List <Hashtable> ObjectIDToUIObjects(PagingData pgdata, Hashtable attribList) { try { Hashtable hashFieldValue; object rowObj = null; if (pgdata.ObjectId.Count < pgdata.EndIndex) { pgdata.EndIndex = pgdata.ObjectId.Count; } if (attribList.Count == 0) { IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_classname); if (rClass != null) { IReflectField[] reff = DataLayerCommon.GetDeclaredFieldsInHeirarchy(rClass); if (reff == null) { return(m_lstRowContent); } for (int i = pgdata.StartIndex; i < pgdata.EndIndex; i++) { if (pgdata.ObjectId[i] == 0) { continue; } rowObj = objectContainer.Ext().GetByID(pgdata.ObjectId[i]); if (rowObj != null) { if (m_refresh) { objectContainer.Ext().Refresh(rowObj, 1); } else { objectContainer.Ext().Activate(rowObj, 1); } } if (rowObj != null) { hashFieldValue = checkforprimitives(reff, rowObj, pgdata.ObjectId[i]); m_lstRowContent.Add(hashFieldValue); } } } } else { int length = GetDepth(attribList); for (int i = pgdata.StartIndex; i < pgdata.EndIndex; i++) { hashFieldValue = new Hashtable(); m_hashRowContent = new Hashtable(); foreach (string attribute in attribList.Keys) { if (pgdata.ObjectId[i] == 0) { continue; } rowObj = objectContainer.Ext().GetByID(pgdata.ObjectId[i]); if (rowObj != null) { if (m_refresh) { objectContainer.Ext().Refresh(rowObj, length); } else { objectContainer.Ext().Activate(rowObj, length); } hashFieldValue = UpdateResults(rowObj, attribute); } } if (hashFieldValue.Count != 0) { if (!hashFieldValue.ContainsKey(BusinessConstants.DB4OBJECTS_REF)) { hashFieldValue.Add(BusinessConstants.DB4OBJECTS_REF, pgdata.ObjectId[i]); } m_lstRowContent.Add(hashFieldValue); } } } return(m_lstRowContent); } catch (Exception oEx) { //LoggingHelper.HandleException(oEx); LoggingHelper.ShowMessage(oEx, "Maybe Can't find 'enum' Type. "); return(new List <Hashtable>( )); } }
private void ConvertToNew(IObjectContainer db1, string f2) { worker = new BackgroundWorker(); worker.WorkerReportsProgress = true; worker.WorkerSupportsCancellation = true; worker.ProgressChanged += Worker_ProgressChanged; worker.DoWork += (sender, e) => { IObjectContainer db2 = Db4oFactory.OpenFile(f2); var clist = db1.Ext().StoredClasses(); worker.ReportProgress(0, string.Format("{0} classes are listed.", clist.Length)); Assembly assembly = Assembly.LoadFile(assemblyFile); worker.ReportProgress(0, string.Format("Assembly [{0}] is loaded.", assemblyFile)); foreach (Type t in assembly.GetTypes()) { worker.ReportProgress(0, string.Format("++Type [{0}] is loaded.", t)); } foreach (IStoredClass c in clist) { // try to list objects. var ids = c.GetIDs(); worker.ReportProgress(0, string.Format("{0} objects for class [{1}] are listed.", ids.Length, c.GetName())); foreach (var id in ids) { var o = db1.Ext().GetByID(id); var o2 = PopulateFrom(id, o, c, assembly); if (o2 != null) { db2.Store(o2); } } } db2.Commit(); db2.Close(); }; worker.RunWorkerAsync(); }