public DatabaseMetadata(DbConnection connection, Dialect.Dialect dialect, bool extras)
{
schemaReader = new InformationSchemaReader(connection);
this.extras = extras;
InitSequences(connection, dialect);
sqlExceptionConverter = dialect.BuildSQLExceptionConverter();
}
public static ADOException Convert(ISQLExceptionConverter converter, Exception sqle, string message, SqlString sql,
object[] parameterValues, IDictionary namedParameters)
{
string extendMessage = ExtendMessage(message, sql, parameterValues, namedParameters);
ADOExceptionReporter.LogExceptions(sqle, extendMessage);
return new ADOException(extendMessage, sqle, sql);
}
/// <summary>
/// Converts the given SQLException into Exception hierarchy, as well as performing
/// appropriate logging.
/// </summary>
/// <param name="converter">The converter to use.</param>
/// <param name="sqlException">The exception to convert.</param>
/// <param name="message">An optional error message.</param>
/// <param name="sql">The SQL executed.</param>
/// <returns> The converted <see cref="ADOException"/>.</returns>
public static Exception Convert(ISQLExceptionConverter converter, Exception sqlException, string message,
SqlString sql)
{
return Convert(converter,
new AdoExceptionContextInfo
{SqlException = sqlException, Message = message, Sql = sql != null ? sql.ToString() : null});
}
/// <summary>
/// Converts the given SQLException into Exception hierarchy, as well as performing
/// appropriate logging.
/// </summary>
/// <param name="converter">The converter to use.</param>
/// <param name="sqlException">The exception to convert.</param>
/// <param name="message">An optional error message.</param>
/// <returns> The converted <see cref="ADOException"/>.</returns>
public static Exception Convert(ISQLExceptionConverter converter, Exception sqlException, string message)
{
var sql = TryGetActualSqlQuery(sqlException, SQLNotAvailable);
return(Convert(converter, new AdoExceptionContextInfo {
SqlException = sqlException, Message = message, Sql = sql
}));
}
public DatabaseMetadata(DbConnection connection, Dialect.Dialect dialect, bool extras)
{
meta = dialect.GetDataBaseSchema(connection);
this.dialect = dialect;
this.extras = extras;
InitSequences(connection, dialect);
sqlExceptionConverter = dialect.BuildSQLExceptionConverter();
}
public DatabaseMetadata(DbConnection connection, Dialect.Dialect dialect, bool extras)
{
meta = dialect.GetDataBaseSchema(connection);
this.dialect = dialect;
this.extras = extras;
InitSequences(connection, dialect);
sqlExceptionConverter = dialect.BuildSQLExceptionConverter();
}
public static Exception Convert(ISQLExceptionConverter converter, Exception sqle, string message, SqlString sql,
object[] parameterValues, IDictionary<string, TypedValue> namedParameters)
{
sql = TryGetActualSqlQuery(sqle, sql);
string extendMessage = ExtendMessage(message, sql != null ? sql.ToString() : null, parameterValues, namedParameters);
ADOExceptionReporter.LogExceptions(sqle, extendMessage);
return Convert(converter, sqle, extendMessage, sql);
}
/// <summary>
/// Converts the given SQLException into Exception hierarchy, as well as performing
/// appropriate logging.
/// </summary>
/// <param name="converter">The converter to use.</param>
/// <param name="sqlException">The exception to convert.</param>
/// <param name="message">An optional error message.</param>
/// <param name="sql">The SQL executed.</param>
/// <returns> The converted <see cref="ADOException"/>.</returns>
public static Exception Convert(ISQLExceptionConverter converter, Exception sqlException, string message,
SqlString sql)
{
return(Convert(converter,
new AdoExceptionContextInfo
{
SqlException = sqlException, Message = message, Sql = sql != null ? sql.ToString() : null
}));
}
public static Exception Convert(ISQLExceptionConverter converter, Exception sqle, string message, SqlString sql,
object[] parameterValues, IDictionary <string, TypedValue> namedParameters)
{
sql = TryGetActualSqlQuery(sqle, sql);
string extendMessage = ExtendMessage(message, sql != null ? sql.ToString() : null, parameterValues, namedParameters);
ADOExceptionReporter.LogExceptions(sqle, extendMessage);
return(Convert(converter, sqle, extendMessage, sql));
}
public ExecutionService(InternalDbContext dbContext)
{
this.dbContext = dbContext;
log = dbContext.Log;
if (exceptionConverter == null)
{
exceptionConverter = new SqlExceptionConverter();
}
}
public static Exception Convert(ISqlLog log, ISQLExceptionConverter converter, DbExceptionContextInfo exceptionContextInfo)
{
if (exceptionContextInfo == null)
{
throw new ArgumentNullException("The argument exceptionContextInfo is null.");
}
var sql = TryGetActualSqlQuery(exceptionContextInfo.SqlException, exceptionContextInfo.Sql);
log.Error(exceptionContextInfo.SqlException,
ExtendMessage(exceptionContextInfo.Message, sql));
return converter.Convert(exceptionContextInfo);
}
public static Exception Convert(ISQLExceptionConverter converter, AdoExceptionContextInfo exceptionContextInfo)
{
if(exceptionContextInfo == null)
{
throw new AssertionFailure("The argument exceptionContextInfo is null.");
}
var sql = TryGetActualSqlQuery(exceptionContextInfo.SqlException, exceptionContextInfo.Sql);
ADOExceptionReporter.LogExceptions(exceptionContextInfo.SqlException,
ExtendMessage(exceptionContextInfo.Message, sql, null, null));
return converter.Convert(exceptionContextInfo);
}
public static Exception Convert(ILogger log, ISQLExceptionConverter converter, DbExceptionContextInfo exceptionContextInfo)
{
//if (exceptionContextInfo == null)
//{
// throw new ArgumentNullException("The argument exceptionContextInfo is null.");
//}
var sql = TryGetActualSqlQuery(exceptionContextInfo.SqlException, exceptionContextInfo.Sql);
//log.Log(LogLevel.Error, exceptionContextInfo.SqlException,
// ExtendMessage(exceptionContextInfo.Message, sql));
return(converter.Convert(exceptionContextInfo));
}
public static Exception Convert(ISQLExceptionConverter converter, AdoExceptionContextInfo exceptionContextInfo)
{
if (exceptionContextInfo == null)
{
throw new AssertionFailure("The argument exceptionContextInfo is null.");
}
var sql = TryGetActualSqlQuery(exceptionContextInfo.SqlException, exceptionContextInfo.Sql);
ADOExceptionReporter.LogExceptions(exceptionContextInfo.SqlException,
ExtendMessage(exceptionContextInfo.Message, sql, null, null));
return(converter.Convert(exceptionContextInfo));
}
public static Exception Convert(ISqlLog log, ISQLExceptionConverter converter, DbExceptionContextInfo exceptionContextInfo)
{
if (exceptionContextInfo == null)
{
throw new ArgumentNullException("The argument exceptionContextInfo is null.");
}
var sql = TryGetActualSqlQuery(exceptionContextInfo.SqlException, exceptionContextInfo.Sql);
log.Error(exceptionContextInfo.SqlException,
ExtendMessage(exceptionContextInfo.Message, sql));
return(converter.Convert(exceptionContextInfo));
}
public void BadGrammar()
{
if (Dialect is SQLiteDialect)
{
Assert.Ignore("Example exception converter not implemented.");
}
//ISQLExceptionConverter converter = Dialect.BuildSQLExceptionConverter();
ISQLExceptionConverter converter = sessions.Settings.SqlExceptionConverter;
ISession session = OpenSession();
IDbConnection connection = session.Connection;
// prepare/execute a query against a non-existent table
IDbCommand ps = null;
try
{
ps = connection.CreateCommand();
ps.CommandType = CommandType.Text;
ps.CommandText = "SELECT user_id, user_name FROM tbl_no_there";
ps.ExecuteNonQuery();
Assert.Fail("SQL compilation should have failed");
}
catch (Exception sqle)
{
Assert.AreEqual(typeof(SQLGrammarException),
converter.Convert(new AdoExceptionContextInfo {
SqlException = sqle
}).GetType(),
"Bad conversion [" + sqle.Message + "]");
}
finally
{
if (ps != null)
{
try
{
ps.Dispose();
}
catch (Exception)
{
// ignore...
}
}
}
session.Close();
}
public static Exception Convert(ISqlLog log, ISQLExceptionConverter converter,DbExceptionContextInfo exceptionContextInfo,
object[] parameterValues, NamedParameter[] namedParameters)
{
var sql = TryGetActualSqlQuery(exceptionContextInfo.SqlException, exceptionContextInfo.Sql);
string extendMessage = ExtendMessage(
exceptionContextInfo.Message,
sql != null ? sql.ToString() : null,
exceptionContextInfo.Entity,
parameterValues,
namedParameters);
log.Error(exceptionContextInfo.SqlException, extendMessage);
return converter.Convert(exceptionContextInfo);
}
public static Exception Convert(ISqlLog log, ISQLExceptionConverter converter, DbExceptionContextInfo exceptionContextInfo,
object[] parameterValues, NamedParameter[] namedParameters)
{
var sql = TryGetActualSqlQuery(exceptionContextInfo.SqlException, exceptionContextInfo.Sql);
string extendMessage = ExtendMessage(
exceptionContextInfo.Message,
sql != null ? sql.ToString() : null,
exceptionContextInfo.Entity,
parameterValues,
namedParameters);
log.Error(exceptionContextInfo.SqlException, extendMessage);
return(converter.Convert(exceptionContextInfo));
}
/// <summary>
/// Converts the given SQLException into Exception hierarchy, as well as performing
/// appropriate logging.
/// </summary>
/// <param name="converter">The converter to use.</param>
/// <param name="sqlException">The exception to convert.</param>
/// <param name="message">An optional error message.</param>
/// <returns> The converted <see cref="ADOException"/>.</returns>
public static Exception Convert(ISQLExceptionConverter converter, Exception sqlException, string message)
{
var sql = TryGetActualSqlQuery(sqlException, SQLNotAvailable);
return Convert(converter, new AdoExceptionContextInfo {SqlException = sqlException, Message = message, Sql = sql});
}
public AbstractCollectionPersister(Mapping.Collection collection, ICacheConcurrencyStrategy cache, Configuration cfg,
ISessionFactoryImplementor factory)
{
this.factory = factory;
this.cache = cache;
if (factory.Settings.IsStructuredCacheEntriesEnabled)
{
cacheEntryStructure = collection.IsMap
? (ICacheEntryStructure) new StructuredMapCacheEntry()
: (ICacheEntryStructure) new StructuredCollectionCacheEntry();
}
else
{
cacheEntryStructure = new UnstructuredCacheEntry();
}
dialect = factory.Dialect;
sqlExceptionConverter = factory.SQLExceptionConverter;
collectionType = collection.CollectionType;
role = collection.Role;
entityName = collection.OwnerEntityName;
ownerPersister = factory.GetEntityPersister(entityName);
queryLoaderName = collection.LoaderName;
nodeName = collection.NodeName;
isMutable = collection.IsMutable;
Table table = collection.CollectionTable;
fetchMode = collection.Element.FetchMode;
elementType = collection.Element.Type;
isPrimitiveArray = collection.IsPrimitiveArray;
isArray = collection.IsArray;
subselectLoadable = collection.IsSubselectLoadable;
qualifiedTableName = table.GetQualifiedName(dialect, factory.Settings.DefaultCatalogName, factory.Settings.DefaultSchemaName);
int spacesSize = 1 + collection.SynchronizedTables.Count;
spaces = new string[spacesSize];
int ispa = 0;
spaces[ispa++] = qualifiedTableName;
foreach (string s in collection.SynchronizedTables)
{
spaces[ispa++] = s;
}
sqlOrderByString = collection.OrderBy;
hasOrder = sqlOrderByString != null;
sqlOrderByStringTemplate = hasOrder
? Template.RenderOrderByStringTemplate(sqlOrderByString, dialect,
factory.SQLFunctionRegistry)
: null;
sqlWhereString = !string.IsNullOrEmpty(collection.Where) ? '(' + collection.Where + ')' : null;
hasWhere = sqlWhereString != null;
sqlWhereStringTemplate = hasWhere
? Template.RenderWhereStringTemplate(sqlWhereString, dialect, factory.SQLFunctionRegistry)
: null;
hasOrphanDelete = collection.HasOrphanDelete;
int batch = collection.BatchSize;
if (batch == -1)
{
batch = factory.Settings.DefaultBatchFetchSize;
}
batchSize = batch;
isVersioned = collection.IsOptimisticLocked;
keyType = collection.Key.Type;
int keySpan = collection.Key.ColumnSpan;
keyColumnNames = new string[keySpan];
keyColumnAliases = new string[keySpan];
int k = 0;
foreach (Column col in collection.Key.ColumnIterator)
{
keyColumnNames[k] = col.GetQuotedName(dialect);
keyColumnAliases[k] = col.GetAlias(dialect);
k++;
}
ISet distinctColumns = new HashedSet();
CheckColumnDuplication(distinctColumns, collection.Key.ColumnIterator);
#region Element
IValue element = collection.Element;
if (!collection.IsOneToMany)
{
CheckColumnDuplication(distinctColumns, element.ColumnIterator);
}
string elemNode = collection.ElementNodeName;
if (elementType.IsEntityType)
{
string _entityName = ((EntityType) elementType).GetAssociatedEntityName();
elementPersister = factory.GetEntityPersister(_entityName);
if (elemNode == null)
{
elemNode = cfg.GetClassMapping(_entityName).NodeName;
}
// NativeSQL: collect element column and auto-aliases
}
else
{
elementPersister = null;
}
elementNodeName = elemNode;
int elementSpan = element.ColumnSpan;
elementColumnAliases = new string[elementSpan];
elementColumnNames = new string[elementSpan];
elementFormulaTemplates = new string[elementSpan];
elementFormulas = new string[elementSpan];
elementColumnIsSettable = new bool[elementSpan];
elementColumnIsInPrimaryKey = new bool[elementSpan];
bool isPureFormula = true;
bool hasNotNullableColumns = false;
int j = 0;
foreach (ISelectable selectable in element.ColumnIterator)
{
elementColumnAliases[j] = selectable.GetAlias(dialect);
if (selectable.IsFormula)
{
Formula form = (Formula) selectable;
elementFormulaTemplates[j] = form.GetTemplate(dialect, factory.SQLFunctionRegistry);
elementFormulas[j] = form.FormulaString;
}
else
{
Column col = (Column) selectable;
elementColumnNames[j] = col.GetQuotedName(dialect);
elementColumnIsSettable[j] = true;
elementColumnIsInPrimaryKey[j] = !col.IsNullable;
if (!col.IsNullable)
{
hasNotNullableColumns = true;
}
isPureFormula = false;
}
j++;
}
elementIsPureFormula = isPureFormula;
//workaround, for backward compatibility of sets with no
//not-null columns, assume all columns are used in the
//row locator SQL
if (!hasNotNullableColumns)
{
ArrayHelper.Fill(elementColumnIsInPrimaryKey, true);
}
#endregion
#region INDEX AND ROW SELECT
hasIndex = collection.IsIndexed;
if (hasIndex)
{
// NativeSQL: collect index column and auto-aliases
IndexedCollection indexedCollection = (IndexedCollection) collection;
indexType = indexedCollection.Index.Type;
int indexSpan = indexedCollection.Index.ColumnSpan;
indexColumnNames = new string[indexSpan];
indexFormulaTemplates = new string[indexSpan];
indexFormulas = new string[indexSpan];
indexColumnIsSettable = new bool[indexSpan];
indexColumnAliases = new string[indexSpan];
bool hasFormula = false;
int i = 0;
foreach (ISelectable selectable in indexedCollection.Index.ColumnIterator)
{
indexColumnAliases[i] = selectable.GetAlias(dialect);
if (selectable.IsFormula)
{
Formula indexForm = (Formula) selectable;
indexFormulaTemplates[i] = indexForm.GetTemplate(dialect, factory.SQLFunctionRegistry);
indexFormulas[i] = indexForm.FormulaString;
hasFormula = true;
}
else
{
Column indexCol = (Column) selectable;
indexColumnNames[i] = indexCol.GetQuotedName(dialect);
indexColumnIsSettable[i] = true;
}
i++;
}
indexContainsFormula = hasFormula;
baseIndex = indexedCollection.IsList ? ((List) indexedCollection).BaseIndex : 0;
indexNodeName = indexedCollection.IndexNodeName;
CheckColumnDuplication(distinctColumns, indexedCollection.Index.ColumnIterator);
}
else
{
indexContainsFormula = false;
indexColumnIsSettable = null;
indexFormulaTemplates = null;
indexFormulas = null;
indexType = null;
indexColumnNames = null;
indexColumnAliases = null;
baseIndex = 0;
indexNodeName = null;
}
hasIdentifier = collection.IsIdentified;
if (hasIdentifier)
{
if (collection.IsOneToMany)
{
throw new MappingException("one-to-many collections with identifiers are not supported.");
}
IdentifierCollection idColl = (IdentifierCollection) collection;
identifierType = idColl.Identifier.Type;
Column col = null;
foreach (Column column in idColl.Identifier.ColumnIterator)
{
col = column;
break;
}
identifierColumnName = col.GetQuotedName(dialect);
identifierColumnAlias = col.GetAlias(dialect);
identifierGenerator =
idColl.Identifier.CreateIdentifierGenerator(factory.Dialect, factory.Settings.DefaultCatalogName,
factory.Settings.DefaultSchemaName, null);
// NH see : identityDelegate declaration
IPostInsertIdentifierGenerator pig = (identifierGenerator as IPostInsertIdentifierGenerator);
if (pig != null)
{
identityDelegate = pig.GetInsertGeneratedIdentifierDelegate(this, Factory, UseGetGeneratedKeys());
}
else
{
identityDelegate = null;
}
CheckColumnDuplication(distinctColumns, idColl.Identifier.ColumnIterator);
}
else
{
identifierType = null;
identifierColumnName = null;
identifierColumnAlias = null;
identifierGenerator = null;
identityDelegate = null;
}
#endregion
#region GENERATE THE SQL
// NH Different behavior : for the Insert SQL we are managing isPostInsertIdentifier (not supported in H3.2.5)
if (collection.CustomSQLInsert == null)
{
if (!IsIdentifierAssignedByInsert)
{
sqlInsertRowString = GenerateInsertRowString();
}
else
{
sqlInsertRowString = GenerateIdentityInsertRowString();
}
insertCallable = false;
insertCheckStyle = ExecuteUpdateResultCheckStyle.Count;
}
else
{
SqlType[] parmsTypes = GenerateInsertRowString().ParameterTypes;
sqlInsertRowString = new SqlCommandInfo(collection.CustomSQLInsert, parmsTypes);
insertCallable = collection.IsCustomInsertCallable;
insertCheckStyle = collection.CustomSQLInsertCheckStyle
?? ExecuteUpdateResultCheckStyle.DetermineDefault(collection.CustomSQLInsert, insertCallable);
}
sqlUpdateRowString = GenerateUpdateRowString();
if (collection.CustomSQLUpdate == null)
{
updateCallable = false;
updateCheckStyle = ExecuteUpdateResultCheckStyle.Count;
}
else
{
sqlUpdateRowString = new SqlCommandInfo(collection.CustomSQLUpdate, sqlUpdateRowString.ParameterTypes);
updateCallable = collection.IsCustomUpdateCallable;
updateCheckStyle = collection.CustomSQLUpdateCheckStyle
?? ExecuteUpdateResultCheckStyle.DetermineDefault(collection.CustomSQLUpdate, updateCallable);
}
sqlDeleteRowString = GenerateDeleteRowString();
if (collection.CustomSQLDelete == null)
{
deleteCallable = false;
deleteCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
else
{
sqlDeleteRowString = new SqlCommandInfo(collection.CustomSQLDelete, sqlDeleteRowString.ParameterTypes);
deleteCallable = collection.IsCustomDeleteCallable;
deleteCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
sqlDeleteString = GenerateDeleteString();
if (collection.CustomSQLDeleteAll == null)
{
deleteAllCallable = false;
deleteAllCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
else
{
sqlDeleteString = new SqlCommandInfo(collection.CustomSQLDeleteAll, sqlDeleteString.ParameterTypes);
deleteAllCallable = collection.IsCustomDeleteAllCallable;
deleteAllCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
isCollectionIntegerIndex = collection.IsIndexed && !collection.IsMap;
sqlDetectRowByIndexString = GenerateDetectRowByIndexString();
sqlDetectRowByElementString = GenerateDetectRowByElementString();
sqlSelectRowByIndexString = GenerateSelectRowByIndexString();
LogStaticSQL();
#endregion
isLazy = collection.IsLazy;
isExtraLazy = collection.ExtraLazy;
isInverse = collection.IsInverse;
if (collection.IsArray)
{
elementClass = ((Array) collection).ElementClass;
}
else
{
// for non-arrays, we don't need to know the element class
elementClass = null;
}
if (elementType.IsComponentType)
{
elementPropertyMapping =
new CompositeElementPropertyMapping(elementColumnNames, elementFormulaTemplates,
(IAbstractComponentType) elementType, factory);
}
else if (!elementType.IsEntityType)
{
elementPropertyMapping = new ElementPropertyMapping(elementColumnNames, elementType);
}
else
{
elementPropertyMapping = elementPersister as IPropertyMapping;
if (elementPropertyMapping == null)
{
elementPropertyMapping = new ElementPropertyMapping(elementColumnNames, elementType);
}
}
// Handle any filters applied to this collection
filterHelper = new FilterHelper(collection.FilterMap, dialect, factory.SQLFunctionRegistry);
// Handle any filters applied to this collection for many-to-many
manyToManyFilterHelper = new FilterHelper(collection.ManyToManyFilterMap, dialect, factory.SQLFunctionRegistry);
manyToManyWhereString = !string.IsNullOrEmpty(collection.ManyToManyWhere)
? "( " + collection.ManyToManyWhere + " )"
: null;
manyToManyWhereTemplate = manyToManyWhereString == null
? null
: Template.RenderWhereStringTemplate(manyToManyWhereString, factory.Dialect,
factory.SQLFunctionRegistry);
manyToManyOrderByString = collection.ManyToManyOrdering;
manyToManyOrderByTemplate = manyToManyOrderByString == null
? null
: Template.RenderOrderByStringTemplate(manyToManyOrderByString, factory.Dialect,
factory.SQLFunctionRegistry);
InitCollectionPropertyMap();
}
public void IntegrityViolation()
{
//ISQLExceptionConverter converter = Dialect.BuildSQLExceptionConverter();
ISQLExceptionConverter converter = sessions.Settings.SqlExceptionConverter;
ISession session = OpenSession();
session.BeginTransaction();
IDbConnection connection = session.Connection;
// Attempt to insert some bad values into the T_MEMBERSHIP table that should
// result in a constraint violation
IDbCommand ps = null;
try
{
ps = connection.CreateCommand();
ps.CommandType = CommandType.Text;
ps.CommandText = "INSERT INTO T_MEMBERSHIP (user_id, group_id) VALUES (@p1, @p2)";
IDbDataParameter pr = ps.CreateParameter();
pr.ParameterName = "p1";
pr.DbType = DbType.Int64;
pr.Value = 52134241L; // Non-existent user_id
ps.Parameters.Add(pr);
pr = ps.CreateParameter();
pr.ParameterName = "p2";
pr.DbType = DbType.Int64;
pr.Value = 5342L; // Non-existent group_id
ps.Parameters.Add(pr);
session.Transaction.Enlist(ps);
ps.ExecuteNonQuery();
Assert.Fail("INSERT should have failed");
}
catch (Exception sqle)
{
ADOExceptionReporter.LogExceptions(sqle, "Just output!!!!");
Exception adoException = converter.Convert(new AdoExceptionContextInfo {
SqlException = sqle
});
Assert.AreEqual(typeof(ConstraintViolationException), adoException.GetType(),
"Bad conversion [" + sqle.Message + "]");
ConstraintViolationException ex = (ConstraintViolationException)adoException;
Console.WriteLine("Violated constraint name: " + ex.ConstraintName);
}
finally
{
if (ps != null)
{
try
{
ps.Dispose();
}
catch (Exception)
{
// ignore...
}
}
}
session.Transaction.Rollback();
session.Close();
}
/// <summary>
/// Converts the given SQLException into NHibernate's ADOException hierarchy, as well as performing
/// appropriate logging.
/// </summary>
/// <param name="converter">The converter to use.</param>
/// <param name="sqlException">The exception to convert.</param>
/// <param name="message">An optional error message.</param>
/// <returns> The converted <see cref="ADOException"/>.</returns>
public static ADOException Convert(ISQLExceptionConverter converter, Exception sqlException, string message)
{
return Convert(converter, sqlException, message, new SqlString(SQLNotAvailable));
}
/// <summary>
/// Converts the given SQLException into NHibernate's ADOException hierarchy, as well as performing
/// appropriate logging.
/// </summary>
/// <param name="converter">The converter to use.</param>
/// <param name="sqlException">The exception to convert.</param>
/// <param name="message">An optional error message.</param>
/// <param name="sql">The SQL executed.</param>
/// <returns> The converted <see cref="ADOException"/>.</returns>
public static ADOException Convert(ISQLExceptionConverter converter, Exception sqlException, string message, SqlString sql)
{
ADOExceptionReporter.LogExceptions(sqlException, ExtendMessage(message, sql, null, null));
return converter.Convert(sqlException, message, sql);
}
