protected void DeleteDataRow(Class dataClass, DataRow r)
{
var objId = Convert.ToInt64(r["id", DataRowVersion.Original]);
var obj = new ObjectContainer(dataClass, objId);
ObjectContainerStorage.Delete(obj);
}
public int Update(Query query, IDictionary <string, IQueryValue> data)
{
var schema = GetSchema();
var dataClass = schema.FindClassByID(query.Table.Name);
if (dataClass != null)
{
var affectedObjIds = ObjectContainerStorage.GetObjectIds(query);
foreach (var objId in affectedObjIds)
{
var obj = new ObjectContainer(dataClass, objId);
foreach (var entry in data)
{
var valConst = entry.Value as QConst;
if (valConst == null)
{
throw new NotSupportedException(
String.Format("Value {0} for {1} is not supported", entry.Value, entry.Key));
}
obj[entry.Key] = valConst.Value;
}
ObjectContainerStorage.Update(obj);
}
return(affectedObjIds.Length);
}
var relation = schema.FindRelationshipByID(query.Table.Name);
if (relation != null)
{
throw new NotSupportedException(String.Format("Update is not allowed for relationship {0}", relation.ID));
}
return(UnderlyingDalc.Update(query, data));
}
protected void InsertDataRow(Class dataClass, DataRow r)
{
var obj = new ObjectContainer(dataClass);
foreach (DataColumn c in r.Table.Columns)
{
if (!c.AutoIncrement)
{
var val = r[c];
if (val == DBNull.Value)
{
val = null;
}
obj[c.ColumnName] = val;
}
}
ObjectContainerStorage.Insert(obj);
r["id"] = obj.ID.Value;
}
protected DataTable LoadRelationTable(Query query, DataSet ds)
{
var relations = ObjectContainerStorage.LoadRelations(query.Table.Name, query.Condition);
if (!ds.Tables.Contains(query.Table.Name))
{
ds.Tables.Add(query.Table.Name);
}
var tbl = ds.Tables[query.Table.Name];
// ensure columns
var fields = query.Fields ?? new[] { (QField)"subject_id", (QField)"object_id" };
foreach (var f in fields)
{
if (!tbl.Columns.Contains(f.Name))
{
tbl.Columns.Add(f.Name, typeof(long));
}
}
var loadSubj = tbl.Columns.Contains("subject_id");
var loadObj = tbl.Columns.Contains("object_id");
foreach (var rel in relations)
{
var row = tbl.NewRow();
if (loadSubj)
{
row["subject_id"] = rel.SubjectID;
}
if (loadObj)
{
row["object_id"] = rel.ObjectID;
}
tbl.Rows.Add(row);
}
tbl.AcceptChanges();
return(tbl);
}
protected void UpdateDataRow(Class dataClass, DataRow r)
{
var objId = Convert.ToInt64(r["id"]);
var obj = new ObjectContainer(dataClass, objId);
foreach (DataColumn c in r.Table.Columns)
{
if (!c.AutoIncrement)
{
var val = r[c];
if (val == DBNull.Value)
{
val = null;
}
obj[c.ColumnName] = val;
}
}
ObjectContainerStorage.Update(obj);
}
public int Delete(Query query)
{
var srcName = new QTable(query.Table.Name);
var schema = GetSchema();
var dataClass = schema.FindClassByID(query.Table.Name);
if (dataClass != null)
{
var ids = ObjectContainerStorage.GetObjectIds(query);
return(ObjectContainerStorage.Delete(ids));
}
// check for relation table
var relation = schema.FindRelationshipByID(query.Table.Name);
if (relation != null)
{
var rels = ObjectContainerStorage.LoadRelations(query.Table.Name, query.Condition).ToArray();
ObjectContainerStorage.RemoveRelation(rels);
return(rels.Length);
}
return(UnderlyingDalc.Delete(query));
}
public void Update(DataTable t)
{
var schema = GetSchema();
var dataClass = schema.FindClassByID(t.TableName);
if (dataClass != null)
{
foreach (DataRow r in t.Rows)
{
switch (r.RowState)
{
case DataRowState.Added:
InsertDataRow(dataClass, r);
break;
case DataRowState.Modified:
UpdateDataRow(dataClass, r);
break;
case DataRowState.Deleted:
DeleteDataRow(dataClass, r);
break;
}
}
t.AcceptChanges();
return;
}
// check for relation table
var relation = schema.FindRelationshipByID(t.TableName);
if (relation != null)
{
foreach (DataColumn c in t.Columns)
{
if (c.ColumnName != "subject_id" && c.ColumnName != "object_id")
{
throw new ArgumentException(String.Format("{0} does not exist in {1}", c.ColumnName, t.TableName));
}
}
if (!t.Columns.Contains("subject_id"))
{
throw new ArgumentException("subject_id column is required");
}
if (!t.Columns.Contains("object_id"))
{
throw new ArgumentException("object_id column is required");
}
foreach (DataRow r in t.Rows)
{
switch (r.RowState)
{
case DataRowState.Added:
ObjectContainerStorage.AddRelation(
new ObjectRelation(
Convert.ToInt64(r["subject_id"]),
relation,
Convert.ToInt64(r["object_id"])));
break;
case DataRowState.Deleted:
ObjectContainerStorage.RemoveRelation(
new ObjectRelation(
Convert.ToInt64(r["subject_id", DataRowVersion.Original]),
relation,
Convert.ToInt64(r["object_id", DataRowVersion.Original]))
);
break;
default:
throw new NotSupportedException(String.Format("Relation doesn't support row state {0}", r.RowState));
}
}
t.AcceptChanges();
return;
}
UnderlyingDalc.Update(t);
}
public void Insert(string tableName, IDictionary <string, IQueryValue> data)
{
var schema = GetSchema();
var dataClass = schema.FindClassByID(tableName);
if (dataClass != null)
{
var objContainer = new ObjectContainer(dataClass);
foreach (var changeEntry in data)
{
if (!(changeEntry.Value is QConst))
{
throw new NotSupportedException(
String.Format("{0} value type is not supported", changeEntry.Value.GetType()));
}
objContainer[changeEntry.Key] = ((QConst)changeEntry.Value).Value;
}
ObjectContainerStorage.Insert(objContainer);
return;
}
// check for relation table
var relation = schema.FindRelationshipByID(tableName);
if (relation != null)
{
long?subjId = null;
long?objId = null;
foreach (var entry in data)
{
var valConst = entry.Value as QConst;
if (valConst == null)
{
throw new NotSupportedException(
String.Format("Value {0} for {1} is not supported", entry.Value, entry.Key));
}
if (entry.Key == "subject_id")
{
subjId = Convert.ToInt64(((QConst)entry.Value).Value);
}
else if (entry.Key == "object_id")
{
objId = Convert.ToInt64(((QConst)entry.Value).Value);
}
else
{
throw new ArgumentException(String.Format("{0} does not exist in {1}", entry.Key, tableName));
}
}
if (!subjId.HasValue)
{
throw new ArgumentException("subject_id is required");
}
if (!objId.HasValue)
{
throw new ArgumentException("object_id is required");
}
ObjectContainerStorage.AddRelation(
new ObjectRelation(subjId.Value, relation, objId.Value));
return;
}
UnderlyingDalc.Insert(tableName, data);
}
protected DataTable LoadObjectTable(Query query, DataSet ds, Class dataClass)
{
// special count query
if (query.Fields != null &&
query.Fields.Length == 1 &&
query.Fields[0].Expression != null &&
query.Fields[0].Expression.ToLower() == "count(*)")
{
if (ds.Tables.Contains(query.Table.Name))
{
ds.Tables.Remove(query.Table.Name);
}
var t = ds.Tables.Add(query.Table.Name);
t.Columns.Add("count", typeof(int));
var cntRow = t.NewRow();
cntRow["count"] = ObjectContainerStorage.GetObjectsCount(query);
t.Rows.Add(cntRow);
return(t);
}
DataTable tbl;
if (!ds.Tables.Contains(dataClass.ID))
{
tbl = ds.Tables.Add(dataClass.ID);
}
else
{
tbl = ds.Tables[dataClass.ID];
}
// check columns
IEnumerable <Property> propsToLoad = null;
var relatedPropsToLoad = new Dictionary <Relationship, List <Property> >();
var relationFieldNamePrefix = new Dictionary <Relationship, string>();
var relatedProps = new List <Property>();
if (query.Fields == null)
{
propsToLoad = dataClass.Properties;
}
else
{
var queryProps = new List <Property>();
foreach (var fld in query.Fields)
{
if (fld.Prefix != null)
{
var rel = dataClass.Schema.FindRelationshipByID(fld.Prefix);
if (rel == null)
{
rel = dataClass.Schema.InferRelationshipByID(fld.Prefix, dataClass);
}
if (rel != null)
{
if (rel.Object == dataClass && !rel.Inferred)
{
rel = dataClass.FindRelationship(rel.Predicate, rel.Subject, true);
}
if (rel.Subject != dataClass)
{
throw new ArgumentException(String.Format(
"Relation {0} is not applicable with {1}", fld.Prefix, dataClass.ID));
}
var relProp = rel.Object.FindPropertyByID(fld.Name);
if (relProp != null)
{
if (!relatedPropsToLoad.ContainsKey(rel))
{
relatedPropsToLoad[rel] = new List <Property>();
}
relatedPropsToLoad[rel].Add(relProp);
relationFieldNamePrefix[rel] = fld.Prefix.Replace('.', '_'); // for inferred relations
relatedProps.Add(relProp);
continue;
}
}
}
var prop = dataClass.FindPropertyByID(fld.Name);
if (prop == null)
{
throw new Exception(String.Format("Unknown field {0}", fld));
}
queryProps.Add(prop);
}
propsToLoad = queryProps;
}
// ensure property columns
foreach (var p in propsToLoad)
{
var propType = p.DataType.ValueType;
if (p.Multivalue)
{
propType = propType.MakeArrayType();
}
if (!tbl.Columns.Contains(p.ID) || tbl.Columns[p.ID].DataType != propType)
{
if (tbl.Columns.Contains(p.ID))
{
tbl.Columns.Remove(p.ID);
}
tbl.Columns.Add(p.ID, propType);
}
}
foreach (var relEntry in relatedPropsToLoad)
{
foreach (var relProp in relEntry.Value)
{
var propType = relProp.DataType.ValueType;
if (relProp.Multivalue || relEntry.Key.Multiplicity)
{
propType = propType.MakeArrayType();
}
var relColName = String.Format("{0}_{1}", relationFieldNamePrefix[relEntry.Key], relProp.ID);
if (!tbl.Columns.Contains(relColName) || tbl.Columns[relColName].DataType != propType)
{
if (tbl.Columns.Contains(relColName))
{
tbl.Columns.Remove(relColName);
}
tbl.Columns.Add(relColName, propType);
}
}
}
var ids = ObjectContainerStorage.GetObjectIds(query);
var objects = ObjectContainerStorage.Load(ids, propsToLoad.ToArray());
IDictionary <long, ObjectContainer> relatedObjects = null;
var objIdToRelationData = new Dictionary <long, List <ObjectRelation> >();
if (relatedPropsToLoad.Count > 0)
{
var relationData = ObjectContainerStorage.LoadRelations(objects.Values.ToArray(), relatedPropsToLoad.Keys);
var relObjIds = new List <long>();
foreach (var r in relationData)
{
if (!relObjIds.Contains(r.ObjectID))
{
relObjIds.Add(r.ObjectID);
}
if (!objIdToRelationData.ContainsKey(r.SubjectID))
{
objIdToRelationData[r.SubjectID] = new List <ObjectRelation>();
}
objIdToRelationData[r.SubjectID].Add(r);
}
relatedObjects = ObjectContainerStorage.Load(relObjIds.ToArray(), relatedProps.ToArray());
}
foreach (var id in ids)
{
if (objects.ContainsKey(id))
{
var obj = objects[id];
var r = tbl.NewRow();
foreach (var p in propsToLoad)
{
r[p.ID] = obj[p] ?? DBNull.Value;
}
if (relatedPropsToLoad.Count > 0 && objIdToRelationData.ContainsKey(obj.ID.Value))
{
foreach (var relEntry in relatedPropsToLoad)
{
foreach (var rel in objIdToRelationData[obj.ID.Value])
{
if (rel.Relation.Equals(relEntry.Key) && relatedObjects.ContainsKey(rel.ObjectID))
{
// process related props
foreach (var relProp in relEntry.Value)
{
var relColName = String.Format("{0}_{1}", relationFieldNamePrefix[relEntry.Key], relProp.ID);
if (relEntry.Key.Multiplicity)
{
//TBD: add merge values
r[relColName] = r.IsNull(relColName) ?
relatedObjects[rel.ObjectID][relProp] :
MergeMultivalueColumns(r[relColName], relatedObjects[rel.ObjectID][relProp]);
}
else
{
r[relColName] = relatedObjects[rel.ObjectID][relProp];
}
}
}
}
}
}
tbl.Rows.Add(r);
r.AcceptChanges();
}
}
tbl.AcceptChanges();
return(tbl);
}
