public ServerObject SelectScalar(Type type, Query query)
{
query.Top = 1;
ServerObjectCollection collection = Select(type, query);
if (collection.Count != 1)
{
return(null);
}
return(collection[0]);
}
internal ServerObjectCollection GetValue(string key)
{
Trace.WriteLineIf(DebugOutput.Enabled, "Getting value for key " + key);
ServerObjectCollection children = data[key] as ServerObjectCollection;
if (children == null && obj.State == ObjectState.Added)
{
children = new ServerObjectCollection();
data[key] = children;
}
return(children);
}
private void CommitChildren(ServerObject obj, object key)
{
Trace.WriteLineIf(DebugOutput.Enabled, "Enumerating children");
TypeSchema schema = SchemaCache.Current.GetSchema(obj.ServerObjectType);
if (key != null)
{
foreach (ChildrenSchema childSchema in schema.ChildrenSchemas)
{
ServerObjectCollection children = obj.Children.GetValue(childSchema.Property.Name);
if (children == null)
{
continue;
}
TypeSchema childTypeSchema = SchemaCache.Current.GetSchema(childSchema.ChildType);
ParentSchema parentSchema = childTypeSchema.FindParentSchema(childSchema.PropertyName);
foreach (ServerObject child in children)
{
if (child.Parents.GetValue(parentSchema.Property.Name) != obj)
{
continue;
}
child.Data.SetValue(parentSchema.Property.Name, key);
}
}
}
foreach (ChildrenSchema childSchema in schema.ChildrenSchemas)
{
ServerObjectCollection children = obj.Children.GetValue(childSchema.Property.Name);
if (children == null)
{
continue;
}
foreach (ServerObject child in children)
{
Commit(child, true);
}
}
}
/// <summary>
/// Gets the child collection associated with the given property.
/// </summary>
/// <param name="key">The name of the property in the <see cref="ServerObject">ServerObject</see> which exposes this child collection.</param>
/// <value>A <see cref="ServerObjectCollection">ServerObjectCollection</see> that is a child collection or if no children exists an empty collection.</value>
public ServerObjectCollection this[string key]
{
get
{
if (data[key] == null)
{
Trace.WriteLineIf(DebugOutput.Enabled, "Children not found, loading");
ServerObjectCollection children = obj.State == ObjectState.Added ? new ServerObjectCollection() : obj.Transaction.SelectChildren(obj, key);
data[key] = children;
return(children);
}
return(data[key] as ServerObjectCollection);
}
}
internal ServerObjectCollection SelectChildren(ServerObject obj, string propertyName)
{
Trace.WriteLineIf(DebugOutput.Enabled, "Selecting children for " + propertyName);
TypeSchema schema = SchemaCache.Current.GetSchema(obj.ServerObjectType);
ChildrenSchema childrenSchema = schema.FindChildrenSchema(propertyName);
ServerObjectCollection children = null;
object primaryKey = obj.Data.GetValue(schema.PrimaryKey.Property.Name);
Query query = new Query(new Condition(childrenSchema.PropertyName, Expression.Equal, primaryKey));
children = Select(childrenSchema.ChildType, query);
Trace.WriteLineIf(DebugOutput.Enabled, "Checking cache for more items");
foreach (ServerObject cacheItem in objectCache.GetCacheItem(childrenSchema.ChildType))
{
if (primaryKey.Equals(cacheItem.Data.GetValue(childrenSchema.PropertyName)) && !children.Contains(cacheItem))
{
children.Add(cacheItem);
}
}
ServerObjectCollection toRemove = new ServerObjectCollection();
foreach (ServerObject child in children)
{
if (!primaryKey.Equals(child.Data.GetValue(childrenSchema.PropertyName)))
{
toRemove.Add(child);
}
}
foreach (ServerObject child in toRemove)
{
children.Remove(child);
}
return(children);
}
public ServerObjectCollection Select(Type type, Query query)
{
if (type == null)
{
throw new ArgumentNullException("type", "type cannot be null.");
}
if (query == null)
{
throw new ArgumentNullException("query", "query cannot be null.");
}
ServerObjectCollection collection = new ServerObjectCollection();
try
{
adapter.Open();
collection = adapter.Select(type, query);
}
finally
{
adapter.Close();
}
for (int i = 0; i < collection.Count; i++)
{
collection[i].State = ObjectState.Unchanged;
collection[i].SetTransaction(this);
collection[i] = objectCache.Add(collection[i]);
collection[i].PromptEvent(EventType.Initialised);
}
return(collection);
}
/// <summary>
/// Gets or sets the <see cref="ServerObject">ServerObject</see> that is a Parent object.
/// </summary>
/// <remarks>
/// On object access if a parent exists but has not be retrieved by ObjectServer then it will be retrieved and returned.
/// Otherwise the existing object will be returned. If you wish a null value to be set the assign null to the parent.
/// When an object is assigned as a parent, ObjectServer will locate the correct children collection and automatically append the current object.
/// </remarks>
/// <param name="key">The name of the property in the <see cref="ServerObject">ServerObject</see> which exposes this Parent.</param>
/// <value>A <see cref="ServerObject">ServerObject</see> that is a Parent object or if no parent exists null.</value>
public ServerObject this[string key]
{
get
{
if (data[key] == null)
{
Trace.WriteLineIf(DebugOutput.Enabled, "Parent not found, loading");
TypeSchema schema = SchemaCache.Current.GetSchema(obj.ServerObjectType);
ParentSchema parentSchema = schema.FindParentSchema(key);
ServerObject parent = obj.Transaction.Select(parentSchema.Property.PropertyType, obj.Data.GetValue(key));
data[key] = parent;
return(parent);
}
else if (Convert.IsDBNull(data[key]))
{
Trace.WriteLineIf(DebugOutput.Enabled, "Key Value is DBNull.Value returning null");
return(null);
}
return(data[key] as ServerObject);
}
set
{
if (value == null)
{
Trace.WriteLineIf(DebugOutput.Enabled, "Parent set to null, setting key value to DBNull.Value");
obj.Data.SetValue(key, DBNull.Value);
data[key] = DBNull.Value;
UpdateState(key);
}
else
{
if (!value.Equals(data[key]))
{
Trace.WriteLineIf(DebugOutput.Enabled, "New Parent set");
ServerObject newParent = value as ServerObject;
ServerObject oldParent = data[key] != null ? data[key] as ServerObject : null;
TypeSchema schema = SchemaCache.Current.GetSchema(newParent.ServerObjectType);
object parentKey = newParent.Data.GetValue(schema.PrimaryKey.Property.Name);
obj.Data.SetValue(key, parentKey);
data[key] = newParent;
UpdateState(key);
foreach (ChildrenSchema childSchema in schema.ChildrenSchemas)
{
if (childSchema.PropertyName == key && childSchema.ChildType == obj.ServerObjectType)
{
if (oldParent != null)
{
Trace.WriteLineIf(DebugOutput.Enabled, "Removing from children collection " + childSchema.Property.Name);
ServerObjectCollection oldChildren = oldParent.Children.GetValue(childSchema.Property.Name);
if (oldChildren != null && oldChildren.Contains(obj))
{
oldChildren.Remove(obj);
}
}
Trace.WriteLineIf(DebugOutput.Enabled, "Adding to children collection " + childSchema.Property.Name);
ServerObjectCollection newChildren = newParent.Children.GetValue(childSchema.Property.Name);
if (newChildren != null && !newChildren.Contains(obj))
{
newChildren.Add(obj);
}
break;
}
}
}
}
}
}
private void DeleteImpl(ServerObject obj)
{
if (obj.Processed)
{
return;
}
Trace.WriteLineIf(DebugOutput.Enabled, "Deleting ServerObject of type " + obj.ServerObjectType);
switch (obj.State)
{
case ObjectState.Added:
Trace.WriteLineIf(DebugOutput.Enabled, "Setting state to ObjectState.Detached");
obj.State = ObjectState.Detached;
break;
case ObjectState.Modified:
case ObjectState.Unchanged:
Trace.WriteLineIf(DebugOutput.Enabled, "Setting state to ObjectState.Deleted");
obj.State = ObjectState.Deleted;
break;
case ObjectState.Deleted:
case ObjectState.Detached:
break;
default:
throw new ObjectServerException("Invalid ObjectState found.");
}
;
obj.Processed = true;
TypeSchema parentTypeSchema = SchemaCache.Current.GetSchema(obj.ServerObjectType);
Trace.WriteLineIf(DebugOutput.Enabled, "Enumerating Childrean");
foreach (ChildrenSchema childSchema in parentTypeSchema.ChildrenSchemas)
{
Trace.WriteLineIf(DebugOutput.Enabled, "Checking Children " + childSchema.Property.Name);
ServerObjectCollection children = obj.Children[childSchema.Property.Name] as ServerObjectCollection;
TypeSchema childTypeSchema = SchemaCache.Current.GetSchema(childSchema.ChildType);
ParentSchema parentSchema = childTypeSchema.FindParentSchema(childSchema.PropertyName);
int nonDeleted = 0;
foreach (ServerObject child in children)
{
if (child.State != ObjectState.Deleted && child.State != ObjectState.Detached)
{
nonDeleted++;
}
}
Trace.WriteLineIf(DebugOutput.Enabled, "Counted " + nonDeleted + " non-deleted children");
if (nonDeleted > 0)
{
if (parentSchema.DeleteAction == DeleteAction.Throw)
{
throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "Could not delete, {0}.{1} has DeleteAction.Throw", childTypeSchema.Type.FullName, parentSchema.Property.Name));
}
if (parentSchema.DeleteAction == DeleteAction.Null)
{
Trace.WriteLineIf(DebugOutput.Enabled, "Changing key to DBNull.Value and updating state");
foreach (ServerObject child in children)
{
child.Data.SetValue(childSchema.PropertyName, DBNull.Value);
switch (child.State)
{
case ObjectState.Added:
case ObjectState.Modified:
case ObjectState.Detached:
case ObjectState.Deleted:
break;
case ObjectState.Unchanged:
child.State = ObjectState.Modified;
break;
default:
throw new ObjectServerException("Invalid ObjectState found.");
}
;
}
continue;
}
}
Trace.WriteLineIf(DebugOutput.Enabled, "Processing children");
foreach (ServerObject child in children)
{
DeleteImpl(child);
}
}
}