protected virtual void OpenInitialConnectionAndTransaction()
        {
            if (this.m_dataSource.Transaction && this.m_mergeTran)
            {
                AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.DataSourceInfo dataSourceInfo = this.m_odpContext.GlobalDataSourceInfo[this.m_dataSource.Name];
                if (dataSourceInfo != null)
                {
                    this.m_connection  = dataSourceInfo.Connection;
                    this.m_transaction = dataSourceInfo.TransactionInfo;
                }
            }
            Global.Tracer.Trace(TraceLevel.Verbose, "Data source '{0}': Transaction = {1}, MergeTran = {2}, NumDataSets = {3}", this.m_dataSource.Name.MarkAsModelInfo(), this.m_dataSource.Transaction, this.m_mergeTran, this.m_runtimeDataSets.Count);
            if (this.m_connection == null)
            {
                AspNetCore.ReportingServices.ReportIntermediateFormat.DataSet dataSet = this.m_runtimeDataSets[0].DataSet;
                this.m_connection            = RuntimeDataSource.OpenConnection(this.m_dataSource, dataSet, this.m_odpContext, this.m_executionMetrics);
                this.m_needToCloseConnection = true;
                Global.Tracer.Trace(TraceLevel.Verbose, "Data source '{0}': Created a connection.", this.m_dataSource.Name.MarkAsModelInfo());
            }
            bool flag = false;

            if (this.m_dataSource.Transaction)
            {
                if (this.m_transaction == null)
                {
                    IDbTransaction transaction = this.m_connection.BeginTransaction();
                    Global.Tracer.Trace(TraceLevel.Verbose, "Data source '{0}': Begun a transaction.", this.m_dataSource.Name.MarkAsModelInfo());
                    this.m_transaction        = new AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.TransactionInfo(transaction);
                    this.m_isTransactionOwner = true;
                }
                IDbTransactionExtension dbTransactionExtension = this.m_transaction.Transaction as IDbTransactionExtension;
                flag = (dbTransactionExtension != null && dbTransactionExtension.AllowMultiConnection);
                this.m_useConcurrentDataSetProcessing &= flag;
                Global.Tracer.Trace(TraceLevel.Verbose, "Data source '{0}': TransactionCanSpanConnections = {1}, ConcurrentDataSets = {2}", this.m_dataSource.Name.MarkAsModelInfo(), flag, this.m_useConcurrentDataSetProcessing);
            }
            this.MergeAutoCollationSettings(this.m_connection);
            if (this.m_isTransactionOwner && this.m_report.SubReportMergeTransactions && !this.m_odpContext.ProcessReportParameters)
            {
                IDbConnection connection;
                if (flag)
                {
                    connection = null;
                    this.m_isGlobalConnection = false;
                }
                else
                {
                    connection = this.m_connection;
                    this.m_isGlobalConnection = true;
                }
                Global.Tracer.Trace(TraceLevel.Verbose, "Data source '{0}': Storing trans+conn into GlobalDataSourceInfo. CloseConnection = {1}.", this.m_dataSource.Name.MarkAsModelInfo(), this.m_needToCloseConnection);
                DataSourceInfo dataSourceInfo2 = RuntimeDataSource.GetDataSourceInfo(this.m_dataSource, this.m_odpContext);
                this.m_odpContext.GlobalDataSourceInfo.Add(this.m_dataSource, connection, this.m_transaction, dataSourceInfo2);
                this.m_isGlobalTransaction = true;
            }
        }
Exemple #2
0
        protected IDataReader RunLiveQuery(List <AspNetCore.ReportingServices.ReportIntermediateFormat.ParameterValue> queryParams, object[] paramValues)
        {
            IDataReader          dataReader = null;
            IDbCommand           dbCommand  = null;
            ViewerJobContextImpl jobContext = (ViewerJobContextImpl)this.m_odpContext.JobContext;

            if (this.m_dataSourceConnection == null)
            {
                this.m_dataSourceConnection = RuntimeDataSource.OpenConnection(this.m_dataSource, this.m_dataSet, this.m_odpContext, this.m_executionMetrics);
            }
            if (string.IsNullOrEmpty(this.m_dataSourceConnection.ConnectionString) && !string.IsNullOrEmpty(this.m_dataSource.ConnectStringExpression.OriginalText))
            {
                this.m_dataSourceConnection.ConnectionString = this.m_dataSource.ConnectStringExpression.OriginalText;
            }
            try
            {
                this.m_executionMetrics.StartTimer(DataProcessingMetrics.MetricType.Query);
                dbCommand = this.CreateCommand();
                this.SetCommandParameters(dbCommand, queryParams, paramValues);
                string commandText = this.SetCommandText(dbCommand);
                this.StoreCommandText(commandText);
                this.SetCommandType(dbCommand);
                this.SetTransaction(dbCommand);
                this.m_odpContext.CheckAndThrowIfAborted();
                //todo : delete;
                //var ss=System.AppDomain.CurrentDomain.GetAssemblies().Select(t => t.FullName).OrderBy(t => t).ToList();

                this.SetCommandTimeout(dbCommand);
                this.ExtractRewrittenCommandText(dbCommand);
                this.SetRestartPosition(dbCommand);
                DataSourceInfo dataSourceInfo = null;
                if (dbCommand is IDbImpersonationNeededForCommandCancel)
                {
                    dataSourceInfo = this.m_dataSource.GetDataSourceInfo(this.m_odpContext);
                }
                this.m_command = dbCommand;
                this.m_commandWrappedForCancel = new CommandWrappedForCancel(this.m_command, this.m_odpContext.CreateAndSetupDataExtensionFunction, this.m_dataSource, dataSourceInfo, this.m_dataSet.Name, this.m_dataSourceConnection);
                if (jobContext != null)
                {
                    jobContext.SetAdditionalCorrelation(this.m_command);
                    jobContext.ApplyCommandMemoryLimit(this.m_command);
                }
                DataSourceErrorInspector errorInspector = this.CreateErrorInspector();
                dataReader = this.ExecuteReader(jobContext, errorInspector, commandText);
                this.StoreDataReader(dataReader, errorInspector);
                return(dataReader);
            }
            catch (RSException ex)
            {
                this.EagerInlineCommandAndReaderCleanup(ref dataReader, ref dbCommand);
                throw;
            }
            catch (Exception e)
            {
                if (AsynchronousExceptionDetection.IsStoppingException(e))
                {
                    throw;
                }
                this.EagerInlineCommandAndReaderCleanup(ref dataReader, ref dbCommand);
                throw;
            }
            finally
            {
                this.m_executionMetrics.RecordTimerMeasurement(DataProcessingMetrics.MetricType.Query);
            }
        }