public TransactionEventArgs(IDataSource dataSource, IsolationLevel isolationLevel, bool autoPersistAllOnCommit)
     : base()
 {
     m_DataSource = dataSource;
     m_IsolationLevel = isolationLevel;
     m_AutoPersistAllOnCommit = autoPersistAllOnCommit;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ExecutionToken" /> class.
 /// </summary>
 /// <param name="dataSource">The data source.</param>
 /// <param name="operationName">Name of the operation.</param>
 /// <param name="commandText">The command text.</param>
 /// <param name="commandType">Type of the command.</param>
 protected ExecutionToken(IDataSource dataSource, string operationName, string commandText, CommandType commandType)
 {
     DataSource = dataSource;
     OperationName = operationName;
     CommandText = commandText;
     CommandType = commandType;
 }

 internal void notifyLocalDataSorceSetup(IDataSource localDataSource)
 {
     if (this.LocalDataSourceAdded != null)
     {
         this.LocalDataSourceAdded(this, new LocalDataSourceAddedEventArgs() { dataSource = localDataSource });
     }
 }

        public AcquisitionEngine(IDataSource source)
        {
            samplesOverflowSink = new List<float>();

            overviewWfLastCapture = DateTime.Now;
            overviewWf = new Waveform(1, 6000000);

            TriggerSources = new List<ITrigger>();
            TriggerSources.Add(new FreeRunning());
            TriggerSources.Add(new Edge());

            Trigger = new Edge(); // TODO: Temporary trigger

            Source = source;
            Source.Data += ProcessWaveform;
            Source.Data += Source_Data;
            Source.HighresVoltage += Source_HighresVoltage;

            Source.Connect(null);
            var dummyCfg = new NetStreamConfiguration();
            dummyCfg.AdcSpeed = 0;
            dummyCfg.AfeGain = 0;
            dummyCfg.UseFastAdc = false;

            Source.Configure(dummyCfg);
        }

		public virtual object ExecuteScalar(string sql, IDataSource dataSource, IList parameters)
		{
			this.Context.LogManager.Info(this, "Executing scalar sql query", "Sql: " + sql); // do not localize
			IDbConnection connection;
			IDbCommand cmd;
			object result;
			ITransaction transaction;
			SqlExecutorCancelEventArgs e = new SqlExecutorCancelEventArgs(sql, dataSource, parameters);
			this.Context.EventManager.OnExecutingSql(this, e);
			if (e.Cancel)
			{
				this.Context.LogManager.Warn(this, "Executing scalar sql query canceled by observer!", "Sql: " + sql); // do not localize
				return 0;
			}
			sql = e.Sql;
			dataSource = e.DataSource;
			parameters = e.Parameters;
			connection = dataSource.GetConnection();
			cmd = connection.CreateCommand();
			cmd.CommandType = CommandType.Text;
			cmd.CommandText = sql;
			AddParametersToCommand(cmd, parameters);
			transaction = this.Context.GetTransaction(connection);
			if (transaction != null)
			{
				cmd.Transaction = transaction.DbTransaction;
			}
			result = cmd.ExecuteScalar();
			dataSource.ReturnConnection();
			
			SqlExecutorEventArgs e2 = new SqlExecutorEventArgs(sql, dataSource, parameters);

			this.Context.EventManager.OnExecutedSql(this, e2);
			return result;
		}

        internal static MetaTable GetTableWithFullFallback(IDataSource dataSource, HttpContextBase context) {
            MetaTable table = GetTableFromMapping(context, dataSource);
            if (table != null) {
                return table;
            }

            IDynamicDataSource dynamicDataSource = dataSource as IDynamicDataSource;
            if (dynamicDataSource != null) {
                table = GetTableFromDynamicDataSource(dynamicDataSource);
                if (table != null) {
                    return table;
                }
            }

            table = DynamicDataRouteHandler.GetRequestMetaTable(context);
            if (table != null) {
                return table;
            }

            Control c = dataSource as Control;
            string id = (c != null ? c.ID : String.Empty);
            throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                DynamicDataResources.MetaTableHelper_CantFindTable,
                id));
        }

		public Transaction(IDbTransaction dbTransaction, IDataSource dataSource, IContext ctx) : base(ctx)
		{
			m_DbTransaction = dbTransaction;
			m_DataSource = dataSource;
			m_OriginalKeepOpen = m_DataSource.KeepConnectionOpen;
			m_DataSource.KeepConnectionOpen = true;
		}

 public bool? ExecuteBool(IDataSource dataSource)
 {
     var val = _root.GetValue(dataSource);
     var valType = val.GetValueType();
     if (valType != ValueType.Bool) throw new Exception("Return value is not boolean");
     return val.AsBool();
 }

        /// <summary>
        /// Discover at run time the appropriate set of Parameters for a stored procedure
        /// </summary>
		/// <param name="session">An IDalSession object</param>
		/// <param name="spName">Name of the stored procedure.</param>
        /// <param name="includeReturnValueParameter">if set to <c>true</c> [include return value parameter].</param>
        /// <returns>The stored procedure parameters.</returns>
		private IDataParameter[] InternalDiscoverSpParameterSet(
            IDataSource dataSource, 
            string spName, 
            bool includeReturnValueParameter)
		{
            IDbCommand dbCommand = dataSource.DbProvider.CreateCommand();
            dbCommand.CommandType = CommandType.StoredProcedure;

            using (dbCommand)
			{
				cmd.CommandText = spName;

			    // The session connection object is always created but the connection is not alwys open
			    // so we try to open it in case.
				session.OpenConnection();

				DeriveParameters(session.DataSource.DbProvider, cmd);

				if (cmd.Parameters.Count > 0) {
					IDataParameter firstParameter = (IDataParameter)cmd.Parameters[0];
					if (firstParameter.Direction == ParameterDirection.ReturnValue) {
						if (!includeReturnValueParameter) {
							cmd.Parameters.RemoveAt(0);
						}
					}	
				}


				IDataParameter[] discoveredParameters = new IDataParameter[cmd.Parameters.Count];
				cmd.Parameters.CopyTo(discoveredParameters, 0);
				return discoveredParameters;
			}
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="DataAccessIntentHandler"/> class.
        /// </summary>
        public DataAccessIntentHandler(IIntentManager intentManager,
            INetworkSearchConfigBuilder networkSearchConfigBuilder,
            IDataSourcesAndSchema dataSourcesAndSchema,
            IExploreConfigBuilder exploreConfigBuilder,
            INotificationService notificationService,
            IExplorationIntentFactory explorationIntentFactory,
            IAcxiomConstants acxiomConstants)
        {
            mIntentManager = intentManager;
            mNetworkSearchConfigBuilder = networkSearchConfigBuilder;
            mDataSourcesAndSchema = dataSourcesAndSchema;
            mExploreConfigBuilder = exploreConfigBuilder;
            mNotificationService = notificationService;
            mExplorationIntentFactory = explorationIntentFactory;
            mAcxiomConstants = acxiomConstants;

            mDataSource = mDataSourcesAndSchema.DataSources.SingleOrDefault(x => x.Id.Equals(mAcxiomConstants.AcxiomDaodExternalContextRoot));

            if (mDataSource == null)
            {
                string extractDataSourceNotFound = string.Format(AcxiomStringResources.ErrorExternalDataSourceNotFound, mAcxiomConstants.AcxiomDaodExternalContextRoot);
                mNotificationService.PresentInformationNotificationWithoutDiagnosticsToTheUser(extractDataSourceNotFound);
                throw new ArgumentException(string.Format(CultureInfo.InvariantCulture,
                                                          AcxiomStringResources.ErrorExternalDataSourceNotFound,
                                                          mAcxiomConstants.AcxiomDaodExternalContextRoot));
            }
        }

 public static bool ContainsListCollection(IDataSource dataSource) {
     ICollection viewNames = dataSource.GetViewNames();
     if (viewNames != null && viewNames.Count > 0) {
         return true;
     }
     return false;
 }

 private void SetDataSource(IDataSource dataSource, ILayer layer)
 {
     this.Clear();
     this.activeDataSources.Add(dataSource);
     this.videoControl.AddLayer(layer);
     dataSource.Start();
 }

        public RemoteDataService(IDataSource dataSource, IAppSettings appSettings)
        {
            _appSettings = appSettings;
            _dataSource = dataSource;

            _httpClient = new HttpClient();
        }

        private DataParams GetDataParams(DataId dataId, string folder, IDataSource dataSource)
        {
            var fileName = String.Format("{0}{1}.csv", dataId.Symbol, (int) dataId.Period);
            var path = Path.Combine(folder, "Data", dataId.Source, fileName);

            var dataParams = new DataParams
            {
                DataSourceName = dataId.Source,
                Symbol = dataId.Symbol,
                Period = dataId.Period,
                DataId = dataId,
                Path = path,
                StartDate = dataSource.StartDate,
                EndDate = dataSource.EndDate,
                IsUseStartDate = dataSource.IsUseStartDate,
                IsUseEndDate = dataSource.IsUseEndDate,
                MaximumBars = dataSource.MaximumBars,
                MaxIntrabarBars = dataSource.MaxIntrabarBars,
                MinimumBars = dataSource.MinimumBars,
                IsCheckDataAtLoad = dataSource.IsCheckDataAtLoad,
                IsCutOffBadData = dataSource.IsCutOffBadData,
                IsCutOffSatSunData = dataSource.IsCutOffSatSunData,
                IsFillInDataGaps = dataSource.IsFillInDataGaps,
                IsCacheData = dataSource.IsCacheDataFiles,
                IsLongData = false
            };

            return dataParams;
        }

        public HomeController(IDataSource dataSource, IDomainFactory domainFactory)
        {
            Contract.Requires(dataSource != null);
            Contract.Requires(domainFactory != null);

            domain = domainFactory.Create(dataSource);
        }

        // DEFAULT CONSTRUCTOR
        #region Public Methods and Operators

        /// <summary>
        /// Add data source from <paramref name="datasourceBean"/> to <paramref name="datasourceType"/>
        /// </summary>
        /// <param name="datasourceBean">
        /// The data source SDMX Object.
        /// </param>
        /// <param name="datasourceType">
        /// The data source LINQ2XSD object.
        /// </param>
        public void AddDatasource(IDataSource datasourceBean, DatasourceType datasourceType)
        {
            if (datasourceBean.SimpleDatasource)
            {
                if (datasourceBean.DataUrl != null)
                {
                    datasourceType.SimpleDatasource = datasourceBean.DataUrl;
                }
            }
            else
            {
                var queryableDatasourceType = new QueryableDatasourceType();
                datasourceType.QueryableDatasource = queryableDatasourceType;
                if (datasourceBean.DataUrl != null)
                {
                    queryableDatasourceType.DataUrl = datasourceBean.DataUrl;
                }

                queryableDatasourceType.isRESTDatasource = datasourceBean.RESTDatasource;
                queryableDatasourceType.isWebServiceDatasource = datasourceBean.WebServiceDatasource;
                if (datasourceBean.WsdlUrl != null)
                {
                    queryableDatasourceType.WSDLUrl = datasourceBean.WsdlUrl;
                }
            }
        }

 public App(int appId, int zoneId, PortalSettings ownerPS, IDataSource parentSource = null)
 {
     AppId = appId;
     ZoneId = zoneId;
     //InitialSource = parentSource;
     OwnerPS = ownerPS;
 }

 public SqlExecutorEventArgs(string sql, IDataSource ds, IList parameters)
     : base()
 {
     m_Sql = sql;
     m_DataSource = ds;
     m_Parameters = parameters;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="MaterializerCompilerEventArgs" /> class.
 /// </summary>
 /// <param name="dataSource">The data source.</param>
 /// <param name="sql">The SQL.</param>
 /// <param name="code">The code.</param>
 /// <param name="targetType">Type of the target.</param>
 /// <param name="exception">The exception.</param>
 public MaterializerCompilerEventArgs(IDataSource dataSource, string sql, string code, Type targetType, Exception exception = null)
 {
     Exception = exception;
     TargetType = targetType;
     Code = code;
     Sql = sql;
     DataSource = dataSource;
 }

		internal static ITransaction GetTransaction(IDataSource dataSource, IsolationLevel isolationLevel, bool beginTransaction) {
			IDbConnection connection = dataSource.OpenConnection();
			Transaction transaction = new Transaction(connection, isolationLevel);
			if(beginTransaction) {
				transaction.Begin();
			}
			return transaction;
		}