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));
}
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 DataTable Load(Query query, DataSet ds)
{
var schema = GetSchema();
var dataClass = schema.FindClassByID(query.Table.Name);
if (dataClass != null)
{
if (ObjectContainerStorage is ISqlObjectContainerStorage)
{
// SQL-optimized data load
DataTable tbl = !ds.Tables.Contains(dataClass.ID) ? ds.Tables.Add(dataClass.ID) : ds.Tables[dataClass.ID];
tbl.BeginLoadData();
ExecuteReader(query, (reader) => {
for (int i = 0; i < query.StartRecord; i++)
{
reader.Read(); // skip first N records
}
var fieldIdxMapping = new int[reader.FieldCount];
for (int i = 0; i < reader.FieldCount; i++)
{
var cName = reader.GetName(i);
var cType = reader.GetFieldType(i);
if (!tbl.Columns.Contains(cName))
{
tbl.Columns.Add(cName, cType);
}
fieldIdxMapping[i] = tbl.Columns.IndexOf(cName);
}
var values = new object[reader.FieldCount];
while (reader.Read() && tbl.Rows.Count < query.RecordCount)
{
reader.GetValues(values);
var rowValues = new object[tbl.Columns.Count];
for (int i = 0; i < reader.FieldCount; i++)
{
rowValues[fieldIdxMapping[i]] = values[i];
}
var r = tbl.LoadDataRow(rowValues, LoadOption.Upsert);
r.AcceptChanges();
}
});
tbl.EndLoadData();
return(tbl);
}
else
{
return(LoadObjectTable(query, ds, dataClass));
}
}
// check for relation table
var relation = schema.FindRelationshipByID(query.Table.Name);
if (relation != null)
{
// matched
return(LoadRelationTable(query, ds));
}
return(UnderlyingDalc.Load(query, ds));
}
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);
}
