public EndPointInfo GetOrCreate(string EndPoint, IJetTransaction jetTransaction)
{
EndPointInfo resultInfo = null;
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("SELECT [ID] FROM {0} WHERE [EndPoint]=@EndPoint;", _EndPointTable.TableName);
oleDbCommand.Parameters.AddWithValue("@EndPoint", EndPoint);
using (OleDbDataReader reader = oleDbCommand.ExecuteReader(CommandBehavior.SingleRow))
{
if (!reader.HasRows)
{
resultInfo = this.Add(EndPoint, jetTransaction);
}
else
{
reader.Read();
int id = Convert.ToInt32(reader["ID"]);
resultInfo = new EndPointInfo(id, EndPoint);
}
}
return(resultInfo);
}
internal ISyncDigestTableAdapter CreateSyncDigestTableAdapter(IResourceKindTableAdapter resourceKindTableAdapter, IEndpointTableAdapter endpointTableAdapter)
{
ISyncDigestTable syncDigestTable = new SyncDigestTable(resourceKindTableAdapter.Table, endpointTableAdapter.Table);
using (IJetTransaction jetTransaction = _connProvider.GetTransaction(false))
{
// create the table
if (!JetHelpers.TableExists(syncDigestTable.TableName, jetTransaction))
{
syncDigestTable.CreateTable(jetTransaction);
jetTransaction.Commit();
}
else
{
// update the table
ITableFieldsUpdated tableFieldUpdater = syncDigestTable as ITableFieldsUpdated;
if (null != tableFieldUpdater)
{
tableFieldUpdater.UpdateFields(jetTransaction);
jetTransaction.Commit();
}
}
}
return(new SyncDigestTableAdapter(syncDigestTable, _context));
}
public void Load(IJetTransaction jetTransaction)
{
EndpointInfo[] allResourceKindInfos = _tableAdapter.GetAll(jetTransaction);
foreach (EndpointInfo info in allResourceKindInfos)
_cache.Add(info.Endpoint, info);
}
public bool Get(string resourceKind, Type type, out object applicationBookmark)
{
bool result = false;
applicationBookmark = null;
string assemblyQualifiedName = type.AssemblyQualifiedName;
IAppBookmarkTableAdapter appBookmarkTableAdapter = StoreEnvironment.Resolve <IAppBookmarkTableAdapter>(_context);
IResourceKindTableAdapter resourceKindTableAdapter = StoreEnvironment.Resolve <IResourceKindTableAdapter>(_context);
using (IJetTransaction jetTransaction = _jetConnectionProvider.GetTransaction(false))
{
ResourceKindInfo resourceKindInfo = resourceKindTableAdapter.GetOrCreate(resourceKind, jetTransaction);
byte[] blob;
string receivedAssemblyQualifiedName;
if (appBookmarkTableAdapter.Get(resourceKindInfo.Id, out blob, out receivedAssemblyQualifiedName, jetTransaction))
{
applicationBookmark = this.DeserializeBlob(blob, type); // use given type not the one stored
result = true;
}
jetTransaction.Commit();
}
return(result);
}
public bool Update(CorrelatedResSyncInfo info, IJetTransaction jetTransaction)
{
IEndPointTableAdapter EndPointTableAdapter = StoreEnvironment.Resolve <IEndPointTableAdapter>(this.Context);
EndPointInfo EndPointInfo = EndPointTableAdapter.GetOrCreate(info.ResSyncInfo.EndPoint, jetTransaction);
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
// store only correlation data if tick is set to -1
if (info.ResSyncInfo.Tick == -1)
{
sqlQuery = "UPDATE [{0}] SET [LocalId]=@LocalId WHERE (Uuid=@Uuid);";
oleDbCommand.CommandText = string.Format(sqlQuery, _correlatedResSyncTable.TableName);
oleDbCommand.Parameters.AddWithValue("@LocalId", info.LocalId);
oleDbCommand.Parameters.AddWithValue("@Uuid", info.ResSyncInfo.Uuid);
}
else
{
sqlQuery = "UPDATE [{0}] SET [tick]=@tick, [ModifiedStamp]=@ModifiedStamp, [Etag]=@Etag, [LocalId]=@LocalId , [FKEndPointId]=@EndPointId WHERE (Uuid=@Uuid);";
oleDbCommand.CommandText = string.Format(sqlQuery, _correlatedResSyncTable.TableName);
oleDbCommand.Parameters.AddWithValue("@tick", info.ResSyncInfo.Tick);
oleDbCommand.Parameters.AddWithValue("@ModifiedStamp", info.ResSyncInfo.ModifiedStamp.ToString());
oleDbCommand.Parameters.AddWithValue("@Etag", info.ResSyncInfo.Etag);
oleDbCommand.Parameters.AddWithValue("@LocalId", info.LocalId);
oleDbCommand.Parameters.AddWithValue("@EndPointId", EndPointInfo.Id);
oleDbCommand.Parameters.AddWithValue("@Uuid", info.ResSyncInfo.Uuid);
}
return(0 != oleDbCommand.ExecuteNonQuery());
}
public void Delete(IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("DELETE FROM {0};", _syncResultsTable.TableName);
oleDbCommand.ExecuteNonQuery();
}
public CorrelatedResSyncInfo[] GetAll(IJetTransaction jetTransaction)
{
List<CorrelatedResSyncInfo> resultInfos = new List<CorrelatedResSyncInfo>();
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "SELECT {0}.Uuid, {0}.Tick, {0}.ModifiedStamp, {0}.Etag, {0}.LocalId, {1}.Endpoint FROM {1} INNER JOIN {0} ON {1}.ID = {0}.FKEndpointId WHERE ((({0}.FKResourceKindId)=@ResourceKindId));";
//sqlQuery = "SELECT {0}.Uuid, {0}.Tick, {0}.ModifiedStamp, {0}.Etag, {1}.Endpoint, {2}.LocalId FROM {2} INNER JOIN ({1} INNER JOIN {0} ON {1}.ID = {0}.FKEndpointId) ON {2}.Uuid = {0}.Uuid WHERE ((({0}.FKResourceKindId)=@ResourceKindId));";
oleDbCommand.CommandText = string.Format(sqlQuery, _correlatedResSyncTable.TableName, _correlatedResSyncTable.EndpointTable.TableName);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", _correlatedResSyncTable.ResourceKindId);
OleDbDataReader reader = oleDbCommand.ExecuteReader();
string tmpLocalId;
Guid tmpUuid;
string tmpEndpoint;
int tmpTick;
string tmpEtag;
DateTime tmpModifiedStamp;
while (reader.Read())
{
tmpLocalId = Convert.ToString(reader["LocalId"]);
tmpUuid = new Guid(Convert.ToString(reader["Uuid"]));
tmpEndpoint = Convert.ToString(reader["Endpoint"]);
tmpTick = Convert.ToInt32(reader["Tick"]);
tmpEtag = Convert.ToString(reader["Etag"]);
tmpModifiedStamp = Convert.ToDateTime(reader["ModifiedStamp"]);
resultInfos.Add(new CorrelatedResSyncInfo(tmpLocalId, new ResSyncInfo(tmpUuid, tmpEndpoint, tmpTick, tmpEtag, tmpModifiedStamp)));
}
return resultInfos.ToArray();
}
public ResourceKindInfo GetOrCreate(string resourceKind, IJetTransaction jetTransaction)
{
ResourceKindInfo resourceKindInfo = null;
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("SELECT [ID] FROM {0} WHERE [Name]=@Name;", _resourceKindTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Name", resourceKind);
OleDbDataReader reader = oleDbCommand.ExecuteReader(CommandBehavior.SingleRow);
if (!reader.HasRows)
{
resourceKindInfo = this.Add(resourceKind, jetTransaction);
}
else
{
reader.Read();
int id = Convert.ToInt32(reader["ID"]);
resourceKindInfo = new ResourceKindInfo(id, resourceKind);
}
return(resourceKindInfo);
}
public SyncDigestInfo Get(int resourceKindId, IJetTransaction jetTransaction)
{
SyncDigestInfo resultInfo = new SyncDigestInfo();
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "SELECT {0}.Tick, {0}.ConflictPriority, {0}.Stamp, {1}.EndPoint FROM {1} INNER JOIN {0} ON {1}.ID={0}.FKEndPointId WHERE ((({0}.FKResourceKindId)=@ResourceKindId));";
oleDbCommand.CommandText = string.Format(sqlQuery, _syncDigestTable.TableName, _syncDigestTable.EndPointTable.TableName);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
using (OleDbDataReader reader = oleDbCommand.ExecuteReader(CommandBehavior.Default))
{
while (reader.Read())
{
string EndPoint;
int tick;
int conflictPriority;
DateTime stamp;
EndPoint = Convert.ToString(reader["EndPoint"]);
tick = Convert.ToInt32(reader["tick"]);
conflictPriority = Convert.ToInt32(reader["ConflictPriority"]);
stamp = Convert.ToDateTime(reader["Stamp"]);
resultInfo.Add(new SyncDigestEntryInfo(EndPoint, tick, conflictPriority, stamp));
}
}
return(resultInfo);
}
public void Add(string resourceKind, SyncDigestEntryInfo info)
{
ISyncDigestTableAdapter syncDigestTableAdapter = StoreEnvironment.Resolve <ISyncDigestTableAdapter>(_context);
IResourceKindTableAdapter resourceKindTableAdapter = StoreEnvironment.Resolve <IResourceKindTableAdapter>(_context);
using (IJetTransaction jetTransaction = _jetConnectionProvider.GetTransaction(false))
{
ResourceKindInfo resourceKindInfo = resourceKindTableAdapter.GetOrCreate(resourceKind, jetTransaction);
try
{
syncDigestTableAdapter.Insert(resourceKindInfo.Id, new SyncDigestEntryInfo[] { info }, jetTransaction);
}
catch (OleDbException exception)
{
if (exception.Errors.Count == 1 && exception.Errors[0].SQLState == "3022")
{
throw new StoreException(string.Format("An error occured while adding a new sync digest entry. A sync digest entry already exists for the resource kind '{0}' and EndPoint '{1}.", resourceKind, info.EndPoint), exception);
}
throw;
}
jetTransaction.Commit();
}
}
private ResourceKindInfo Add(string resourceKind, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("INSERT INTO [{0}] ([Name]) VALUES (@Name);", _resourceKindTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Name", resourceKind);
try
{
oleDbCommand.ExecuteNonQuery();
}
catch (OleDbException exception)
{
if (exception.Errors.Count == 1 && exception.Errors[0].SQLState == "3022")
{
throw new StoreException("An error occured while adding a new resource kind. The resourcekind already exists for the resource kind '{0}'.", exception);
}
throw;
}
oleDbCommand.Parameters.Clear();
oleDbCommand.CommandText = string.Format("SELECT @@IDENTITY FROM [{0}];", _resourceKindTable.TableName);
oleDbCommand.CommandType = CommandType.Text;
int newId = (int)oleDbCommand.ExecuteScalar();
return(new ResourceKindInfo(newId, resourceKind));
}
public SyncDigestEntryInfo Get(int resourceKindId, int EndPointId, IJetTransaction jetTransaction)
{
SyncDigestEntryInfo resultInfo = null;
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "SELECT {0}.Tick, {0}.ConflictPriority, {0}.Stamp, {1}.EndPoint FROM {1} INNER JOIN {0} ON {1}.ID={0}.FKEndPointId " +
"WHERE ({0}.FKResourceKindId)=@ResourceKindId " +
"AND ({0}.FKEndPointId)=@EndPointId;";
oleDbCommand.CommandText = string.Format(sqlQuery, _syncDigestTable.TableName, _syncDigestTable.EndPointTable.TableName);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
oleDbCommand.Parameters.AddWithValue("@EndPointId", EndPointId);
using (OleDbDataReader reader = oleDbCommand.ExecuteReader(CommandBehavior.Default))
{
if (reader.Read())
{
string EndPoint;
int tick;
int conflictPriority;
DateTime stamp;
EndPoint = Convert.ToString(reader["EndPoint"]);
tick = Convert.ToInt32(reader["tick"]);
conflictPriority = Convert.ToInt32(reader["ConflictPriority"]);
stamp = Convert.ToDateTime(reader["Stamp"]);
resultInfo = new SyncDigestEntryInfo(EndPoint, tick, conflictPriority, stamp);
}
}
return resultInfo;
}
public void Insert(SyncResultEntryInfo[] infos, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "INSERT INTO {0} ([HttpMethod], [HttpStatus], [HttpMessage], [HttpLocation], [Diagnoses], [Payload], [Endpoint], [Stamp]) VALUES (@HttpMethod, @HttpStatus, @HttpMessage, @HttpLocation, @Diagnoses, @Payload, @Endpoint, @Stamp);";
oleDbCommand.CommandText = string.Format(sqlQuery, _syncResultsTable.TableName);
foreach (SyncResultEntryInfo info in infos)
{
// TODO: Use prepared query
//oleDbCommand.Parameters.Clear();
oleDbCommand.Parameters.AddWithValue("@HttpMethod", info.HttpMethod);
oleDbCommand.Parameters.AddWithValue("@HttpStatus", info.HttpStatus);
if (null != info.HttpMessage) oleDbCommand.Parameters.AddWithValue("@HttpMessage", info.HttpMessage);
else oleDbCommand.Parameters.AddWithValue("@HttpMessage", DBNull.Value);
if (null != info.HttpLocation) oleDbCommand.Parameters.AddWithValue("@HttpLocation", info.HttpLocation);
else oleDbCommand.Parameters.AddWithValue("@HttpLocation", DBNull.Value);
if (null != info.DiagnosisXml) oleDbCommand.Parameters.AddWithValue("@Diagnoses", info.DiagnosisXml);
else oleDbCommand.Parameters.AddWithValue("@Diagnoses", DBNull.Value);
if (null != info.PayloadXml) oleDbCommand.Parameters.AddWithValue("@Payload", info.PayloadXml);
else oleDbCommand.Parameters.AddWithValue("@Payload", DBNull.Value);
oleDbCommand.Parameters.AddWithValue("@Endpoint", info.Endpoint);
oleDbCommand.Parameters.AddWithValue("@Stamp", info.Stamp.ToString());
oleDbCommand.ExecuteNonQuery();
}
}
internal IEndpointTableAdapter CreateEndpointTableAdapter()
{
IEndpointTable endpointTable = new EndpointTable();
using (IJetTransaction jetTransaction = _connProvider.GetTransaction(false))
{
if (!JetHelpers.TableExists(endpointTable.TableName, jetTransaction))
{
endpointTable.CreateTable(jetTransaction);
jetTransaction.Commit();
}
}
IEndpointTableAdapter endpointTableAdapter = new EndpointTableAdapter(endpointTable, _context);
using (IJetTransaction jetTransaction = _connProvider.GetTransaction(false))
{
endpointTableAdapter.SetOriginEndPoint(_context.BaseUrl, jetTransaction);
jetTransaction.Commit();
}
return(endpointTableAdapter);
//CachedEndpointTableAdapter cachedEndpointTableAdapter = new CachedEndpointTableAdapter(endpointTableAdapter);
//using (IJetTransaction jetTransaction = _connProvider.GetTransaction(false))
//{
// cachedEndpointTableAdapter.Load(jetTransaction);
// jetTransaction.Commit();
//}
//return cachedEndpointTableAdapter;
}
internal int CreateNexttick(string resourceKind)
{
int nexttick;
int currenttick;
ItickTableAdapter tickTableAdapter = StoreEnvironment.Resolve <ItickTableAdapter>(_context);
IResourceKindTableAdapter resourceKindTableAdapter = StoreEnvironment.Resolve <IResourceKindTableAdapter>(_context);
using (IJetTransaction jetTransaction = _jetConnectionProvider.GetTransaction(false))
{
ResourceKindInfo resourceKindInfo = resourceKindTableAdapter.GetOrCreate(resourceKind, jetTransaction);
if (!tickTableAdapter.TryGet(resourceKindInfo.Id, out currenttick, jetTransaction))
{
currenttick = STARTtick;
tickTableAdapter.Insert(resourceKindInfo.Id, currenttick, jetTransaction);
nexttick = currenttick;
}
else
{
currenttick++;
tickTableAdapter.Update(resourceKindInfo.Id, currenttick, jetTransaction);
nexttick = currenttick;
}
jetTransaction.Commit();
}
return(nexttick);
}
public EndPointInfo GetOrCreate(string EndPoint, IJetTransaction jetTransaction)
{
EndPointInfo resultInfo = null;
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("SELECT [ID] FROM {0} WHERE [EndPoint]=@EndPoint;", _EndPointTable.TableName);
oleDbCommand.Parameters.AddWithValue("@EndPoint", EndPoint);
using (OleDbDataReader reader = oleDbCommand.ExecuteReader(CommandBehavior.SingleRow))
{
if (!reader.HasRows)
{
resultInfo = this.Add(EndPoint, jetTransaction);
}
else
{
reader.Read();
int id = Convert.ToInt32(reader["ID"]);
resultInfo = new EndPointInfo(id, EndPoint);
}
}
return resultInfo;
}
public ResourceKindInfo GetOrCreate(string resourceKind, IJetTransaction jetTransaction)
{
ResourceKindInfo resourceKindInfo = null;
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("SELECT [ID] FROM {0} WHERE [Name]=@Name;", _resourceKindTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Name", resourceKind);
using (OleDbDataReader reader = oleDbCommand.ExecuteReader(CommandBehavior.SingleRow))
{
if (!reader.HasRows)
{
resourceKindInfo = this.Add(resourceKind, jetTransaction);
}
else
{
reader.Read();
int id = Convert.ToInt32(reader["ID"]);
resourceKindInfo = new ResourceKindInfo(id, resourceKind);
}
}
return resourceKindInfo;
}
internal IResourceKindTableAdapter CreateResourceKindTableAdapter()
{
IResourceKindTable resourceKindTable = new ResourceKindTable();
using (IJetTransaction jetTransaction = _connProvider.GetTransaction(false))
{
if (!JetHelpers.TableExists(resourceKindTable.TableName, jetTransaction))
{
resourceKindTable.CreateTable(jetTransaction);
jetTransaction.Commit();
}
}
IResourceKindTableAdapter resourceKindTableAdapter = new ResourceKindTableAdapter(resourceKindTable, _context);
return(resourceKindTableAdapter);
//CachedResourceKindTableAdapter cachedResourceKindTableAdapter = new CachedResourceKindTableAdapter(resourceKindTableAdapter);
//using (IJetTransaction jetTransaction = _connProvider.GetTransaction(false))
//{
// cachedResourceKindTableAdapter.Load(jetTransaction);
// jetTransaction.Commit();
//}
//return cachedResourceKindTableAdapter;
}
public void Add(string resourceKind, object applicationBookmark)
{
string assemblyQualifiedName = applicationBookmark.GetType().AssemblyQualifiedName;
object blob = this.SerializeApplicationBookmark(applicationBookmark);
IAppBookmarkTableAdapter appBookmarkTableAdapter = StoreEnvironment.Resolve <IAppBookmarkTableAdapter>(_context);
IResourceKindTableAdapter resourceKindTableAdapter = StoreEnvironment.Resolve <IResourceKindTableAdapter>(_context);
using (IJetTransaction jetTransaction = _jetConnectionProvider.GetTransaction(false))
{
ResourceKindInfo resourceKindInfo = resourceKindTableAdapter.GetOrCreate(resourceKind, jetTransaction);
try
{
appBookmarkTableAdapter.Insert(resourceKindInfo.Id, blob, assemblyQualifiedName, jetTransaction);
}
catch (OleDbException exception)
{
if (exception.Errors.Count == 1 && exception.Errors[0].SQLState == "3022")
{
throw new StoreException(string.Format("An error occured while adding a new application bookmark. An application bookmark already exists for the resource kind '{0}'.", resourceKind), exception);
}
throw;
}
jetTransaction.Commit();
}
}
public void Delete(int resourceKindId, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("DELETE FROM {0} WHERE [FKResourceKindId] = @ResourceKindId", _appBookmarkTable.TableName);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
oleDbCommand.ExecuteNonQuery();
}
public bool Get(int resourceKindId, out byte[] applicationBookmark, out string assemblyQualifiedName, IJetTransaction jetTransaction)
{
applicationBookmark = null;
assemblyQualifiedName = null;
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "SELECT [Type], [Value] FROM {0} WHERE [FKResourceKindId] = @ResourceKindId";
oleDbCommand.CommandText = string.Format(sqlQuery, _appBookmarkTable.TableName);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
OleDbDataReader reader = oleDbCommand.ExecuteReader(CommandBehavior.SingleRow | CommandBehavior.SequentialAccess);
if (!reader.HasRows)
return false;
reader.Read(); // only one row accepted
assemblyQualifiedName = Convert.ToString(reader["Type"]);
applicationBookmark = JetHelpers.ReadBlob(reader, 1);
return true;
}
public void Delete(int resourceKindId, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("DELETE FROM {0} WHERE [FKResourceKindId] = @ResourceKindId", _appBookmarkTable.TableName);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
oleDbCommand.ExecuteNonQuery();
}
public void Remove(Guid uuid, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("DELETE FROM {0} WHERE [Uuid] = @Uuid", _correlatedResSyncTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Uuid", uuid);
oleDbCommand.ExecuteNonQuery();
}
public void Load(IJetTransaction jetTransaction)
{
EndpointInfo[] allResourceKindInfos = _tableAdapter.GetAll(jetTransaction);
foreach (EndpointInfo info in allResourceKindInfos)
{
_cache.Add(info.Endpoint, info);
}
}
public void CreateTable(IJetTransaction oleDbTransaction)
{
OleDbCommand command = oleDbTransaction.CreateOleCommand();
foreach (string sqlQuery in _sqlQueries)
{
command.CommandText = sqlQuery;
command.ExecuteNonQuery();
}
}
public void CreateTable(IJetTransaction oleDbTransaction)
{
OleDbCommand command = oleDbTransaction.CreateOleCommand();
foreach (string sqlQuery in _sqlQueries)
{
command.CommandText = sqlQuery;
command.ExecuteNonQuery();
}
}
public void Insert(SyncResultEntryInfo[] infos, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "INSERT INTO {0} ([HttpMethod], [HttpStatus], [HttpMessage], [HttpLocation], [Diagnoses], [Payload], [Endpoint], [Stamp]) VALUES (@HttpMethod, @HttpStatus, @HttpMessage, @HttpLocation, @Diagnoses, @Payload, @Endpoint, @Stamp);";
oleDbCommand.CommandText = string.Format(sqlQuery, _syncResultsTable.TableName);
foreach (SyncResultEntryInfo info in infos)
{
// TODO: Use prepared query
//oleDbCommand.Parameters.Clear();
oleDbCommand.Parameters.AddWithValue("@HttpMethod", info.HttpMethod);
oleDbCommand.Parameters.AddWithValue("@HttpStatus", info.HttpStatus);
if (null != info.HttpMessage)
{
oleDbCommand.Parameters.AddWithValue("@HttpMessage", info.HttpMessage);
}
else
{
oleDbCommand.Parameters.AddWithValue("@HttpMessage", DBNull.Value);
}
if (null != info.HttpLocation)
{
oleDbCommand.Parameters.AddWithValue("@HttpLocation", info.HttpLocation);
}
else
{
oleDbCommand.Parameters.AddWithValue("@HttpLocation", DBNull.Value);
}
if (null != info.DiagnosisXml)
{
oleDbCommand.Parameters.AddWithValue("@Diagnoses", info.DiagnosisXml);
}
else
{
oleDbCommand.Parameters.AddWithValue("@Diagnoses", DBNull.Value);
}
if (null != info.PayloadXml)
{
oleDbCommand.Parameters.AddWithValue("@Payload", info.PayloadXml);
}
else
{
oleDbCommand.Parameters.AddWithValue("@Payload", DBNull.Value);
}
oleDbCommand.Parameters.AddWithValue("@Endpoint", info.Endpoint);
oleDbCommand.Parameters.AddWithValue("@Stamp", info.Stamp.ToString());
oleDbCommand.ExecuteNonQuery();
}
}
public ResourceKindInfo GetOrCreate(string resourceKind, IJetTransaction jetTransaction)
{
ResourceKindInfo info;
string contextName = jetTransaction.OleDbConnection.ConnectionString;
if (!_cache.TryGetValue(resourceKind, out info))
{
info = _tableAdapter.GetOrCreate(resourceKind, jetTransaction);
_cache.Add(resourceKind, info);
}
return info;
}
public EndpointInfo GetOrCreate(string endpoint, IJetTransaction jetTransaction)
{
EndpointInfo info;
string contextName = jetTransaction.OleDbConnection.ConnectionString;
if (!_cache.TryGetValue(endpoint, out info))
{
info = _tableAdapter.GetOrCreate(endpoint, jetTransaction);
_cache.Add(endpoint, info);
}
return info;
}
public void Add(string resourceKind, SyncResultEntryInfo[] syncResultEntryInfos)
{
ISyncResultsTableAdapter syncResultsTableAdapter = this.GetAdapter(resourceKind);
IResourceKindTableAdapter resourceKindTableAdapter = StoreEnvironment.Resolve <IResourceKindTableAdapter>(_context);
using (IJetTransaction jetTransaction = _jetConnectionProvider.GetTransaction(false))
{
syncResultsTableAdapter.Insert(syncResultEntryInfos, _runName, _runStamp, jetTransaction);
jetTransaction.Commit();
}
}
public EndpointInfo GetOrCreate(string endpoint, IJetTransaction jetTransaction)
{
EndpointInfo info;
string contextName = jetTransaction.OleDbConnection.ConnectionString;
if (!_cache.TryGetValue(endpoint, out info))
{
info = _tableAdapter.GetOrCreate(endpoint, jetTransaction);
_cache.Add(endpoint, info);
}
return(info);
}
public ResourceKindInfo GetOrCreate(string resourceKind, IJetTransaction jetTransaction)
{
ResourceKindInfo info;
string contextName = jetTransaction.OleDbConnection.ConnectionString;
if (!_cache.TryGetValue(resourceKind, out info))
{
info = _tableAdapter.GetOrCreate(resourceKind, jetTransaction);
_cache.Add(resourceKind, info);
}
return(info);
}
public void Insert(int resourceKindId, int tick, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "INSERT INTO [{0}] ([Tick], [FKResourceKindId]) VALUES (@Tick, @ResourceKindId);";
oleDbCommand.CommandText = string.Format(sqlQuery, _tickTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Tick", tick);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
oleDbCommand.ExecuteNonQuery();
}
public void Update(string resourceKind, CorrelatedResSyncInfo info)
{
ICorrelatedResSyncTableAdapter correlatedResSyncTableAdapter = this.GetAdapter(resourceKind);
using (IJetTransaction jetTransaction = _jetConnectionProvider.GetTransaction(false))
{
if (!correlatedResSyncTableAdapter.Update(info, jetTransaction))
{
throw new StoreException(string.Format("No correlated ResSync exists for the resource kind '{0}' that can be updated.", resourceKind));
}
jetTransaction.Commit();
}
}
public CorrelatedResSyncInfo[] GetByLocalId(string[] localIds, IJetTransaction jetTransaction)
{
List <CorrelatedResSyncInfo> resultInfos = new List <CorrelatedResSyncInfo>();
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string localIdsParameterValue = string.Empty;
for (int i = 0; i < localIds.Length; i++)
{
localIdsParameterValue += localIds[i] + ",";
}
// remove last ','
localIdsParameterValue = localIdsParameterValue.Remove(localIdsParameterValue.Length - 1);
string sqlQuery = string.Empty;
sqlQuery = "SELECT {0}.Uuid, {0}.Tick, {0}.ModifiedStamp, {0}.Etag, {0}.LocalId, {1}.EndPoint FROM {1} INNER JOIN {0} ON {1}.ID = {0}.FKEndPointId WHERE ((({0}.LocalId) IN (@LocalIds)) AND (({0}.FKResourceKindId)=@ResourceKindId))";
//sqlQuery = "SELECT {0}.Uuid, {0}.Tick, {0}.ModifiedStamp, {0}.Etag, {1}.EndPoint, {2}.LocalId FROM {2} INNER JOIN ({1} INNER JOIN {0} ON {1}.ID = {0}.FKEndPointId) ON {2}.Uuid = {0}.Uuid WHERE ((({2}.LocalId) IN (@LocalIds)) AND (({0}.FKResourceKindId)=@ResourceKindId));";
oleDbCommand.CommandText = string.Format(sqlQuery, _correlatedResSyncTable.TableName, _correlatedResSyncTable.EndPointTable.TableName);
oleDbCommand.Parameters.AddWithValue("@LocalIds", localIdsParameterValue);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", _correlatedResSyncTable.ResourceKindId);
using (OleDbDataReader reader = oleDbCommand.ExecuteReader())
{
string tmpLocalId;
Guid tmpUuid;
string tmpEndPoint;
int tmptick;
string tmpEtag;
DateTime tmpModifiedStamp;
while (reader.Read())
{
tmpLocalId = Convert.ToString(reader["LocalId"]);
tmpUuid = new Guid(Convert.ToString(reader["Uuid"]));
tmpEndPoint = Convert.ToString(reader["EndPoint"]);
tmptick = Convert.ToInt32(reader["tick"]);
tmpEtag = Convert.ToString(reader["Etag"]);
tmpModifiedStamp = Convert.ToDateTime(reader["ModifiedStamp"]);
resultInfos.Add(new CorrelatedResSyncInfo(tmpLocalId, new ResSyncInfo(tmpUuid, tmpEndPoint, tmptick, tmpEtag, tmpModifiedStamp)));
}
}
return(resultInfos.ToArray());
}
public void Update(int resourceKindId, int tick, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "UPDATE [{0}] SET [tick]=@tick WHERE (FKResourceKindId=@ResourceKindId);";
oleDbCommand.CommandText = string.Format(sqlQuery, _tickTable.TableName);
oleDbCommand.Parameters.AddWithValue("@tick", tick);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
oleDbCommand.ExecuteNonQuery();
}
public void Insert(int resourceKindId, int tick, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "INSERT INTO [{0}] ([tick], [FKResourceKindId]) VALUES (@tick, @ResourceKindId);";
oleDbCommand.CommandText = string.Format(sqlQuery, _tickTable.TableName);
oleDbCommand.Parameters.AddWithValue("@tick", tick);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
oleDbCommand.ExecuteNonQuery();
}
public void Insert(int resourceKindId, object applicationBookmark, string assemblyQualifiedName, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "INSERT INTO {0} ([Type], [Value], [FKResourceKindId]) VALUES (@Type, @Value, @ResourceKindId);";
oleDbCommand.CommandText = string.Format(sqlQuery, _appBookmarkTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Type", assemblyQualifiedName);
oleDbCommand.Parameters.AddWithValue("@Value", applicationBookmark);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
oleDbCommand.ExecuteNonQuery();
}
internal ITickTableAdapter CreateTickTableAdapter(IResourceKindTableAdapter resourceKindTableAdapter)
{
ITickTable tickTable = new TickTable(resourceKindTableAdapter.Table);
using (IJetTransaction jetTransaction = _connProvider.GetTransaction(false))
{
if (!JetHelpers.TableExists(tickTable.TableName, jetTransaction))
{
tickTable.CreateTable(jetTransaction);
jetTransaction.Commit();
}
}
return(new TickTableAdapter(tickTable, _context));
}
public CorrelatedResSyncInfo[] GetByUuid(string resourceKind, Guid[] uuids)
{
CorrelatedResSyncInfo[] resultInfos;
ICorrelatedResSyncTableAdapter correlatedResSyncTableAdapter = this.GetAdapter(resourceKind);
using (IJetTransaction jetTransaction = _jetConnectionProvider.GetTransaction(false))
{
resultInfos = correlatedResSyncTableAdapter.GetByUuids(uuids, jetTransaction);
jetTransaction.Commit();
}
return((null != resultInfos) ? resultInfos : new CorrelatedResSyncInfo[0]);
}
public ICorrelatedResSyncInfoEnumerator GetAll(string resourceKind)
{
CorrelatedResSyncInfo[] resultInfos;
ICorrelatedResSyncTableAdapter correlatedResSyncTableAdapter = this.GetAdapter(resourceKind);
using (IJetTransaction jetTransaction = _jetConnectionProvider.GetTransaction(false))
{
resultInfos = correlatedResSyncTableAdapter.GetAll(jetTransaction);
jetTransaction.Commit();
}
return((null != resultInfos) ? new CorrelatedResSyncInfoEnumerator(resultInfos) : new CorrelatedResSyncInfoEnumerator(new CorrelatedResSyncInfo[0]));
}
/*
* public void Update(string resourceKind, SyncDigestInfo info)
* {
* ISyncDigestTableAdapter syncDigestTableAdapter = StoreEnvironment.Resolve<ISyncDigestTableAdapter>(_context);
* IResourceKindTableAdapter resourceKindTableAdapter = StoreEnvironment.Resolve<IResourceKindTableAdapter>(_context);
*
* using (IJetTransaction jetTransaction = _jetConnectionProvider.GetTransaction(false))
* {
* ResourceKindInfo resourceKindInfo = resourceKindTableAdapter.GetOrCreate(resourceKind, jetTransaction);
*
* try
* {
* syncDigestTableAdapter.Update(resourceKindInfo.Id, info.ToArray(), jetTransaction);
* }
* catch (StoreException exception)
* {
* throw new StoreException(string.Format("An error occured while updating a sync digest entry. No sync digest entry exists for the resource kind '{0}'.", resourceKind), exception);
* }
* jetTransaction.Commit();
* }
* }
*/
public bool Update(string resourceKind, SyncDigestEntryInfo info)
{
bool result = false;
ISyncDigestTableAdapter syncDigestTableAdapter = StoreEnvironment.Resolve <ISyncDigestTableAdapter>(_context);
IResourceKindTableAdapter resourceKindTableAdapter = StoreEnvironment.Resolve <IResourceKindTableAdapter>(_context);
using (IJetTransaction jetTransaction = _jetConnectionProvider.GetTransaction(false))
{
ResourceKindInfo resourceKindInfo = resourceKindTableAdapter.GetOrCreate(resourceKind, jetTransaction);
result = syncDigestTableAdapter.Update(resourceKindInfo.Id, info, jetTransaction);
jetTransaction.Commit();
}
return(result);
}
public SyncDigestInfo Get(string resourceKind)
{
SyncDigestInfo resultInfo = null;
ISyncDigestTableAdapter syncDigestTableAdapter = StoreEnvironment.Resolve <ISyncDigestTableAdapter>(_context);
IResourceKindTableAdapter resourceKindTableAdapter = StoreEnvironment.Resolve <IResourceKindTableAdapter>(_context);
using (IJetTransaction jetTransaction = _jetConnectionProvider.GetTransaction(false))
{
ResourceKindInfo resourceKindInfo = resourceKindTableAdapter.GetOrCreate(resourceKind, jetTransaction);
resultInfo = syncDigestTableAdapter.Get(resourceKindInfo.Id, jetTransaction);
jetTransaction.Commit();
}
return(resultInfo);
}
public static bool TableExists(string tableName, IJetTransaction transaction)
{
string sql = string.Format("SELECT COUNT(*) FROM {0};", tableName);
OleDbCommand oleDbCmd = transaction.CreateOleCommand();
oleDbCmd.CommandText = sql;
oleDbCmd.CommandType = CommandType.Text;
try
{
oleDbCmd.ExecuteNonQuery();
}
catch (OleDbException)
{
return false;
}
return true;
}
public EndpointInfo[] GetAll(IJetTransaction jetTransaction)
{
List<EndpointInfo> resultInfos = new List<EndpointInfo>();
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("SELECT [ID], [Endpoint] FROM {0};", _endpointTable.TableName);
OleDbDataReader reader = oleDbCommand.ExecuteReader();
int tmpId;
string tmpEndpoint;
while(reader.Read())
{
tmpId = Convert.ToInt32(reader["ID"]);
tmpEndpoint = Convert.ToString(reader["Endpoint"]);
resultInfos.Add(new EndpointInfo(tmpId, tmpEndpoint));
}
return resultInfos.ToArray();
}
public ResourceKindInfo[] GetAll(IJetTransaction jetTransaction)
{
List<ResourceKindInfo> resultInfos = new List<ResourceKindInfo>();
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("SELECT [ID], [Name] FROM {0};", _resourceKindTable.TableName);
using (OleDbDataReader reader = oleDbCommand.ExecuteReader())
{
int tmpId;
string tmpName;
while (reader.Read())
{
tmpId = Convert.ToInt32(reader["ID"]);
tmpName = Convert.ToString(reader["Name"]);
resultInfos.Add(new ResourceKindInfo(tmpId, tmpName));
}
}
return resultInfos.ToArray();
}
void ITableFieldsUpdated.UpdateFields(IJetTransaction jetTransaction)
{
// CHECK IF COLUMN EXISTS
bool rowStampExists = false;
string[] restrictions = new string[] { null, null, this.TableName, null };
System.Data.DataTable DataTable1 = jetTransaction.OleDbConnection.GetSchema("Columns", restrictions);
string restriction = string.Format("[TABLE_NAME]='{0}'", this.TableName);
DataRow[] rows = jetTransaction.OleDbConnection.GetSchema("Columns").Select(restriction);
if (null == rows || rows.Length == 0)
throw new StoreException("Cannot update table '{0}'. The column names cannot be requested.");
foreach (DataRow dataRow in rows)
{
if (Convert.ToString(dataRow["COLUMN_NAME"]) == "Stamp")
{
rowStampExists = true;
break;
}
}
// ADD COLUMN AND VALUES
if (!rowStampExists)
{
OleDbCommand command = jetTransaction.CreateOleCommand();
string sql = string.Format("ALTER TABLE [{0}] ADD COLUMN [Stamp] TIMESTAMP NOT NULL", this.TableName);
command.CommandText = sql;
command.ExecuteNonQuery();
sql = "UPDATE [{0}] SET [Stamp]=@Stamp;";
command.CommandText = string.Format(sql, this.TableName);
command.Parameters.AddWithValue("@Stamp", DateTime.Now.ToString());
command.ExecuteNonQuery();
}
}
public bool TryGet(int resourceKindId, out int tick, IJetTransaction jetTransaction)
{
tick = int.MinValue;
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "SELECT [FKResourceKindId], [Tick] FROM {0} WHERE ([FKResourceKindId]=@ResourceKindId);";
oleDbCommand.CommandText = string.Format(sqlQuery, _tickTable.TableName);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
OleDbDataReader reader = oleDbCommand.ExecuteReader(CommandBehavior.SingleRow);
if (reader.Read())
{
tick = Convert.ToInt32(reader["Tick"]);
return true;
}
return false;
}
public void SetOriginEndPoint(string endPointBaseUrl, IJetTransaction jetTransaction)
{
List<EndpointInfo> updateInfos = new List<EndpointInfo>();
if (String.IsNullOrEmpty(endPointBaseUrl))
return;
if (!endPointBaseUrl.EndsWith("/"))
endPointBaseUrl += "/";
string localHost = "localhost/";
OleDbCommand selectCommand = jetTransaction.CreateOleCommand();
selectCommand.CommandText = string.Format(@"SELECT [ID], Endpoint FROM {0} WHERE (((Endpoint) Like ""{1}%""));", _endpointTable.TableName, localHost);
OleDbDataReader reader = selectCommand.ExecuteReader();
int tmpId;
string tmpEndpoint;
while (reader.Read())
{
tmpId = Convert.ToInt32(reader["ID"]);
tmpEndpoint = Convert.ToString(reader["Endpoint"]);
tmpEndpoint = tmpEndpoint.Replace(localHost, endPointBaseUrl);
updateInfos.Add(new EndpointInfo(tmpId, tmpEndpoint));
}
foreach (EndpointInfo info in updateInfos)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("UPDATE {0} SET [Endpoint] = @Endpoint WHERE [ID]=@ID;", _endpointTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Endpoint", info.Endpoint);
oleDbCommand.Parameters.AddWithValue("@ID", info.Id);
oleDbCommand.ExecuteNonQuery();
}
}
public void Update(int resourceKindId, int tick, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "UPDATE [{0}] SET [Tick]=@Tick WHERE (FKResourceKindId=@ResourceKindId);";
oleDbCommand.CommandText = string.Format(sqlQuery, _tickTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Tick", tick);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
oleDbCommand.ExecuteNonQuery();
}
public void Insert(CorrelatedResSyncInfo info, IJetTransaction jetTransaction)
{
IEndpointTableAdapter endpointTableAdapter = StoreEnvironment.Resolve<IEndpointTableAdapter>(this.Context);
EndpointInfo endpointInfo = endpointTableAdapter.GetOrCreate(info.ResSyncInfo.Endpoint, jetTransaction);
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "INSERT INTO {0} ([Uuid], [Tick], [ModifiedStamp], [Etag], [LocalId], [FKEndpointId], [FKResourceKindId]) VALUES (@Uuid, @Tick, @ModifiedStamp, @Etag, @LocalId, @EndpointId, @ResourceKindId);";
oleDbCommand.CommandText = string.Format(sqlQuery, _correlatedResSyncTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Uuid", info.ResSyncInfo.Uuid);
oleDbCommand.Parameters.AddWithValue("@Tick", info.ResSyncInfo.Tick);
oleDbCommand.Parameters.AddWithValue("@ModifiedStamp", info.ResSyncInfo.ModifiedStamp.ToString());
oleDbCommand.Parameters.AddWithValue("@Etag", info.ResSyncInfo.Etag);
oleDbCommand.Parameters.AddWithValue("@LocalId", info.LocalId);
oleDbCommand.Parameters.AddWithValue("@EndpointId", endpointInfo.Id);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", _correlatedResSyncTable.ResourceKindId);
oleDbCommand.ExecuteNonQuery();
}
public void Remove(Guid uuid, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("DELETE FROM {0} WHERE [Uuid] = @Uuid", _correlatedResSyncTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Uuid", uuid);
oleDbCommand.ExecuteNonQuery();
}
public bool Update(CorrelatedResSyncInfo info, IJetTransaction jetTransaction)
{
IEndpointTableAdapter endpointTableAdapter = StoreEnvironment.Resolve<IEndpointTableAdapter>(this.Context);
EndpointInfo endpointInfo = endpointTableAdapter.GetOrCreate(info.ResSyncInfo.Endpoint, jetTransaction);
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
string sqlQuery = string.Empty;
sqlQuery = "UPDATE [{0}] SET [Tick]=@Tick, [ModifiedStamp]=@ModifiedStamp, [Etag]=@Etag, [LocalId]=@LocalId , [FKEndpointId]=@EndpointId WHERE (Uuid=@Uuid);";
oleDbCommand.CommandText = string.Format(sqlQuery, _correlatedResSyncTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Tick", info.ResSyncInfo.Tick);
oleDbCommand.Parameters.AddWithValue("@ModifiedStamp", info.ResSyncInfo.ModifiedStamp.ToString());
oleDbCommand.Parameters.AddWithValue("@Etag", info.ResSyncInfo.Etag);
oleDbCommand.Parameters.AddWithValue("@LocalId", info.LocalId);
oleDbCommand.Parameters.AddWithValue("@EndpointId", endpointInfo.Id);
oleDbCommand.Parameters.AddWithValue("@Uuid", info.ResSyncInfo.Uuid);
return (0 != oleDbCommand.ExecuteNonQuery());
}
public bool Update(int resourceKindId, object applicationBookmark, string assemblyQualifiedName, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("UPDATE [{0}] SET [FKResourceKindId]=@ResourceKindId, [Type]=@Type, [Value]=@Value WHERE [FKResourceKindId]=@ResourceKindId;", _appBookmarkTable.TableName);
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
oleDbCommand.Parameters.AddWithValue("@Type", assemblyQualifiedName);
oleDbCommand.Parameters.AddWithValue("@Value", applicationBookmark);
return (0 != oleDbCommand.ExecuteNonQuery());
}
public void Insert(int resourceKindId, SyncDigestEntryInfo[] syncDigestEntryInfo, IJetTransaction jetTransaction)
{
IEndPointTableAdapter EndPointTableAdapter = StoreEnvironment.Resolve<IEndPointTableAdapter>(this.Context);
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
EndPointInfo tmpEndPointInfo;
string sqlQuery = string.Empty;
sqlQuery = "INSERT INTO [{0}] ([tick], [ConflictPriority], [Stamp], [FKResourceKindId], [FKEndPointId]) VALUES (@tick, @ConflictPriority, @Stamp, @ResourceKindId, @EndPointId);";
oleDbCommand.CommandText = string.Format(sqlQuery, _syncDigestTable.TableName);
foreach (SyncDigestEntryInfo info in syncDigestEntryInfo)
{
// TODO: Use prepared query
tmpEndPointInfo = EndPointTableAdapter.GetOrCreate(info.EndPoint, jetTransaction);
//oleDbCommand.Parameters.Clear();
oleDbCommand.Parameters.AddWithValue("@tick", info.Tick);
oleDbCommand.Parameters.AddWithValue("@ConflictPriority", info.ConflictPriority);
oleDbCommand.Parameters.AddWithValue("@Stamp", info.Stamp.ToString());
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
oleDbCommand.Parameters.AddWithValue("@EndPointId", tmpEndPointInfo.Id);
oleDbCommand.ExecuteNonQuery();
}
}
public bool Update(int resourceKindId, SyncDigestEntryInfo syncDigestEntryInfo, IJetTransaction jetTransaction)
{
IEndPointTableAdapter EndPointTableAdapter = StoreEnvironment.Resolve<IEndPointTableAdapter>(this.Context);
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
EndPointInfo tmpEndPointInfo;
string sqlQuery = string.Empty;
sqlQuery = "UPDATE [{0}] SET [tick]=@tick, [ConflictPriority]=@ConflictPriority, [Stamp]=@Stamp WHERE (FKResourceKindId=@ResourceKindId AND FKEndPointId=@EndPointId);";
oleDbCommand.CommandText = string.Format(sqlQuery, _syncDigestTable.TableName);
// TODO: Use prepared query
tmpEndPointInfo = EndPointTableAdapter.GetOrCreate(syncDigestEntryInfo.EndPoint, jetTransaction);
oleDbCommand.Parameters.AddWithValue("@tick", syncDigestEntryInfo.Tick);
oleDbCommand.Parameters.AddWithValue("@ConflictPriority", syncDigestEntryInfo.ConflictPriority);
oleDbCommand.Parameters.AddWithValue("@Stamp", syncDigestEntryInfo.Stamp.ToString());
oleDbCommand.Parameters.AddWithValue("@ResourceKindId", resourceKindId);
oleDbCommand.Parameters.AddWithValue("@EndPointId", tmpEndPointInfo.Id);
int count = oleDbCommand.ExecuteNonQuery();
return (count > 0);
}
private EndpointInfo Add(string endpoint, IJetTransaction jetTransaction)
{
EndpointInfo resultInfo = null;
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("INSERT INTO [{0}] ([Endpoint]) VALUES (@Endpoint);", _endpointTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Endpoint", endpoint);
oleDbCommand.ExecuteNonQuery();
oleDbCommand.Parameters.Clear();
oleDbCommand.CommandText = string.Format("SELECT @@IDENTITY FROM [{0}];", _endpointTable.TableName);
oleDbCommand.CommandType = CommandType.Text;
int newId = (int)oleDbCommand.ExecuteScalar();
resultInfo = new EndpointInfo(newId, endpoint);
return resultInfo;
}
private ResourceKindInfo Add(string resourceKind, IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("INSERT INTO [{0}] ([Name]) VALUES (@Name);", _resourceKindTable.TableName);
oleDbCommand.Parameters.AddWithValue("@Name", resourceKind);
try
{
oleDbCommand.ExecuteNonQuery();
}
catch (OleDbException exception)
{
if (exception.Errors.Count == 1 && exception.Errors[0].SQLState == "3022")
throw new StoreException("An error occured while adding a new resource kind. The resourcekind already exists for the resource kind '{0}'.", exception);
throw;
}
oleDbCommand.Parameters.Clear();
oleDbCommand.CommandText = string.Format("SELECT @@IDENTITY FROM [{0}];", _resourceKindTable.TableName);
oleDbCommand.CommandType = CommandType.Text;
int newId = (int)oleDbCommand.ExecuteScalar();
return new ResourceKindInfo(newId, resourceKind);
}
public void CreateTable(IJetTransaction oleDbTransaction)
{
_jetTableImp.CreateTable(oleDbTransaction);
}
public void Delete(IJetTransaction jetTransaction)
{
OleDbCommand oleDbCommand = jetTransaction.CreateOleCommand();
oleDbCommand.CommandText = string.Format("DELETE FROM {0};", _syncResultsTable.TableName);
oleDbCommand.ExecuteNonQuery();
}
