private object DeserializeQueuedEvent(SqlDataReader result)
{
var eventTypeIdColumnId = result.GetOrdinal("EventTypeId");
var eventDataColumnId = result.GetOrdinal("EventData");
result.Read();
var eventTypeId = result.GetSqlGuid(eventTypeIdColumnId).Value;
return this.serializationMethod.Deserialize(new XmlSerializedData(eventTypeId, result.GetSqlXml(eventDataColumnId).CreateReader()));
}
/// <summary>
/// Constructs an instance of IStoreLogEntry using parts of a row from SqlDataReader.
/// Used for creating the store operation for Undo.
/// </summary>
/// <param name="reader">SqlDataReader whose row has operation information.</param>
/// <param name="offset">Reader offset for column that begins operation information.</param>
internal SqlLogEntry(SqlDataReader reader, int offset)
{
this.Id = reader.GetGuid(offset);
this.OpCode = (StoreOperationCode)reader.GetInt32(offset + 1);
this.Data = reader.GetSqlXml(offset + 2);
this.UndoStartState = (StoreOperationState)reader.GetInt32(offset + 3);
SqlGuid shardIdRemoves;
shardIdRemoves = reader.GetSqlGuid(offset + 4);
this.OriginalShardVersionRemoves = shardIdRemoves.IsNull ? default(Guid) : shardIdRemoves.Value;
SqlGuid shardIdAdds;
shardIdAdds = reader.GetSqlGuid(offset + 5);
this.OriginalShardVersionAdds = shardIdAdds.IsNull ? default(Guid) : shardIdAdds.Value;
}
private EventStream DeserializeEvents(Guid id, SqlDataReader result)
{
var lastVersion = 0;
var snapshotVersion = 0;
var eventTypeIdColumnId = result.GetOrdinal("EventTypeId");
var eventDataColumnId = result.GetOrdinal("EventData");
var versionColumnId = result.GetOrdinal("Version");
var snapshotVersionColumnId = result.GetOrdinal("SnapshotVersion");
var events = new List<object>();
while (result.Read())
{
var eventTypeId = result.GetSqlGuid(eventTypeIdColumnId).Value;
lastVersion = result.GetSqlInt32(versionColumnId).Value;
snapshotVersion = result.GetSqlInt32(snapshotVersionColumnId).Value;
events.Add(this.serializationMethod.Deserialize(new XmlSerializedData(eventTypeId, result.GetSqlXml(eventDataColumnId).CreateReader())));
}
return new EventStream(id, lastVersion, snapshotVersion, events);
}
public virtual void AddItemsToListBySqlDataReader(System.Data.SqlClient.SqlDataReader reader)
{
DotNetNancy.Rules.RuleSet.DataAccess.DTO.ConfigurationFile dto;
using (reader)
{
while (reader.Read())
{
dto = new DotNetNancy.Rules.RuleSet.DataAccess.DTO.ConfigurationFile();
dto.ConfigurationFile_Property = new System.Xml.XmlDocument();
dto.ConfigurationFile_Property.Load(reader.GetSqlXml(reader.GetOrdinal("ConfigurationFile")).CreateReader());
dto.TypeID =
_baseDatabase.retrieveGuidFromDataReader(reader.GetOrdinal("TypeID"), reader);
dto.ApplicationID =
_baseDatabase.retrieveGuidFromDataReader(reader.GetOrdinal("ApplicationID"), reader);
dto.ConfigurationTypeID =
_baseDatabase.resolveNullInt32(reader.GetOrdinal("ConfigurationTypeID"), reader);
this.Add(dto);
}
}
}
public virtual void AddItemsToListBySqlDataReader(System.Data.SqlClient.SqlDataReader reader)
{
DTO.RuleDefinition dto;
using (reader)
{
while (reader.Read())
{
dto = new DTO.RuleDefinition();
dto.RuleName =
_baseDatabase.resolveNullString(reader.GetOrdinal("RuleName"), reader);
dto.Definition = new System.Xml.XmlDocument();
dto.Definition.Load(reader.GetSqlXml(reader.GetOrdinal("Definition")).CreateReader());
dto.Paused =
_baseDatabase.resolveNullBoolean(reader.GetOrdinal("Paused"), reader);
dto.DateCreated =
_baseDatabase.resolveNullDateTime(reader.GetOrdinal("DateCreated"), reader);
dto.CreatedBy =
_baseDatabase.retrieveGuidFromDataReader(reader.GetOrdinal("CreatedBy"), reader);
dto.Deleted =
_baseDatabase.resolveNullBoolean(reader.GetOrdinal("Deleted"), reader);
dto.DateUpdated =
_baseDatabase.resolveNullDateTime(reader.GetOrdinal("DateUpdated"), reader);
dto.UpdatedBy =
_baseDatabase.retrieveGuidFromDataReader(reader.GetOrdinal("UpdatedBy"), reader);
dto.RuleID =
_baseDatabase.retrieveGuidFromDataReader(reader.GetOrdinal("RuleID"), reader);
dto.TypeID =
_baseDatabase.retrieveGuidFromDataReader(reader.GetOrdinal("TypeID"), reader);
dto.ApplicationID =
_baseDatabase.retrieveGuidFromDataReader(reader.GetOrdinal("ApplicationID"), reader);
this.Add(dto);
}
}
}
protected static void PopulateEntity(SqlDataReader reader, ServerEntity entity, Dictionary<string, PropertyInfo> propMap)
{
for (int i = 0; i < reader.FieldCount; i++)
{
String columnName = reader.GetName(i);
// Special case for when we select a range of values with an EntityBroker, just ignore
if (columnName.Equals("RowNum"))
continue;
if (columnName.Equals("GUID"))
{
Guid uid = reader.GetGuid(i);
entity.SetKey(new ServerEntityKey(entity.Name, uid));
continue;
}
if (columnName.Equals(entity.Name) && columnName.Contains("Enum"))
columnName = "Enum";
PropertyInfo prop;
if (!propMap.TryGetValue(columnName, out prop))
throw new EntityNotFoundException("Unable to match column to property: " + columnName, null);
if (columnName.Contains("GUID"))
columnName = columnName.Replace("GUID", "Key");
if (reader.IsDBNull(i))
{
prop.SetValue(entity, null, null);
continue;
}
Type propType = prop.PropertyType;
if (propType == typeof(String))
prop.SetValue(entity, reader.GetString(i), null);
else if (propType == typeof(ServerEntityKey))
{
Guid uid = reader.GetGuid(i);
prop.SetValue(entity, new ServerEntityKey(columnName.Replace("Key", String.Empty), uid), null);
}
else if (propType == typeof(DateTime))
prop.SetValue(entity, reader.GetDateTime(i), null);
else if (propType == typeof(DateTime?))
{
if (reader.IsDBNull(i))
{
prop.SetValue(entity, null, null);
}
else
{
prop.SetValue(entity, reader.GetDateTime(i), null);
}
}
else if (propType == typeof(bool))
prop.SetValue(entity, reader.GetBoolean(i), null);
else if (propType == typeof(Int32))
prop.SetValue(entity, reader.GetInt32(i), null);
else if (propType == typeof(Int16))
prop.SetValue(entity, reader.GetInt16(i), null);
else if (propType == typeof(double))
prop.SetValue(entity, reader.GetDouble(i), null);
else if (propType == typeof(Decimal))
prop.SetValue(entity, reader.GetDecimal(i), null);
else if (propType == typeof(float))
prop.SetValue(entity, reader.GetFloat(i), null);
else if (propType == typeof(XmlDocument))
{
SqlXml xml = reader.GetSqlXml(i);
if (xml!=null && !xml.IsNull)
{
XmlReader xmlReader = xml.CreateReader();
if (xmlReader != null)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xmlReader);
prop.SetValue(entity, xmlDoc, null);
}
else
prop.SetValue(entity, null, null);
}
else
{
prop.SetValue(entity, null, null);
}
}
else if (typeof(ServerEnum).IsAssignableFrom(propType))
{
short enumVal = reader.GetInt16(i);
ConstructorInfo construct = prop.PropertyType.GetConstructor(new Type[0]);
ServerEnum val = (ServerEnum)construct.Invoke(null);
val.SetEnum(enumVal);
prop.SetValue(entity, val, null);
}
else
throw new EntityNotFoundException("Unsupported property type: " + propType, null);
}
}
// Copy multiple fields from reader to ITypedSettersV3
// Assumes caller enforces that reader and setter metadata are compatible
internal static void FillCompatibleITypedSettersFromReader( SmiEventSink_Default sink, ITypedSettersV3 setters, SmiMetaData[] metaData, SqlDataReader reader ) {
for ( int i = 0; i < metaData.Length; i++ ) {
if ( reader.IsDBNull(i) ) {
ValueUtilsSmi.SetDBNull_Unchecked( sink, setters, i );
}
else {
switch ( metaData[i].SqlDbType ) {
case SqlDbType.BigInt:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.Int64 ) );
ValueUtilsSmi.SetInt64_Unchecked( sink, setters, i, reader.GetInt64(i) );
break;
case SqlDbType.Binary:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlBytes ) );
ValueUtilsSmi.SetSqlBytes_LengthChecked( sink, setters, i, metaData[i], reader.GetSqlBytes(i), 0 );
break;
case SqlDbType.Bit:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.Boolean ) );
SetBoolean_Unchecked( sink, setters, i, reader.GetBoolean(i) );
break;
case SqlDbType.Char:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlChars ) );
SetSqlChars_LengthChecked( sink, setters, i, metaData[i], reader.GetSqlChars(i), 0 );
break;
case SqlDbType.DateTime:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.DateTime ) );
SetDateTime_Checked( sink, setters, i, metaData[i], reader.GetDateTime(i) );
break;
case SqlDbType.Decimal:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlDecimal ) );
SetSqlDecimal_Unchecked( sink, setters, i, reader.GetSqlDecimal(i) );
break;
case SqlDbType.Float:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.Double ) );
SetDouble_Unchecked( sink, setters, i, reader.GetDouble(i) );
break;
case SqlDbType.Image:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlBytes ) );
SetSqlBytes_LengthChecked( sink, setters, i, metaData[i], reader.GetSqlBytes(i), 0 );
break;
case SqlDbType.Int:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.Int32 ) );
SetInt32_Unchecked( sink, setters, i, reader.GetInt32(i) );
break;
case SqlDbType.Money:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlMoney ) );
SetSqlMoney_Unchecked( sink, setters, i, metaData[i], reader.GetSqlMoney(i) );
break;
case SqlDbType.NChar:
case SqlDbType.NText:
case SqlDbType.NVarChar:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlChars ) );
SetSqlChars_LengthChecked( sink, setters, i, metaData[i], reader.GetSqlChars(i), 0 );
break;
case SqlDbType.Real:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.Single ) );
SetSingle_Unchecked( sink, setters, i, reader.GetFloat(i) );
break;
case SqlDbType.UniqueIdentifier:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.Guid ) );
SetGuid_Unchecked( sink, setters, i, reader.GetGuid(i) );
break;
case SqlDbType.SmallDateTime:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.DateTime ) );
SetDateTime_Checked( sink, setters, i, metaData[i], reader.GetDateTime(i) );
break;
case SqlDbType.SmallInt:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.Int16 ) );
SetInt16_Unchecked( sink, setters, i, reader.GetInt16(i) );
break;
case SqlDbType.SmallMoney:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlMoney ) );
SetSqlMoney_Checked( sink, setters, i, metaData[i], reader.GetSqlMoney(i) );
break;
case SqlDbType.Text:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlChars ) );
SetSqlChars_LengthChecked( sink, setters, i, metaData[i], reader.GetSqlChars(i), 0 );
break;
case SqlDbType.Timestamp:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlBytes ) );
SetSqlBytes_LengthChecked( sink, setters, i, metaData[i], reader.GetSqlBytes(i), 0 );
break;
case SqlDbType.TinyInt:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.Byte ) );
SetByte_Unchecked( sink, setters, i, reader.GetByte(i) );
break;
case SqlDbType.VarBinary:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlBytes ) );
SetSqlBytes_LengthChecked( sink, setters, i, metaData[i], reader.GetSqlBytes(i), 0 );
break;
case SqlDbType.VarChar:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.String ) );
SetSqlChars_LengthChecked( sink, setters, i, metaData[i], reader.GetSqlChars(i), 0 );
break;
case SqlDbType.Xml:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlXml ) );
SetSqlXml_Unchecked( sink, setters, i, reader.GetSqlXml(i) );
break;
case SqlDbType.Variant:
object o = reader.GetSqlValue(i);
ExtendedClrTypeCode typeCode = MetaDataUtilsSmi.DetermineExtendedTypeCode( o );
SetCompatibleValue( sink, setters, i, metaData[i], o, typeCode, 0 );
break;
case SqlDbType.Udt:
Debug.Assert( CanAccessSetterDirectly( metaData[i], ExtendedClrTypeCode.SqlBytes ) );
SetSqlBytes_LengthChecked( sink, setters, i, metaData[i], reader.GetSqlBytes(i), 0 );
break;
default:
// In order for us to get here we would have to have an
// invalid instance of SqlDbType, or one would have to add
// new member to SqlDbType without adding a case in this
// switch, hence the assert - it must be
Debug.Assert( false, "unsupported DbType:" + metaData[i].SqlDbType.ToString() );
throw ADP.NotSupported();
}
}
}
}
private void ProcessNotificationResults(SqlDataReader reader)
{
IntPtr hscp;
Bid.NotificationsScopeEnter(out hscp, "<sc.SqlConnectionContainer.ProcessNotificationResults|DEP> %d#", ObjectID);
try {
Guid handle = Guid.Empty; // Conversation_handle. Always close this!
try {
if (!_stop) {
while (reader.Read()) {
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP> Row read.\n");
#if DEBUG
for (int i=0; i<reader.FieldCount; i++) {
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP> column: %ls, value: %ls\n", reader.GetName(i), reader.GetValue(i).ToString());
}
#endif
string msgType = reader.GetString(0);
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP> msgType: '%ls'\n", msgType);
handle = reader.GetGuid(1);
// Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults(SqlDataReader)|DEP> conversationHandle: '%p(GUID)'\n", conversationHandle);
// Only process QueryNotification messages.
if (0 == String.Compare(msgType, "http://schemas.microsoft.com/SQL/Notifications/QueryNotification", StringComparison.OrdinalIgnoreCase)) {
SqlXml payload = reader.GetSqlXml(2);
if (null != payload) {
SqlNotification notification = SqlNotificationParser.ProcessMessage(payload);
if (null != notification) {
string key = notification.Key;
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP> Key: '%ls'\n", key);
int index = key.IndexOf(';'); // Our format is simple: "AppDomainKey;commandHash"
if (index >= 0) { // Ensure ';' present.
string appDomainKey = key.Substring(0, index);
SqlDependencyPerAppDomainDispatcher dispatcher;
lock (_staticInstance._sqlDependencyPerAppDomainDispatchers) {
dispatcher = _staticInstance._sqlDependencyPerAppDomainDispatchers[appDomainKey];
}
if (null != dispatcher) {
try {
dispatcher.InvalidateCommandID(notification); // CROSS APP-DOMAIN CALL!
}
catch (Exception e) {
if (!ADP.IsCatchableExceptionType(e)) {
throw;
}
ADP.TraceExceptionWithoutRethrow(e); // Discard failure. User event could throw exception.
}
}
else {
Debug.Assert(false, "Received notification but do not have an associated PerAppDomainDispatcher!");
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP|ERR> Received notification but do not have an associated PerAppDomainDispatcher!\n");
}
}
else {
Debug.Assert(false, "Unexpected ID format received!");
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP|ERR> Unexpected ID format received!\n");
}
}
else {
Debug.Assert(false, "Null notification returned from ProcessMessage!");
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP|ERR> Null notification returned from ProcessMessage!\n");
}
}
else {
Debug.Assert(false, "Null payload for QN notification type!");
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP|ERR> Null payload for QN notification type!\n");
}
}
else {
handle = Guid.Empty;
// VSDD 546707: this assert was hit by SQL Notification fuzzing tests, disable it to let these tests run on Debug bits
// Debug.Assert(false, "Unexpected message format received!");
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP> Unexpected message format received!\n");
}
}
}
}
finally {
// Since we do not want to make a separate round trip just for the end conversation call, we need to
// batch it with the next command.
if (handle == Guid.Empty) { // This should only happen if failure occurred, or if non-QN format received.
_com.CommandText = (null != _beginConversationQuery) ? _beginConversationQuery : _receiveQuery; // If we're doing the initial query, we won't have a conversation Guid to begin yet.
if (_com.Parameters.Count > 1) { // Remove conversation param since next execute is only query.
_com.Parameters.Remove(_conversationGuidParam);
}
Debug.Assert(_com.Parameters.Count == 1, "Unexpected number of parameters!");
}
else {
_com.CommandText = _concatQuery; // END query + WAITFOR RECEIVE query.
_conversationGuidParam.Value = handle; // Set value for conversation handle.
if (_com.Parameters.Count == 1) { // Add parameter if previous execute was only query.
_com.Parameters.Add(_conversationGuidParam);
}
Debug.Assert(_com.Parameters.Count == 2, "Unexpected number of parameters!");
}
}
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
internal static void FillCompatibleITypedSettersFromReader(SmiEventSink_Default sink, ITypedSettersV3 setters, SmiMetaData[] metaData, SqlDataReader reader)
{
for (int i = 0; i < metaData.Length; i++)
{
if (reader.IsDBNull(i))
{
SetDBNull_Unchecked(sink, setters, i);
continue;
}
switch (metaData[i].SqlDbType)
{
case SqlDbType.BigInt:
{
SetInt64_Unchecked(sink, setters, i, reader.GetInt64(i));
continue;
}
case SqlDbType.Binary:
{
SetSqlBytes_LengthChecked(sink, setters, i, metaData[i], reader.GetSqlBytes(i), 0);
continue;
}
case SqlDbType.Bit:
{
SetBoolean_Unchecked(sink, setters, i, reader.GetBoolean(i));
continue;
}
case SqlDbType.Char:
{
SetSqlChars_LengthChecked(sink, setters, i, metaData[i], reader.GetSqlChars(i), 0);
continue;
}
case SqlDbType.DateTime:
{
SetDateTime_Checked(sink, setters, i, metaData[i], reader.GetDateTime(i));
continue;
}
case SqlDbType.Decimal:
{
SetSqlDecimal_Unchecked(sink, setters, i, reader.GetSqlDecimal(i));
continue;
}
case SqlDbType.Float:
{
SetDouble_Unchecked(sink, setters, i, reader.GetDouble(i));
continue;
}
case SqlDbType.Image:
{
SetSqlBytes_LengthChecked(sink, setters, i, metaData[i], reader.GetSqlBytes(i), 0);
continue;
}
case SqlDbType.Int:
{
SetInt32_Unchecked(sink, setters, i, reader.GetInt32(i));
continue;
}
case SqlDbType.Money:
{
SetSqlMoney_Unchecked(sink, setters, i, metaData[i], reader.GetSqlMoney(i));
continue;
}
case SqlDbType.NChar:
case SqlDbType.NText:
case SqlDbType.NVarChar:
{
SetSqlChars_LengthChecked(sink, setters, i, metaData[i], reader.GetSqlChars(i), 0);
continue;
}
case SqlDbType.Real:
{
SetSingle_Unchecked(sink, setters, i, reader.GetFloat(i));
continue;
}
case SqlDbType.UniqueIdentifier:
{
SetGuid_Unchecked(sink, setters, i, reader.GetGuid(i));
continue;
}
case SqlDbType.SmallDateTime:
{
SetDateTime_Checked(sink, setters, i, metaData[i], reader.GetDateTime(i));
continue;
}
case SqlDbType.SmallInt:
{
SetInt16_Unchecked(sink, setters, i, reader.GetInt16(i));
continue;
}
case SqlDbType.SmallMoney:
{
SetSqlMoney_Checked(sink, setters, i, metaData[i], reader.GetSqlMoney(i));
continue;
}
case SqlDbType.Text:
{
SetSqlChars_LengthChecked(sink, setters, i, metaData[i], reader.GetSqlChars(i), 0);
continue;
}
case SqlDbType.Timestamp:
{
SetSqlBytes_LengthChecked(sink, setters, i, metaData[i], reader.GetSqlBytes(i), 0);
continue;
}
case SqlDbType.TinyInt:
{
SetByte_Unchecked(sink, setters, i, reader.GetByte(i));
continue;
}
case SqlDbType.VarBinary:
{
SetSqlBytes_LengthChecked(sink, setters, i, metaData[i], reader.GetSqlBytes(i), 0);
continue;
}
case SqlDbType.VarChar:
{
SetSqlChars_LengthChecked(sink, setters, i, metaData[i], reader.GetSqlChars(i), 0);
continue;
}
case SqlDbType.Variant:
{
object sqlValue = reader.GetSqlValue(i);
ExtendedClrTypeCode typeCode = MetaDataUtilsSmi.DetermineExtendedTypeCode(sqlValue);
SetCompatibleValue(sink, setters, i, metaData[i], sqlValue, typeCode, 0);
continue;
}
case SqlDbType.Xml:
{
SetSqlXml_Unchecked(sink, setters, i, reader.GetSqlXml(i));
continue;
}
case SqlDbType.Udt:
{
SetSqlBytes_LengthChecked(sink, setters, i, metaData[i], reader.GetSqlBytes(i), 0);
continue;
}
}
throw ADP.NotSupported();
}
}
private static XmlDocument getXmlRecords(string connection, XmlDocument searchIds, string contentType, DeletedOptions deleted)
{
if (connection == null || connection.Length <= 0)
{
throw new Exception("missing or invalid connection string");
}
if (searchIds == null)
{
throw new Exception("missing or invalid searchIds Xml");
}
if (contentType.Length <= 0)
{
throw new Exception("contentType must be specified");
}
XmlDocument xdOutput = new XmlDocument {
XmlResolver = null
};
string rootNode = contentType + "s";
// no IDs, so save time by aborting now
if (!searchIds.DocumentElement.HasChildNodes)
{
xdOutput.LoadXml(string.Format("<{0}/>", rootNode));
return(xdOutput);
}
try
{
StringBuilder sbXml = new StringBuilder();
using (SqlCommand oCmd = new SqlCommand("getXmlRecords", new SqlConnection(connection)))
{
oCmd.CommandType = CommandType.StoredProcedure;
using (XmlNodeReader xnr = new XmlNodeReader(searchIds))
{
SqlXml sx = new SqlXml(xnr);
oCmd.Parameters.Add("@ids", SqlDbType.Xml);
oCmd.Parameters["@ids"].Value = sx;
}
oCmd.Parameters.AddWithValue("@contentType", contentType);
oCmd.Parameters.AddWithValue("@version", null);
oCmd.Parameters.AddWithValue("@deleted", deleted);
oCmd.Connection.Open();
System.Data.SqlClient.SqlDataReader oRdr = oCmd.ExecuteReader();
if (!oRdr.HasRows)
{
sbXml.Append("<" + rootNode + "/>");
}
else
{
sbXml.Append("<" + rootNode + ">");
while (oRdr.Read())
{
System.Data.SqlTypes.SqlXml sx = oRdr.GetSqlXml(0);
//XmlReader xr = sx.CreateReader();
//xr.Read();
sbXml.Append(sx.Value);
}
sbXml.Append("</" + rootNode + ">");
oRdr.Close();
oCmd.Connection.Close();
}
}
xdOutput.LoadXml(sbXml.ToString());
return(xdOutput);
}
catch (Exception ex)
{
throw ex;
}
}
private static XmlDocument getXmlRecord(string connection, string keyId, string contentType, DeletedOptions deleted)
{
if (connection.Length <= 0)
{
throw new Exception("missing or invalid connection string");
}
if (keyId.Length <= 0)
{
throw new Exception("missing or invalid keyID");
}
if (contentType.Length <= 0)
{
throw new Exception("contentType must be specified");
}
try
{
XmlDocument xdOutput = new XmlDocument {
XmlResolver = null
};
StringBuilder sb = new StringBuilder();
using (SqlCommand oCmd = new SqlCommand("getXmlRecord", new SqlConnection(connection)))
{
oCmd.CommandType = CommandType.StoredProcedure;
oCmd.Parameters.AddWithValue("@id", keyId);
oCmd.Parameters.AddWithValue("@contentType", contentType);
oCmd.Parameters.AddWithValue("@deleted", deleted);
oCmd.Connection.Open();
System.Data.SqlClient.SqlDataReader oRdr = oCmd.ExecuteReader();
if (!oRdr.HasRows)
{
return(null);
}
while (oRdr.Read())
{
System.Data.SqlTypes.SqlXml sx = oRdr.GetSqlXml(0);
//XmlReader xr = sx.CreateReader();
//xr.Read();
sb.Append(sx.Value);
}
oRdr.Close();
oCmd.Connection.Close();
}
xdOutput.LoadXml(sb.ToString());
return(xdOutput);
}
catch (Exception ex)
{
throw ex;
}
}
private void ProcessNotificationResults(SqlDataReader reader)
{
IntPtr ptr;
Bid.NotificationsScopeEnter(out ptr, "<sc.SqlConnectionContainer.ProcessNotificationResults|DEP> %d#", this.ObjectID);
try
{
Guid empty = Guid.Empty;
try
{
if (!this._stop)
{
while (reader.Read())
{
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP> Row read.\n");
string str2 = reader.GetString(0);
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP> msgType: '%ls'\n", str2);
empty = reader.GetGuid(1);
if (string.Compare(str2, "http://schemas.microsoft.com/SQL/Notifications/QueryNotification", StringComparison.OrdinalIgnoreCase) == 0)
{
SqlXml sqlXml = reader.GetSqlXml(2);
if (sqlXml != null)
{
SqlNotification sqlNotification = SqlDependencyProcessDispatcher.SqlNotificationParser.ProcessMessage(sqlXml);
if (sqlNotification != null)
{
string key = sqlNotification.Key;
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP> Key: '%ls'\n", key);
int index = key.IndexOf(';');
if (index >= 0)
{
SqlDependencyPerAppDomainDispatcher dispatcher;
string str3 = key.Substring(0, index);
lock (SqlDependencyProcessDispatcher._staticInstance._sqlDependencyPerAppDomainDispatchers)
{
dispatcher = SqlDependencyProcessDispatcher._staticInstance._sqlDependencyPerAppDomainDispatchers[str3];
}
if (dispatcher != null)
{
try
{
dispatcher.InvalidateCommandID(sqlNotification);
continue;
}
catch (Exception exception)
{
if (!ADP.IsCatchableExceptionType(exception))
{
throw;
}
ADP.TraceExceptionWithoutRethrow(exception);
continue;
}
}
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP|ERR> Received notification but do not have an associated PerAppDomainDispatcher!\n");
}
else
{
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP|ERR> Unexpected ID format received!\n");
}
}
else
{
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP|ERR> Null notification returned from ProcessMessage!\n");
}
}
else
{
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP|ERR> Null payload for QN notification type!\n");
}
}
else
{
empty = Guid.Empty;
Bid.NotificationsTrace("<sc.SqlConnectionContainer.ProcessNotificationResults|DEP> Unexpected message format received!\n");
}
}
}
}
finally
{
if (empty == Guid.Empty)
{
this._com.CommandText = (this._beginConversationQuery != null) ? this._beginConversationQuery : this._receiveQuery;
if (this._com.Parameters.Count > 1)
{
this._com.Parameters.Remove(this._conversationGuidParam);
}
}
else
{
this._com.CommandText = this._concatQuery;
this._conversationGuidParam.Value = empty;
if (this._com.Parameters.Count == 1)
{
this._com.Parameters.Add(this._conversationGuidParam);
}
}
}
}
finally
{
Bid.ScopeLeave(ref ptr);
}
}
/// <summary>
/// Constructs an instance of IStoreSchemaInfo using parts of a row from SqlDataReader.
/// </summary>
/// <param name="reader">SqlDataReader whose row has shard information.</param>
/// <param name="offset">Reader offset for column that begins shard information.</param>
internal SqlSchemaInfo(SqlDataReader reader, int offset)
{
this.Name = reader.GetString(offset);
this.ShardingSchemaInfo = reader.GetSqlXml(offset + 1);
}
