public static IStoredField GetDeclaredStoredFieldInHeirarchy(IStoredClass aClass, string attribute) { try { IStoredField sField = null; if (aClass == null) { return(null); } while (aClass != null) { sField = aClass.StoredField(attribute, null); if (sField != null) { break; } aClass = aClass.GetParentStoredClass(); } return(sField); } catch (Exception e) { LoggingHelper.HandleException(e); } return(null); }
private static void ChangeType() { StoreInDB(new Person(), new Person("John")); // #example: copying the data from the old field type to the new one using (IObjectContainer container = Db4oEmbedded.OpenFile("database.db4o")) { // first get all objects which should be updated IList <Person> persons = container.Query <Person>(); foreach (Person person in persons) { // get the database-metadata about this object-type IStoredClass dbClass = container.Ext().StoredClass(person); // get the old field which was an int-type IStoredField oldField = dbClass.StoredField("id", typeof(int)); if (null != oldField) { // Access the old data and copy it to the new field! object oldValue = oldField.Get(person); if (null != oldValue) { person.id = new Identity((int)oldValue); container.Store(person); } } } } // #end example }
private void AssertIndexed(Type clazz, bool expected) { IStoredClass storedClass = FileSession().StoredClass(clazz); IStoredField storedField = storedClass.StoredField("_id", typeof(int)); Assert.AreEqual(expected, storedField.HasIndex()); }
private void AssertStoredType(IStoredClass clazz, string fieldName, Type type) { IStoredField field = clazz.StoredField(fieldName, null); Assert.AreEqual(type.FullName, CrossPlatformServices.SimpleName(field.GetStoredType ().GetName())); }
public virtual void Test() { for (int i = 0; i < ObjectCount; i++) { Store(new CommitAfterDroppedFieldIndexTestCase.Item(1)); } IStoredField storedField = FileSession().StoredClass(typeof(CommitAfterDroppedFieldIndexTestCase.Item )).StoredField("_id", null); storedField.CreateIndex(); FileSession().Commit(); IExtObjectContainer session = OpenNewSession(); IObjectSet allItems = session.Query(typeof(CommitAfterDroppedFieldIndexTestCase.Item )); for (IEnumerator itemIter = allItems.GetEnumerator(); itemIter.MoveNext();) { CommitAfterDroppedFieldIndexTestCase.Item item = ((CommitAfterDroppedFieldIndexTestCase.Item )itemIter.Current); item._id++; session.Store(item); } // Making sure all storing has been processed. session.SetSemaphore("anySemaphore", 0); storedField.DropIndex(); session.Commit(); storedField.CreateIndex(); }
public virtual void TestTraverseValues() { IStoredField field = StoredField(); ExpectingVisitor expectingVisitor = new ExpectingVisitor(IntArrays4.ToObjectArray (Foos)); field.TraverseValues(expectingVisitor); expectingVisitor.AssertExpectations(); }
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 }
public virtual void TestDropIndex() { IStoredField field = StoredField(); field.CreateIndex(); AssertQuery(); field.DropIndex(); Assert.IsFalse(field.HasIndex()); AssertQuery(); }
public virtual void TestCreateIndexAtRuntime() { IStoredField field = StoredField(); Assert.IsFalse(field.HasIndex()); field.CreateIndex(); Assert.IsTrue(field.HasIndex()); AssertQuery(); field.CreateIndex(); }
public virtual IStoredField[] GetStoredFields() { IStoredField[] fieldMetadata = _classMetadata.GetStoredFields(); IStoredField[] storedFields = new IStoredField[fieldMetadata.Length]; for (int i = 0; i < fieldMetadata.Length; i++) { storedFields[i] = new StoredFieldImpl(_transaction, (FieldMetadata)fieldMetadata[ i]); } return(storedFields); }
public virtual IStoredField[] GetStoredFields() { IStoredField[] fieldMetadata = _classMetadata.GetStoredFields(); IStoredField[] storedFields = new IStoredField[fieldMetadata.Length]; for (int i = 0; i < fieldMetadata.Length; i++) { storedFields[i] = new StoredFieldImpl(_transaction, (FieldMetadata)fieldMetadata[ i]); } return storedFields; }
public Db4oField(IStoredField storedField) { this.storedField = storedField; internalName = storedField.GetName(); name = AutomaticPropertyUtils.TryParseName(internalName); IsIndexed = storedField.HasIndex(); IReflectClass type = storedField.GetStoredType(); if(type!=null) DataType = type.ToString(); }
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 virtual void TestTraverseValues() { IStoredField field = StoredField(); StringFieldIndexTestCase.ExpectedVisitor visitor = new StringFieldIndexTestCase.ExpectedVisitor (2); field.TraverseValues(visitor); for (int i = 0; i < _fooValues.Length; i++) { Assert.AreEqual(_fooValues[i], visitor.GetValues()[i]); } }
public static void Main(string[] args) { using (IObjectContainer container = Db4oEmbedded.OpenFile("database.db4o")) { container.Store(new Person("Johnson", "Roman", 42)); container.Store(new Person("Miller", "John", 21)); // #example: All stored classes // Get the information about all stored classes. IStoredClass[] classesInDB = container.Ext().StoredClasses(); foreach (IStoredClass storedClass in classesInDB) { Console.WriteLine(storedClass.GetName()); } // Information for a certain class IStoredClass metaInfo = container.Ext().StoredClass(typeof(Person)); // #end example // #example: Accessing stored fields IStoredClass metaInfoForPerson = container.Ext().StoredClass(typeof(Person)); // Access all existing fields foreach (IStoredField field in metaInfoForPerson.GetStoredFields()) { Console.WriteLine("Field: " + field.GetName()); } // Accessing the field 'name' of any type. IStoredField nameField = metaInfoForPerson.StoredField("name", null); // Accessing the string field 'name'. Important if this field had another time in previous // versions of the class model IStoredField ageField = metaInfoForPerson.StoredField("age", typeof(int)); // Check if the field is indexed bool isAgeFieldIndexed = ageField.HasIndex(); // Get the type of the field string fieldType = ageField.GetStoredType().GetName(); // #end example // #example: Access via meta data IStoredClass metaForPerson = container.Ext().StoredClass(typeof(Person)); IStoredField metaNameField = metaForPerson.StoredField("name", null); IList <Person> persons = container.Query <Person>(); foreach (Person person in persons) { string name = (string)metaNameField.Get(person); Console.WriteLine("Name is " + name); } // #end example } }
private static void ReindexDateTimeField(IStoredField field) { IReflectClass claxx = field.GetStoredType(); if (claxx == null) { return; } Type t = NetReflector.ToNative(claxx); if (t == typeof(DateTime) || t == typeof(DateTime?)) { field.DropIndex(); field.CreateIndex(); } }
public virtual void TestGetStoredFields() { AssertStoredField(typeof(StoredClassTestCase.Item), FieldName, ItemName, typeof(string ), true, false); AssertStoredField(typeof(StoredClassTestCase.ItemParent), "_array", null, typeof( string), false, true); IStoredClass itemStoredClass = ItemStoredClass(); IStoredField storedField = itemStoredClass.StoredField(FieldName, null); IStoredField sameStoredField = itemStoredClass.GetStoredFields()[0]; IStoredField otherStoredField = StoredClass(typeof(StoredClassTestCase.ItemParent )).GetStoredFields()[0]; Assert.EqualsAndHashcode(storedField, sameStoredField, otherStoredField); Assert.IsNull(itemStoredClass.StoredField(string.Empty, null)); }
private static void ReindexDateTimeField(IStoredField field) { var claxx = field.GetStoredType(); if (claxx == null) { return; } var t = NetReflector.ToNative(claxx); if (t == typeof(T) || t == typeof(T?)) { field.DropIndex(); field.CreateIndex(); } }
public virtual void TestStoredFieldIsolation() { EmbeddedClientObjectContainerTestCase.Item storedItem = StoreItemToClient1AndCommit (); storedItem._name = ChangedName; _client1.Store(storedItem); EmbeddedClientObjectContainerTestCase.Item retrievedItem = RetrieveItemFromClient2 (); IStoredClass storedClass = _client2.StoredClass(typeof(EmbeddedClientObjectContainerTestCase.Item )); IStoredField storedField = storedClass.StoredField(FieldName, null); object retrievedName = storedField.Get(retrievedItem); Assert.AreEqual(OriginalName, retrievedName); _client1.Commit(); retrievedName = storedField.Get(retrievedItem); Assert.AreEqual(ChangedName, retrievedName); }
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(); } }
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"); } }
private void AssertStoredField(Type objectClass, string fieldName, object expectedFieldValue , Type expectedFieldType, bool hasIndex, bool isArray) { IStoredClass storedClass = StoredClass(objectClass); IStoredField[] storedFields = storedClass.GetStoredFields(); Assert.AreEqual(1, storedFields.Length); IStoredField storedField = storedFields[0]; Assert.AreEqual(fieldName, storedField.GetName()); IStoredField storedFieldByName = storedClass.StoredField(fieldName, expectedFieldType ); Assert.AreEqual(storedField, storedFieldByName); object item = RetrieveOnlyInstance(objectClass); Assert.AreEqual(expectedFieldValue, storedField.Get(item)); IReflectClass fieldType = storedField.GetStoredType(); Assert.AreEqual(Reflector().ForClass(expectedFieldType), fieldType); Assert.AreEqual(isArray, storedField.IsArray()); if (IsMultiSession()) { return; } Assert.AreEqual(hasIndex, storedField.HasIndex()); // FIXME: test rename if (!hasIndex) { Assert.Expect(typeof(Exception), new _ICodeBlock_113(storedField)); } else { IntByRef count = new IntByRef(); storedField.TraverseValues(new _IVisitor4_123(count, expectedFieldValue)); Assert.AreEqual(1, count.value); } }
public bool IsIndexed() { try { IStoredClass storedClass = objectContainer.Ext().StoredClass(m_classname); if (null == storedClass) { return(false); } IStoredField field = DataLayerCommon.GetDeclaredStoredFieldInHeirarchy(storedClass, m_fieldname); if (field == null) { return(false); } return(field.HasIndex()); } catch (Exception oEx) { LoggingHelper.HandleException(oEx); return(false); } }
private static IndexingState HasIndex(IStoredField sf) { return sf.HasIndex() ? IndexingState.Indexed : IndexingState.NotIndexed; }
private static IndexingState HasIndex(IStoredField sf) { return(sf.HasIndex() ? IndexingState.Indexed : IndexingState.NotIndexed); }
public _ICodeBlock_113(IStoredField storedField) { this.storedField = storedField; }
public virtual IStoredField[] GetStoredFields() { lock (Lock()) { if (_aspects == null) { return new IStoredField[0]; } var storedFields = new Collection4(); TraverseDeclaredFields(new _IProcedure4_1039(storedFields)); var fields = new IStoredField[storedFields.Size()]; storedFields.ToArray(fields); return fields; } }