/// <summary>
/// Clears all internal caches.
/// </summary>
/// <param name="mode">The clear mode.</param>
public override void ClearCache(ClearCacheMode mode)
{
base.ClearCache(mode);
typeLock.EnterWriteLock();
try
{
unifiedTypes.Clear();
unifiedTypes.Add(VoidType, VoidType);
unifiedTypes.Add(StringType, StringType);
foreach (var basicType in BasicValueTypes)
{
var type = GetPrimitiveType(basicType);
unifiedTypes.Add(type, type);
}
unifiedTypes.Add(IndexType, IndexType);
}
finally
{
typeLock.ExitWriteLock();
}
}
/// <summary>
/// Clears all internal caches.
/// </summary>
/// <param name="mode">The clear mode.</param>
public void ClearCache(ClearCacheMode mode)
{
lock (syncRoot)
{
Backend.ClearCache(mode);
ClearKernelCache_SyncRoot();
}
}
/// <summary>
/// Clears all internal caches.
/// </summary>
/// <param name="mode">The clear mode.</param>
public virtual void ClearCache(ClearCacheMode mode)
{
// Synchronize all accesses below using a write scope
using var writeScope = cachingLock.EnterWriteScope();
typeInfoMapping.Clear();
InitIntrinsicTypeInformation();
}
/// <summary>
/// Clears internal caches. However, this does not affect individual accelerator
/// caches.
/// </summary>
/// <param name="mode">The clear mode.</param>
/// <remarks>
/// This method is not thread-safe.
/// </remarks>
public override void ClearCache(ClearCacheMode mode)
{
IRContext.ClearCache(mode);
TypeContext.ClearCache(mode);
DebugInformationManager.ClearCache(mode);
DefautltILBackend.ClearCache(mode);
RuntimeSystem.ClearCache(mode);
base.ClearCache(mode);
}
/// <summary>
/// Clears all internal caches.
/// </summary>
/// <param name="mode">The clear mode.</param>
public virtual void ClearCache(ClearCacheMode mode)
{
cachingLock.EnterWriteLock();
try
{
typeInformation.Clear();
}
finally
{
cachingLock.ExitWriteLock();
}
}
/// <summary>
/// Clears all internal caches.
/// </summary>
/// <param name="mode">The clear mode.</param>
public virtual void ClearCache(ClearCacheMode mode)
{
cachingLock.EnterWriteLock();
try
{
typeInfoMapping.Clear();
InitIntrinsicTypeInformation();
}
finally
{
cachingLock.ExitWriteLock();
}
}
public static ProcedureContext CreateForLiveExecution(string statement, ClearCacheMode clearCacheMode, int queryResultRowLimit, string clientVersion, string clientType)
{
return(new ProcedureContext(ProcedureExecutionMode.Live, statement, clearCacheMode, queryResultRowLimit, clientVersion, clientType));
}
public static ProcedureContext CreateForBatchExecution(string statement, ClearCacheMode clearCacheMode, string batchID, string batchConnectionString, string clientVersion, string clientType, string batchName)
{
int queryResultRowLimit = 0;
return(new ProcedureContext(ProcedureExecutionMode.Batch, statement, clearCacheMode, queryResultRowLimit, clientVersion, clientType, batchID, batchConnectionString, batchName));
}
private ProcedureContext(ProcedureExecutionMode executionMode, string statement, ClearCacheMode clearCacheMode, int queryResultRowLimit = 0, string clientVersion = null, string clientType = null, string batchID = null, string batchConnectionString = null, string batchName = null)
{
#region Argument exception
if (statement == null)
{
throw new ArgumentNullException("statement");
}
if (executionMode == ProcedureExecutionMode.Batch ^ batchID != null)
{
throw new ArgumentException("ExecutionMode XOR batchID");
}
if (executionMode == ProcedureExecutionMode.Batch ^ batchConnectionString != null)
{
throw new ArgumentException("ExecutionMode XOR BatchConnectionString");
}
#endregion
_batchConnectionString = batchConnectionString;
_cancellationSource = new CancellationTokenSource();
Statement = statement;
ExecutionMode = executionMode;
BatchID = Guid.Parse(batchID ?? Guid.Empty.ToString());
ExecutionID = Guid.NewGuid();
BatchName = batchName;
CubeName = statement.GetCubeName();
QueryResultRowLimit = queryResultRowLimit;
DatabaseName = AdomdServer.Context.CurrentDatabaseName;
ConnectionUserName = AdomdServer.Context.CurrentConnection.User.Name;
ImpersonationIdentity = WindowsIdentity.GetCurrent();
ExecuteForPrepare = AdomdServer.Context.ExecuteForPrepare;
CurrentTraceEvents = ProfilerCollector.CurrentTraceEvents();
ASQAServerVersion = GetAsqaServerVersion().ToString();
ASQAServerConfig = GetRawConfiguration();
ClientVersion = clientVersion;
ClientType = clientType;
SystemPhysicalMemory = PInvokeHelper.GetPhysicalSystemMemory();
SystemOperativeSystemName = PInvokeHelper.GetOperatingSystemName();
SystemLogicalCpuCore = Environment.ProcessorCount;
GetConfigurationDetails(out int configuredTraceEventsThreshold, out ClearCacheMode configuredClearCacheMode);
TraceEventsThreshold = configuredTraceEventsThreshold;
ClearCacheMode = clearCacheMode == ClearCacheMode.Default ? configuredClearCacheMode : clearCacheMode;
var ssasInfo = GetServerInfo();
SSASInstanceName = AdomdServer.Context.CurrentServerID;
SSASInstanceVersion = ssasInfo.Item1;
SSASInstanceEdition = ssasInfo.Item2;
SSASInstanceConfig = ssasInfo.Item3;
if (executionMode == ProcedureExecutionMode.Batch)
{
var sqlInfo = BatchHelper.GetServerInfo(this);
SQLInstanceName = sqlInfo.Item1;
SQLInstanceVersion = sqlInfo.Item2;
SQLInstanceEdition = sqlInfo.Item3;
CheckBatchVersionCompatibility(version: sqlInfo.Item4);
}
CubeMetadata = XmlaHelper.RetrieveCubeMetadata(this);
ProcedureContext.CheckVersionCompatibility(SSASInstanceVersion);
}
/// <summary>
/// Clears all internal caches.
/// </summary>
/// <param name="mode">The clear mode.</param>
public void ClearCache(ClearCacheMode mode)
{
Dispose(ref cache);
}
/// <summary> /// Clears all internal caches. /// </summary> /// <param name="mode">The clear mode.</param> /// <remarks>This method is not thread-safe.</remarks> public virtual void ClearCache(ClearCacheMode mode) => ForEachExtension(extension => extension.ClearCache(mode));
/// <summary>
/// Execute server-side AnalyzeBatch procedure
/// </summary>
public async Task <AnalyzerStatistics> AnalyzeBatchAsync(string connectionStringBatch, string statement, ClearCacheMode clearCacheMode = ClearCacheMode.Default, string xconfig = null, string batchName = null, bool throwOnError = true)
{
#region Argument exception
if (connectionStringBatch == null)
{
throw new ArgumentNullException("connectionStringBatch");
}
if (statement == null)
{
throw new ArgumentNullException("statement");
}
#endregion
var currentProcess = Process.GetCurrentProcess();
var processName = currentProcess.ProcessName;
var clientVersion = "{0} ({1})".FormatWith(currentProcess.MainModule.FileVersionInfo.FileVersion, ClientVersion);
#if DEBUG
Func <Guid, ClearCacheMode, string> commandAnalyze = (batchID, cacheMode) => "call {0}.AnalyzeBatchWithDebug(\"{1}\", {2}, \"{3}\", \"{4}\", \"{5}\", \"{6}\", \"{7}\", \"{8}\");".FormatWith(ClrAssemblyID, statement.EscapeMdxString(), (int)cacheMode, batchID, connectionStringBatch.EscapeMdxString(), clientVersion, processName, batchName, throwOnError);
#else
Func <Guid, ClearCacheMode, string> commandAnalyze = (batchID, cacheMode) => "call {0}.AnalyzeBatch(\"{1}\", {2}, \"{3}\", \"{4}\", \"{5}\", \"{6}\", \"{7}\", \"{8}\");".FormatWith(ClrAssemblyID, statement.EscapeMdxString(), (int)cacheMode, batchID, connectionStringBatch.EscapeMdxString(), clientVersion, processName, batchName, throwOnError);
#endif
Func <AnalyzerStatistics> analyzeProcedure = () =>
{
ExecutionProgressControl?.StartMonitor_Batch();
try
{
var batchID = Guid.NewGuid();
var coldCacheExecutionResult = AnalysisServicesHelper.ExecuteForDataSet(_connectionString, commandAnalyze(batchID, clearCacheMode), _cancellationTokenSource.Token).ToAnalyzerExecutionResult(dispose: true);
var warmCacheExecutionResult = AnalysisServicesHelper.ExecuteForDataSet(_connectionString, commandAnalyze(batchID, ClearCacheMode.Nothing), _cancellationTokenSource.Token).ToAnalyzerExecutionResult(dispose: true);
return(AnalyzerStatistics.CreateFromAnalyzerExecutionResults(coldCacheExecutionResult, warmCacheExecutionResult));
}
finally
{
ExecutionProgressControl?.StopMonitor_Batch();
}
};
using (_cancellationTokenSource = new CancellationTokenSource())
{
using (var task = Task.Factory.StartNew(analyzeProcedure))
return(await task.ConfigureAwait(continueOnCapturedContext : false));
}
}
/// <summary>
/// Execute server-side Analyze procedure
/// </summary>
public async Task <AnalyzerStatistics> AnalyzeAsync(string statement, ClearCacheMode clearCacheMode = ClearCacheMode.Default, int queryResultRowLimit = 0)
{
#region Argument exception
if (statement == null)
{
throw new ArgumentNullException("statement");
}
#endregion
var currentProcess = Process.GetCurrentProcess();
var processName = currentProcess.ProcessName;
var clientVersion = "{0} ({1})".FormatWith(currentProcess.MainModule.FileVersionInfo.FileVersion, ClientVersion);
#if DEBUG
Func <ClearCacheMode, string> commandAnalyze = (cacheMode) => "call {0}.AnalyzeWithDebug(\"{1}\", {2}, {3}, \"{4}\", \"{5}\");".FormatWith(ClrAssemblyID, statement.EscapeMdxString(), (int)cacheMode, queryResultRowLimit, clientVersion, processName);
#else
Func <ClearCacheMode, string> commandAnalyze = (cacheMode) => "call {0}.Analyze(\"{1}\", {2}, {3}, \"{4}\", \"{5}\");".FormatWith(ClrAssemblyID, statement.EscapeMdxString(), (int)cacheMode, queryResultRowLimit, clientVersion, processName);
#endif
Action <DataSet, string> saveDebug = (data, dbgType) =>
{
if (!DebugToXml)
{
return;
}
var debugPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"SSASQueryAnalyzer\debug");
Directory.CreateDirectory(debugPath);
data.WriteXml(Path.Combine(debugPath, "AnalyzerExecutionResult-{0:yyyyMMdd-hhmmss-fff}.{1}").FormatWith(DateTime.Now, dbgType), XmlWriteMode.WriteSchema);
};
Func <AnalyzerStatistics> analyzeProcedure = () =>
{
ExecutionProgressControl?.StartMonitor();
try
{
AnalyzerExecutionResult coldCacheExecutionResult;
AnalyzerExecutionResult warmCacheExecutionResult;
using (var data = AnalysisServicesHelper.ExecuteForDataSet(_connectionString, commandAnalyze(clearCacheMode), _cancellationTokenSource.Token))
{
saveDebug(data, "xqac");
coldCacheExecutionResult = data.ToAnalyzerExecutionResult(dispose: true);
}
ExecutionProgressControl?.ColdCacheExecutionCompleted();
using (var data = AnalysisServicesHelper.ExecuteForDataSet(_connectionString, commandAnalyze(ClearCacheMode.Nothing), _cancellationTokenSource.Token))
{
saveDebug(data, "xqaw");
warmCacheExecutionResult = data.ToAnalyzerExecutionResult(dispose: true);
}
ExecutionProgressControl?.WarmCacheExecutionCompleted();
return(AnalyzerStatistics.CreateFromAnalyzerExecutionResults(coldCacheExecutionResult, warmCacheExecutionResult));
}
finally
{
ExecutionProgressControl?.StopMonitor();
}
};
using (_cancellationTokenSource = new CancellationTokenSource())
{
using (var task = Task.Factory.StartNew(analyzeProcedure))
return(await task.ConfigureAwait(continueOnCapturedContext : false));
}
}
public static AnalyzerExecutionResult CreateFromBatch(string connectionStringBatch, string batchID, ClearCacheMode clearCacheMode)
{
// TODO: parallelizzare e sistemare codice
Action <string, Action <DataTable>, Action <SqlParameterCollection> > load = (commandText, action, param) =>
{
using (var connection = new SqlConnection(connectionStringBatch))
{
connection.Open();
using (var command = connection.CreateCommand())
{
command.CommandType = CommandType.StoredProcedure;
command.CommandText = commandText;
command.Parameters.Add(new SqlParameter("@batchID", SqlDbType.UniqueIdentifier)).Value = Guid.Parse(batchID);
command.Parameters.Add(new SqlParameter("@clearCacheMode", SqlDbType.NVarChar)).Value = clearCacheMode;
param(command.Parameters);
using (var reader = command.ExecuteReader())
using (var table = new DataTable())
{
table.Load(reader);
action(table);
}
}
}
};
var result = new AnalyzerExecutionResult();
load("[asqa].[sp_read_CommonEnginePerformance]", (table) => result.EnginePerformances = EnginePerformanceCollection.CreateFromDataTable(table), (param) => { });
load("[asqa].[sp_read_CommonAggregationsRead]", (table) => result.AggregationsReads = AggregationsReadCollection.CreateFromDataTable(table), (param) => { });
load("[asqa].[sp_read_CommonPartitionsRead]", (table) => result.PartitionsReads = PartitionsReadCollection.CreateFromDataTable(table), (param) => { });
load("[asqa].[sp_read_CommonCachesRead]", (table) => result.CachesReads = CachesReadCollection.CreateFromDataTable(table), (param) => { });
load("[asqa].[sp_read_ExecutionInfo]", (table) => result.ExecutionInfo = table.Copy(), (param) => { });
#region Load performance
DataTable performanceTypes = null;
load("[asqa].[sp_read_PerformanceTypes]", (table) => performanceTypes = table.Copy(), (param) => { });
result.Performances = new PerformanceItemCollectionList();
foreach (DataRow type in performanceTypes.Rows)
{
string category = Convert.ToString(type["CategoryName"]);
string name = Convert.ToString(type["CounterName"]);
load("[asqa].[sp_read_Performance]",
(table) => result.Performances.Add(PerformanceItemCollection.CreateFromDataTable(table, category, name)),
(param) =>
{
param.Add(new SqlParameter("@categoryName", SqlDbType.NVarChar)).Value = category;
param.Add(new SqlParameter("@counterName", SqlDbType.NVarChar)).Value = name;
});
}
#endregion
#region Load trace
DataTable profilerTypes = null;
load("[asqa].[sp_read_TraceTypes]", (table) => profilerTypes = table.Copy(), (param) => { });
result.Profilers = new ProfilerItemCollectionList();
foreach (DataRow type in profilerTypes.Rows)
{
string eventClass = type["EventClass"].ToString();
load("[asqa].[sp_read_Trace]",
(table) => result.Profilers.Add(ProfilerItemCollection.CreateFromDataTable(table, eventClass)),
(param) => param.Add(new SqlParameter("@eventClass", SqlDbType.NVarChar)).Value = eventClass);
}
#endregion
return(result);
}
/// <summary> /// Clears all internal caches. /// </summary> /// <param name="mode">Not used.</param> public void ClearCache(ClearCacheMode mode) => ReloadAssemblyBuilder();
/// <summary>
/// Clears all internal caches.
/// </summary>
/// <param name="mode">The clear mode.</param>
/// <remarks>This method is not thread-safe.</remarks>
public override void ClearCache(ClearCacheMode mode)
{
base.ClearCache(mode);
intrinsicProvider.ClearCache(mode);
}
/// <summary>
/// Clears all internal caches.
/// </summary>
/// <param name="mode">The clear mode.</param>
public virtual void ClearCache(ClearCacheMode mode)
{
}
