internal void copyToSinkObject(ISerializableObject from, ISerializableObject to) { AttributeWorker w = AttributeWorker.GetInstance(sinkSerializer.Target);//Am besten durch Kopiervorgang ersetzen, der ohne Attributeworker auskommt. FieldInfo[] fis = AttributeWorker.RetrieveAllFields(from.GetType()); foreach (FieldInfo fi in fis) { if (w.IsAutoincID(fi)) { continue; //Kann man aus Lookup-Tabelle holen } if (!w.IsPersistentField(fi)) { continue; //wirklich nötig? } //DirectSync wird im Moment nicht unterstützt if (AttributeWorker.IsRowGuid(fi)) { continue; //Kann man als Lookup-Tabelle definieren } Object val = fi.GetValue(from); fi.SetValue(to, val); } }
internal void Delete(ISerializableObject iso, ISerializerTransaction transaction) { if (!IsManaged(iso)) { return; } AttributeWorker w = AttributeWorker.GetInstance(Target); ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>(); data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType()); data.HandledItem = iso; DeleteHandler h = new DeleteHandler(this); RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>(); res.Handler = h; h.MODE = DeleteHandler.DOWNMODE; res.StartRelationResolving(data); _objectPool.DeleteObject(iso, _connection, transaction); h.MODE = DeleteHandler.UPMODE; res.StartRelationResolving(data); }
public void Activate(string target) { _target = target; _connection = (DbConnection)CreateConnection(); if (_connection.State == ConnectionState.Closed || _connection.State == ConnectionState.Broken) { try { _connection.Close(); } catch (Exception ex) { } } _connection.Open(); //Initialisierung des AttributeWorkers ... AttributeWorker.GetInstance(Target); VirtualKeyFactory vkf = new VirtualKeyFactory(AttributeWorker.GetInstance(target)); foreach (Type t in RegisteredTypes) { vkf.RegisterType(t); } AttributeWorker.GetInstance(Target).AddVirtualKeyFactory(this, vkf); _objectPool = new SortedSerializableObjectPool(this, _registeredTypes); ((SortedSerializableObjectPool)_objectPool).Cleaner = new DefaultCleaner(); }
public CsvPKey(Type type, String csvKey, String target) { _csvKey = csvKey; _type = type; IDictionary <String, FieldInfo> ids = AttributeWorker.GetInstance(target).GetPrimaryKeyFields(type); String[] split = Split(_csvKey, ";", "/;"); foreach (String s in split) { String[] tmp = Split(s, "=", "/="); FieldInfo f = ids[tmp[0]]; tmp[1] = tmp[1].Replace("/;", ";"); tmp[1] = tmp[1].Replace("/=", "="); tmp[1] = tmp[1].Replace("//", "/"); Object val; if (f.FieldType.IsGenericType && f.FieldType.GetGenericTypeDefinition() == typeof(Nullable <>)) { Type t = Nullable.GetUnderlyingType(f.FieldType); val = Convert.ChangeType(tmp[1], t, null); } else { val = Convert.ChangeType(tmp[1], f.FieldType, null); } _fields.Add(f); _values.Add(val); } }
public ISerializableObject CreateISerializableObject(Type type) { AttributeWorker w = AttributeWorker.GetInstance(Target); ISerializableObject iso = null; try { iso = (ISerializableObject)Activator.CreateInstance(type); } catch (InvalidCastException) { throw new SerializerException(); } _objectPool.Register(iso); ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>(); data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType()); data.HandledItem = iso; CreateHandler handler = new CreateHandler(this); RelationResolver <ISerializableObject> resolver = new RelationResolver <ISerializableObject>(); resolver.Handler = handler; resolver.StartRelationResolving(data); return(iso); }
internal virtual String Delete(ISerializableObject iso) { AttributeWorker w = AttributeWorker.GetInstance(Target); StringBuilder sql = new StringBuilder(); sql.Append("DELETE FROM ").Append(w.GetTableMapping(iso.GetType(), _praefix)); sql.Append(" WHERE "); FieldInfo[] fis = AttributeWorker.RetrieveAllFields(iso.GetType()); bool start = true; foreach (FieldInfo fi in fis) { if (w.IsID(fi)) { String col = w.GetColumnMapping(fi); Object val = fi.GetValue(iso); if (val == null) { throw new SerializerException("Not deletable ..."); } if (!start) { sql.Append(" AND "); } start = false; sql.Append(col).Append("=").Append(SqlUtil.SqlConvert(val)); } } return(sql.ToString()); }
protected override void SynchronizeImpl() { ISerializableObject source = StateOwner.SourceObject; ISerializableObject sink = StateOwner.SinkSerializer.CreateISerializableObject(StateOwner.SynchronizedType); CopyUtils.PlainCopy(StateOwner.SinkSerializer, KeyCarrier, sink, new FieldLock(source.GetType()), true); CopyUtils.PlainCopy(StateOwner.SinkSerializer, source, sink, new FieldLock(source.GetType()), false); StateOwner.SinkSerializer.Connector.InsertPlain(sink); StateOwner.SinkObject = sink; SyncItem si1 = StateOwner.SyncSerializer.CreateISerializableObject <SyncItem>(); SyncItem si2 = StateOwner.SyncSerializer.CreateISerializableObject <SyncItem>(); si1.SyncGuid = AttributeWorker.RowGuid(source); si2.SyncGuid = AttributeWorker.RowGuid(sink); si1.ClassID = source.GetType().Name; si2.ClassID = source.GetType().Name; si1.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SourceSerializer.Target, source); si2.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SinkSerializer.Target, sink); si1.CounterPart = si2; StateOwner.SyncSerializer.Connector.Save(si1); StateOwner.SyncSerializer.ConnectOneToOne(si1, si2); StateOwner.SyncSerializer.Connector.Save(si2); StateOwner.SyncSerializer.ConnectOneToOne(si2, si1); StateOwner.SyncSerializer.Connector.Save(si1); StateOwner.UpdateFieldStates(StateOwner.SourceSerializer.Target, si1, source);//Deaktiviert StateOwner.UpdateFieldStates(StateOwner.SinkSerializer.Target, si2, sink); }
public bool analyzeObjects() { if (object1.Rowguid != object2.Rowguid) { throw new Exception("Objects don´t correspond."); } bool inConflict = false; FieldInfo[] fields = AttributeWorker.RetrieveAllFields(ownerType); foreach (FieldInfo fi in fields) { Attribute at = Attribute.GetCustomAttribute(fi, typeof(ColumnAttribute)); IDAttribute id = (IDAttribute)Attribute.GetCustomAttribute(fi, typeof(IDAttribute)); if (at != null) { if (id != null && id.Autoinc == true) { } else { Conflict cf = compareFields(fi, object1, object2); if (cf != null) { inConflict = true; this.conflicts.Add(cf); } } } } return(inConflict); }
public UpdateStates UpdateObject(ISerializableObject iso, DbConnection connection, ISerializerTransaction transaction) { UpdateStates state = UpdateStates.UPDATED; AttributeWorker w = AttributeWorker.GetInstance(Target); DbCommand com = connection.CreateCommand(); Guid g = AttributeWorker.RowGuid(iso); GenericWeakReference <ISerializableObject> tmp; try { tmp = _persistentObjects[g]; } catch (KeyNotFoundException ex) { throw new UpdateException("update failed. object is not known by the system and must be loaded first", ex); } com.CommandText = _owner.SerializeUpdate(iso, ref state, tmp); transaction.Guard(com); //Console.WriteLine(com.CommandText); try { if (com.ExecuteNonQuery() < 1) { state = UpdateStates.NO_ROWS_AFFECTED; return(state); } return(state); } catch (Exception ex) { throw new SerializerException("update failed", ex); } }
internal bool Exists(String column, Object value, String table, ISerializerTransaction transaction) { AttributeWorker w = AttributeWorker.GetInstance(Target); StringBuilder b = new StringBuilder(); b.Append("SELECT ").Append(column).Append(" FROM ").Append(table).Append(" WHERE ").Append(column).Append("="); b.Append(SqlUtil.SqlConvert(value)); DbCommand com = _connection.CreateCommand(); transaction.Guard(com); com.CommandText = b.ToString(); //Console.WriteLine(com.CommandText); DbDataReader r = com.ExecuteReader(); if (r.Read()) { r.Close(); return(true); } r.Close(); return(false); }
public CsvPimaryKey(ISerializableObject iso, String target) { _type = iso.GetType(); IDictionary <String, FieldInfo> ids = AttributeWorker.GetInstance(target).GetPrimaryKeyFields(iso.GetType()); List <String> tmpList = new List <String>(ids.Count); StringBuilder csvKey = new StringBuilder(); String tmp; foreach (String id in ids.Keys) { StringBuilder tmpBuilder = new StringBuilder(); _fields.Add(ids[id]); _values.Add(ids[id].GetValue(iso)); try { //if (ids[id].GetValue(iso) is DateTime) //{ // DateTime dt = (DateTime)ids[id].GetValue(iso); // tmp = SqlUtil.SqlConvert(dt); //} //else // tmp = ids[id].GetValue(iso).ToString(); tmp = SqlUtil.SqlConvert(ids[id].GetValue(iso)).ToString(); } catch (NullReferenceException ex) { throw new KeyNotFoundException("", ex); } //Maskierung der Kommata tmp = tmp.Replace("/", "//"); tmp = tmp.Replace(";", "/;"); tmp = tmp.Replace("=", "/="); tmpBuilder.Append(id).Append("="); tmpBuilder.Append(tmp); tmpList.Add(tmpBuilder.ToString()); } tmpList.Sort(); bool initial = true; foreach (String s in tmpList) { if (!initial) { csvKey.Append(";"); } initial = false; csvKey.Append(s); } _csvKey = csvKey.ToString(); }
public override String ToSqlString(Serializer.Serializer serializer, Type type, String target) { AttributeWorker w = AttributeWorker.GetInstance(target); IList <Type> path = w.ComputeVirtualKeyPath(serializer, _type, type); //ComputePath(type, _type, target); return(ComputeSqlJoin(serializer, path, _sqlString, target).ToString()); }
internal void AdjustKeyDownward(ISerializableObject iso) { AttributeWorker w = AttributeWorker.GetInstance(_sinkSerializer.Target); IVirtualKey vKey = w.CreateVirtualKey(_sinkSerializer, _synchronizedType, iso.GetType()); vKey.InitVirtualKeyBySource(FetchObject(_sinkSerializer, _sinkGuid)); vKey.ApplyVirtualKeyToTarget(iso); }
public override void UpdateOneToMany(Object iterator, ISerializableObject owner, Type storedType, Serializer serializer) { IVirtualKey vKey = AttributeWorker.GetInstance(serializer.Target).CreateVirtualKey(serializer, owner.GetType(), storedType); vKey.InitVirtualKeyBySource(owner); ((IDirectAccessIteratorConfiguration)iterator).Restriction = Restrictions.RestrictionFactory.SqlRestriction(storedType, vKey.ToSqlStringForward(serializer.Target)); }
internal void AddISerializableObject(ISerializableObject iso) { if (!_pooledObjects.ContainsKey(AttributeWorker.RowGuid(iso))) { SyncContainer container = new SyncContainer(iso, _syncSerializer, _serializer); _pooledObjects[AttributeWorker.RowGuid(iso)] = container; } }
internal virtual String SerializeInsert(ISerializableObject iso, string table) { AttributeWorker w = AttributeWorker.GetInstance(Target); StringBuilder sql = new StringBuilder(); StringBuilder values = new StringBuilder(); sql.Append("INSERT INTO ").Append(table); sql.Append(" ("); FieldInfo[] fis = AttributeWorker.RetrieveAllFields(iso.GetType()); bool start = true; foreach (FieldInfo fi in fis) { if (w.IsAutoincID(fi)) { continue; } try { String col = w.GetColumnMapping(fi); Object val = fi.GetValue(iso); if (val == null && (w.IsID(fi) && !w.IsAutoincID(fi))) { throw new SerializerException("PRIMARY KEY FIELD NOT SET!!!!!!!!"); } if (!start) { sql.Append(", "); values.Append(", "); } else { start = false; } sql.Append(col); values.Append(SqlUtil.SqlConvert(val)); } catch (SerializerException) { } } sql.Append(") VALUES ("); sql.Append(values); sql.Append(")"); return(sql.ToString()); }
protected StringBuilder ComputeSqlJoin(Serializer.Serializer serializer, IList <Type> path, String restriction, String target) { AttributeWorker w = AttributeWorker.GetInstance(target); QueryGenerator ret = new QueryGenerator(); ret.AddQueryComponent(new PlaceHolderComponent()); //StringBuilder b = new StringBuilder(); //b.Append(" @@@"); for (int i = 0; i < path.Count - 1; i++) { Type from = path[i]; Type to = path[i + 1]; //if (i > 0) //{ // b.Replace(" @@@", " WHERE @@@"); //} IVirtualKey vKey = w.CreateVirtualKey(serializer, from, to); QueryGenerator gen1 = vKey.ToSqlRestriction(target, from, to, serializer); ret.ReplacePlaceHolders(gen1); //b.Replace(" @@@", vKey.ToSqlRestriction(target, from, to)); if (i == path.Count - 2) { QueryGenerator gen2 = new QueryGenerator(); gen2.AddQueryComponent(new SqlStringComponent(" WHERE ")); gen2.AddQueryComponent(new SqlStringComponent(restriction)); ret.ReplacePlaceHolders(gen2); //b.Replace(" @@@", " WHERE @@@"); //b.Replace(" @@@", restriction); } } if (path.Count == 1) { QueryGenerator gen3 = new QueryGenerator(); gen3.AddQueryComponent(new SqlStringComponent(" WHERE ")); gen3.AddQueryComponent(new SqlStringComponent(restriction)); ret.ReplacePlaceHolders(gen3); //b.Replace(" @@@", " WHERE @@@"); //b.Replace(" @@@", restriction); } //Entferne das führende " WHERE " return(ret.ToSqlString()); //return b.Remove(0,7); }
public bool IsManagedObject(ISerializableObject iso) { try { return(_persistentObjects[AttributeWorker.RowGuid(iso)].Target != null); } catch (KeyNotFoundException) { return(false); } }
public void InsertObject(ISerializableObject iso, DbConnection connection, ISerializerTransaction transaction) { AttributeWorker w = AttributeWorker.GetInstance(Target); DbCommand com = connection.CreateCommand(); com.CommandText = _owner.SerializeInsert(iso); transaction.Guard(com); //Console.WriteLine(com.CommandText); try { //Console.WriteLine(com.ExecuteNonQuery()); com.ExecuteNonQuery(); } catch (Exception ex) { throw new SerializerException("insert failed", ex); } FieldInfo autoincField; Guid g = AttributeWorker.RowGuid(iso); if ((autoincField = w.GetAutoincField(iso.GetType())) != null) { StringBuilder b = new StringBuilder(); b.Append("SELECT * FROM ").Append(w.GetTableMapping(iso.GetType(), _owner.Praefix)).Append(" WHERE "); b.Append(w.GetColumnMapping(AttributeWorker.RowGuid(iso.GetType()))).Append("='"); b.Append(g.ToString()).Append("'"); com.CommandText = b.ToString(); DbDataReader r = com.ExecuteReader(); if (r.Read()) { Object o = r[w.GetColumnMapping(w.GetAutoincField(iso.GetType()))]; autoincField.SetValue(iso, o); } else { r.Close(); throw new SerializerException("Insert core method failed! error unknown..."); } r.Close(); } GenericWeakReference <ISerializableObject> tmp = new GenericWeakReference <ISerializableObject>(iso); _persistentObjects[g] = tmp; MemoriseKeys(iso, w, tmp); }
public void RegisterType(Type t) { FieldInfo f = AttributeWorker.RowGuid(t); if (f == null) { throw new TypeDefException("Type " + t + " has no row guid column!"); } _registeredTypes.Add(t); }
private ISerializableObject FetchObject(Serializer s, Guid guid) { FieldInfo fi = AttributeWorker.RowGuid(_synchronizedType); String col = AttributeWorker.GetInstance(s.Target).GetColumnMapping(fi); StringBuilder tmp = new StringBuilder(); tmp.Append(col).Append("='").Append(guid).Append("'");; IRestriction res = RestrictionFactory.SqlRestriction(_synchronizedType, tmp.ToString()); ISerializableObject iso = s.Connector.Load(_synchronizedType, res); return(iso); }
//public IDirectAccessIterator<IdentificationUnit> Identification //{ // get { return _IdentificationUnits; } //} //public IDirectAccessIterator<CollTaxonomicGroup_Enum> CollTaxonomicGroups //{ // get { return _CollTaxonomicGroups; } //} //public CollTaxonomicGroup_Enum CollTaxonomicGroup //{ // get { return _CollTaxonomicGroup; } //} #endregion #region ToString override public override string ToString() { if (this.DisplayText != null) { String text = "CollTaxonomicGroup: " + this.DisplayText; return(text); } else { return(AttributeWorker.ToStringHelper(this, 30)); } }
//public IDirectAccessIterator<IdentificationUnit> IdentificationUnits //{ // get { return _IdentificationUnits; } //} #endregion #region ToString Override public override string ToString() { if (this.DisplayText != null) { String text = "CollUnitRelationType: " + this.DisplayText; return(text); } else { return(AttributeWorker.ToStringHelper(this, 30)); } }
//public IDirectAccessIterator<CollectionEventLocalisation> CollectionEventLocalisation //{ // get { return _CollectionEventLocalisations; } //} //public IDirectAccessIterator<LocalisationSystem> LocalisationSystemChildren //{ // get { return _LocalisationSystemChildren; } //} //public LocalisationSystem LocalisationSystemParent //{ // get { return _LocalisationSystemParent; } // set { _LocalisationSystemParent = value; } //} #endregion #region ToString override public override string ToString() { if (this.DisplayText != null) { String text = "LocalisationSystem: " + this.DisplayText; return(text); } else { return(AttributeWorker.ToStringHelper(this, 30)); } }
//public IDirectAccessIterator<Identification> Identifications //{ // get { return _Identifications; } //} #endregion #region ToString Override public override string ToString() { if (this.DisplayText != null) { String text = "CollIdentificationCategory " + this.DisplayText; return(text); } else { return(AttributeWorker.ToStringHelper(this, 30)); } }
public override string ToString() { if (this._TaxonNameCache != null) { String text = "TaxonNames: " + this._TaxonNameCache; return(text); } else { return(AttributeWorker.ToStringHelper(this, 30)); } }
public override string ToString() { if (this._Name != null) { String text = "SamplingPlot: " + this._Name; return(text); } else { return(AttributeWorker.ToStringHelper(this, 30)); } }
//public IDirectAccessIterator<AnalysisTaxonomicGroup> AnalysisTaxonomicGroup //{ // get { return _analysisTaxonomicGroups; } //} //public IDirectAccessIterator<Analysis> AnalysisChildren //{ // get { return _Analysis; } //} //public IDirectAccessIterator<AnalysisResult> AnalysisResults //{ // get { return _AnalysisResults; } //} //public IDirectAccessIterator<IdentificationUnitAnalysis> IdentificationUnitAnalysis //{ // get { return _IdentificationUnitAnalysis; } //} //public Analysis AnalysisParent //{ // get { return _analysisParent; } // set { _analysisParent = value; } //} #endregion #region ToString override public override string ToString() { if (this.DisplayText != null) { String text = "Analysis: " + this.DisplayText; return(text); } else { return(AttributeWorker.ToStringHelper(this, 30)); } }
private static void MemoriseKeys(ISerializableObject iso, AttributeWorker w, GenericWeakReference <ISerializableObject> gwr) { IDictionary <String, FieldInfo> pkf = w.GetPrimaryKeyFields(iso.GetType()); foreach (FieldInfo fi in pkf.Values) { if (w.IsAutoincID(fi)) { continue; } gwr.Properties[fi.Name] = fi.GetValue(iso); } }
//Konstruktor internal SyncContainer(ISerializableObject iso, Serializer syncSerializer, Serializer sourceSerializer) { SyncState = new PrematureState(this); _synchronizedType = iso.GetType(); _sourceGuid = AttributeWorker.RowGuid(iso); _syncSerializer = syncSerializer; _sourceSerializer = sourceSerializer; _parents = new List <SyncContainer>(); _children = new List <SyncContainer>(); }
private static void MemoriseKeys(ISerializableObject iso, AttributeWorker w, GenericWeakReference<ISerializableObject> gwr) { IDictionary<String, FieldInfo> pkf = w.GetPrimaryKeyFields(iso.GetType()); foreach (FieldInfo fi in pkf.Values) { if (w.IsAutoincID(fi)) continue; gwr.Properties[fi.Name] = fi.GetValue(iso); } }