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);
}
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());
}
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());
}
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);
StringBuilder b = new StringBuilder();
FieldInfo f = w.RetrieveField(_type, _field, false);
if (f == null)
{
throw new RestrictionException("Field '" + _field + "' not found in '" + _type.ToString() + "'");
}
b.Append(w.GetColumnMapping(f));
b.Append(_comparer).Append(SqlUtil.SqlConvert(_value));
String tmp = ComputeSqlJoin(serializer, path, b.ToString(), target).ToString();
return(tmp);
}
internal void Analyze()
{
SyncItem sourceSyncItem = FetchSyncItem(_sourceGuid);
SyncItem sinkSyncItem;
ISerializableObject source = FetchObject(_sourceSerializer, _sourceGuid);
if (sourceSyncItem == null)//In der Synchronisationstabelle gibt es keinen korrepondierenden Eintrag
{
#if DEBUG
logger.Debug(source.GetType().Name + ", guid=" + AttributeWorker.RowGuid(source) + " is not synchronized and will be inserted");
#endif
SyncState = new InsertState(this);
}
else //in der Synchronisationstabelle ist ein Eintrag vorhanden
{
sinkSyncItem = sourceSyncItem.CounterPart;
_sinkGuid = sinkSyncItem.SyncGuid;
ISerializableObject sink = FetchObject(_sinkSerializer, _sinkGuid); //Das korrepondierende Objekt wird aus der Zieldatenbankgeholt
if (sink == null) //Wenn es nicht vorhanden ist wurde es gelöscht
{
#if DEBUG
logger.Debug(sourceSyncItem.ClassID + ", guid=" + AttributeWorker.RowGuid(source) + " does not exist, the conflict has to be resolved");
#endif
SyncState = new DeletedState(this, sourceSyncItem);
}
else
{
String h1 = sinkSyncItem.Hashcode;
String sinkHashCode = ComputeHashCode(_sinkSerializer.Target, sink);
if (h1 != sinkHashCode)//Änderung der Daten in der Zieldatenbank--warum ist das schon ein Konflikt?
{
#if DEBUG
logger.Debug(sourceSyncItem.ClassID + ", guid=" + AttributeWorker.RowGuid(source) + " is involved in a conflict, which has to be resolved");
#endif
SyncState = new ConflictState(this, sourceSyncItem);
}
else //zieldatenbank unverändert
{
String sourceHashCode = ComputeHashCode(SourceSerializer.Target, source);
if (sourceHashCode == sourceSyncItem.Hashcode)//Quelldatenbank unverändert
{
#if DEBUG
logger.Debug(sourceSyncItem.ClassID + ", guid=" + AttributeWorker.RowGuid(source) + " has not changed and will not be synchronized");
#endif
SyncState = new IgnoreState(this);
}
else//Quelldatenbank verändert-Zieldatenbank unverändert ->update
{
#if DEBUG
logger.Debug(sourceSyncItem.ClassID + ", guid=" + AttributeWorker.RowGuid(source) + " has changed on the sourceside and will be updated");
#endif
SyncState = new UpdateState(this, sourceSyncItem);
}
}
}
}
AttributeWorker w = AttributeWorker.GetInstance(_sinkSerializer.Target);
IList <FieldInfo> fis = w.GetFieldByAttribute <CheckForeingKeyConstraintAttribute>(_synchronizedType);
foreach (FieldInfo fi in fis)
{
Object val = fi.GetValue(source);
if (val == null)
{
continue;
}
CheckForeingKeyConstraintAttribute attr = w.GetAttribute <CheckForeingKeyConstraintAttribute>(fi);
String table = attr.UnmappedTable;
String column = attr.ExternColumn;
if (column == null)
{
column = w.GetColumnMapping(fi);
}
if (!_sinkSerializer.Connector.Exists(column, val, table))
{
//Hier kann man einen neuen Status einführen, der dieses Problem abfängt
throw new InvalidOperationException("Insertion of " + _synchronizedType.Name + " will fail. Unmapped foreign key " + column + "=" + val + " does not exist in target database!");
}
}
}
internal virtual String SerializeUpdate(ISerializableObject iso, ref UpdateStates state, GenericWeakReference <ISerializableObject> tmp)
{
AttributeWorker w = AttributeWorker.GetInstance(Target);
StringBuilder sql = new StringBuilder();
StringBuilder where = new StringBuilder();
Guid g = AttributeWorker.RowGuid(iso);
FieldInfo f = AttributeWorker.RowGuid(iso.GetType());
sql.Append("UPDATE ").Append(w.GetTableMapping(iso.GetType(), _praefix));
sql.Append(" SET ");
where.Append(" WHERE ").Append(AttributeWorker.GetInstance(Target).GetColumnMapping(f));
where.Append("='").Append(g).Append("'");;
FieldInfo[] fis = AttributeWorker.RetrieveAllFields(iso.GetType());
bool start = true;
foreach (FieldInfo fi in fis)
{
try
{
String col = w.GetColumnMapping(fi);
Object val = fi.GetValue(iso);
Object oldVal;
if (w.IsAutoincID(fi))
{
continue;
}
if (AttributeWorker.IsRowGuid(fi))
{
continue;
}
if (w.IsID(fi))
{
oldVal = tmp.Properties[fi.Name];
if (!Object.Equals(val, oldVal))
{
state = UpdateStates.PRIMARYKEY_MODIFIED;
}
tmp.Properties[fi.Name] = val;
}
if (!start)
{
sql.Append(", ");
}
else
{
start = false;
}
sql.Append(col).Append("=").Append(SqlUtil.SqlConvert(val));
}
catch (SerializerException) { }
}
sql.Append(where);
return(sql.ToString());
}
