/// <inheritdoc/>
        protected override SqlDriver CreateDriver(string connectionString, SqlDriverConfiguration configuration)
        {
            using (var connection = new FbConnection(connectionString)) {
                connection.Open();
                SqlHelper.ExecuteInitializationSql(connection, configuration);
                var dataSource     = new FbConnectionStringBuilder(connectionString).DataSource;
                var defaultSchema  = GetDefaultSchema(connection);
                var coreServerInfo = new CoreServerInfo {
                    ServerVersion            = GetVersionFromServerVersionString(connection.ServerVersion),
                    ConnectionString         = connectionString,
                    MultipleActiveResultSets = true,
                    DatabaseName             = defaultSchema.Database,
                    DefaultSchemaName        = defaultSchema.Schema,
                };

                if (Int32.Parse(coreServerInfo.ServerVersion.Major.ToString() + coreServerInfo.ServerVersion.Minor.ToString()) < 25)
                {
                    throw new NotSupportedException(Strings.ExFirebirdBelow25IsNotSupported);
                }
                if (coreServerInfo.ServerVersion.Major == 2 && coreServerInfo.ServerVersion.Minor == 5)
                {
                    return(new v2_5.Driver(coreServerInfo));
                }
                return(null);
            }
        }
 /// <inheritdoc/>
 protected override SqlDriver CreateDriver(string connectionString, SqlDriverConfiguration configuration)
 {
     using (var connection = new OracleConnection(connectionString)) {
         connection.Open();
         SqlHelper.ExecuteInitializationSql(connection, configuration);
         var version = string.IsNullOrEmpty(configuration.ForcedServerVersion)
   ? ParseVersion(connection.ServerVersion)
   : new Version(configuration.ForcedServerVersion);
         var dataSource     = new OracleConnectionStringBuilder(connectionString).DataSource;
         var defaultSchema  = GetDefaultSchema(connection);
         var coreServerInfo = new CoreServerInfo {
             ServerVersion            = version,
             ConnectionString         = connectionString,
             MultipleActiveResultSets = true,
             DatabaseName             = defaultSchema.Database,
             DefaultSchemaName        = defaultSchema.Schema,
         };
         if (version.Major < 9 || version.Major == 9 && version.Minor < 2)
         {
             throw new NotSupportedException(Strings.ExOracleBelow9i2IsNotSupported);
         }
         if (version.Major == 9)
         {
             return(new v09.Driver(coreServerInfo));
         }
         if (version.Major == 10)
         {
             return(new v10.Driver(coreServerInfo));
         }
         return(new v11.Driver(coreServerInfo));
     }
 }
示例#3
0
        /// <inheritdoc/>
        protected override async Task <SqlDriver> CreateDriverAsync(
            string connectionString, SqlDriverConfiguration configuration, CancellationToken token)
        {
            var isPooingOn = !IsPoolingOff(connectionString);

            configuration.EnsureConnectionIsAlive &= isPooingOn;

            var connection = await CreateAndOpenConnectionAsync(connectionString, configuration, token).ConfigureAwait(false);

            await using (connection.ConfigureAwait(false)) {
                var isEnsureAlive       = configuration.EnsureConnectionIsAlive;
                var forcedServerVersion = configuration.ForcedServerVersion;
                var isForcedVersion     = !string.IsNullOrEmpty(forcedServerVersion);
                var isForcedAzure       = isForcedVersion && forcedServerVersion.Equals("azure", StringComparison.OrdinalIgnoreCase);
                var isAzure             = isForcedAzure ||
                                          (!isForcedVersion && await IsAzureAsync(connection, token).ConfigureAwait(false));
                var parser = isAzure
          ? new ErrorMessageParser()
          : await CreateMessageParserAsync(connection, token).ConfigureAwait(false);

                var versionString = isForcedVersion
          ? isForcedAzure ? "10.0.0.0" : forcedServerVersion
          : connection.ServerVersion ?? string.Empty;
                var version       = new Version(versionString);
                var defaultSchema = await GetDefaultSchemaAsync(connection, token : token).ConfigureAwait(false);

                return(CreateDriverInstance(connectionString, isAzure, version, defaultSchema, parser, isEnsureAlive));
            }
        }
示例#4
0
        private static Version GetVersion(SqlDriverConfiguration configuration, NpgsqlConnection connection)
        {
            var version = string.IsNullOrEmpty(configuration.ForcedServerVersion)
        ? connection.PostgreSqlVersion
        : new Version(configuration.ForcedServerVersion);

            return(version);
        }
示例#5
0
        /// <inheritdoc/>
        protected override SqlDriver CreateDriver(string connectionString, SqlDriverConfiguration configuration)
        {
            using var connection = new SQLiteConnection(connectionString);
            connection.Open();
            SqlHelper.ExecuteInitializationSql(connection, configuration);
            var defaultSchema = GetDefaultSchema(connection);
            var version       = new Version(connection.ServerVersion ?? string.Empty);

            return(CreateDriverInstance(connectionString, version, defaultSchema));
        }
示例#6
0
        /// <inheritdoc/>
        protected override SqlDriver CreateDriver(string connectionString, SqlDriverConfiguration configuration)
        {
            using var connection = new OracleConnection(connectionString);
            connection.Open();
            SqlHelper.ExecuteInitializationSql(connection, configuration);
            var version = string.IsNullOrEmpty(configuration.ForcedServerVersion)
        ? ParseVersion(connection.ServerVersion)
        : new Version(configuration.ForcedServerVersion);
            var defaultSchema = GetDefaultSchema(connection);

            return(CreateDriverInstance(connectionString, version, defaultSchema));
        }
示例#7
0
        private async ValueTask OpenConnectionWithNotification(NpgsqlConnection connection,
                                                               SqlDriverConfiguration configuration,
                                                               bool isAsync,
                                                               CancellationToken cancellationToken = default)
        {
            var accessors = configuration.DbConnectionAccessors;

            if (!isAsync)
            {
                SqlHelper.NotifyConnectionOpening(accessors, connection);
                try {
                    connection.Open();
                    if (!string.IsNullOrEmpty(configuration.ConnectionInitializationSql))
                    {
                        SqlHelper.NotifyConnectionInitializing(accessors, connection, configuration.ConnectionInitializationSql);
                    }

                    SqlHelper.ExecuteInitializationSql(connection, configuration);
                    SqlHelper.NotifyConnectionOpened(accessors, connection);
                }
                catch (Exception ex) {
                    SqlHelper.NotifyConnectionOpeningFailed(accessors, connection, ex);
                    throw;
                }
            }
            else
            {
                await SqlHelper.NotifyConnectionOpeningAsync(accessors, connection, false, cancellationToken).ConfigureAwait(false);

                try {
                    await connection.OpenAsync(cancellationToken).ConfigureAwait(false);

                    if (!string.IsNullOrEmpty(configuration.ConnectionInitializationSql))
                    {
                        await SqlHelper.NotifyConnectionInitializingAsync(accessors,
                                                                          connection, configuration.ConnectionInitializationSql, false, cancellationToken)
                        .ConfigureAwait(false);
                    }

                    await SqlHelper.ExecuteInitializationSqlAsync(connection, configuration, cancellationToken).ConfigureAwait(false);

                    await SqlHelper.NotifyConnectionOpenedAsync(accessors, connection, false, cancellationToken).ConfigureAwait(false);
                }
                catch (Exception ex) {
                    await SqlHelper.NotifyConnectionOpeningFailedAsync(accessors, connection, ex, false, cancellationToken).ConfigureAwait(false);

                    throw;
                }
            }
        }
        private static async ValueTask OpenConnectionFast(FbConnection connection,
                                                          SqlDriverConfiguration configuration, bool isAsync, CancellationToken cancellationToken = default)
        {
            if (!isAsync)
            {
                connection.Open();
                SqlHelper.ExecuteInitializationSql(connection, configuration);
            }
            else
            {
                await connection.OpenAsync().ConfigureAwait(false);

                await SqlHelper.ExecuteInitializationSqlAsync(connection, configuration, cancellationToken).ConfigureAwait(false);
            }
        }
示例#9
0
        // Constructors

        public static StorageDriver Create(SqlDriverFactory driverFactory, DomainConfiguration configuration)
        {
            ArgumentValidator.EnsureArgumentNotNull(driverFactory, nameof(driverFactory));
            ArgumentValidator.EnsureArgumentNotNull(configuration, nameof(configuration));

            var driverConfiguration = new SqlDriverConfiguration {
                ForcedServerVersion         = configuration.ForcedServerVersion,
                ConnectionInitializationSql = configuration.ConnectionInitializationSql,
                EnsureConnectionIsAlive     = configuration.EnsureConnectionIsAlive,
            };

            var driver       = driverFactory.GetDriver(configuration.ConnectionInfo, driverConfiguration);
            var providerInfo = ProviderInfoBuilder.Build(configuration.ConnectionInfo.Provider, driver);

            return(new StorageDriver(driver, providerInfo, configuration, GetNullModel));
        }
示例#10
0
        /// <inheritdoc/>
        protected override async Task <SqlDriver> CreateDriverAsync(
            string connectionString, SqlDriverConfiguration configuration, CancellationToken token)
        {
            var connection = new SQLiteConnection(connectionString);

            await using (connection.ConfigureAwait(false)) {
                await connection.OpenAsync(token).ConfigureAwait(false);

                await SqlHelper.ExecuteInitializationSqlAsync(connection, configuration, token).ConfigureAwait(false);

                var defaultSchema = await GetDefaultSchemaAsync(connection, token : token).ConfigureAwait(false);

                var version = new Version(connection.ServerVersion ?? string.Empty);
                return(CreateDriverInstance(connectionString, version, defaultSchema));
            }
        }
示例#11
0
        protected override SqlDriver CreateDriver(string connectionString, SqlDriverConfiguration configuration)
        {
            using var connection = new NpgsqlConnection(connectionString);
            if (configuration.DbConnectionAccessors.Count > 0)
            {
                OpenConnectionWithNotification(connection, configuration, false).GetAwaiter().GetResult();
            }
            else
            {
                OpenConnectionFast(connection, configuration, false).GetAwaiter().GetResult();
            }
            var version       = GetVersion(configuration, connection);
            var defaultSchema = GetDefaultSchema(connection);

            return(CreateDriverInstance(connectionString, version, defaultSchema));
        }
示例#12
0
        protected override SqlDriver CreateDriver(string connectionString, SqlDriverConfiguration configuration)
        {
            using (var connection = new NpgsqlConnection(connectionString)) {
                connection.Open();
                SqlHelper.ExecuteInitializationSql(connection, configuration);
                var version = string.IsNullOrEmpty(configuration.ForcedServerVersion)
          ? connection.PostgreSqlVersion
          : new Version(configuration.ForcedServerVersion);
                var builder        = new NpgsqlConnectionStringBuilder(connectionString);
                var dataSource     = string.Format(DataSourceFormat, builder.Host, builder.Port, builder.Database);
                var defaultSchema  = GetDefaultSchema(connection);
                var coreServerInfo = new CoreServerInfo {
                    ServerVersion            = version,
                    ConnectionString         = connectionString,
                    MultipleActiveResultSets = false,
                    DatabaseName             = defaultSchema.Database,
                    DefaultSchemaName        = defaultSchema.Schema,
                };

                if (version.Major < 8 || version.Major == 8 && version.Minor < 3)
                {
                    throw new NotSupportedException(Strings.ExPostgreSqlBelow83IsNotSupported);
                }

                // We support 8.3, 8.4 and any 9.0+

                if (version.Major == 8)
                {
                    if (version.Minor == 3)
                    {
                        return(new v8_3.Driver(coreServerInfo));
                    }
                    return(new v8_4.Driver(coreServerInfo));
                }

                if (version.Major == 9)
                {
                    if (version.Minor == 0)
                    {
                        return(new v9_0.Driver(coreServerInfo));
                    }
                    return(new v9_1.Driver(coreServerInfo));
                }

                return(new v10_0.Driver(coreServerInfo));
            }
        }
        public void ConntectionTest()
        {
            var descriptor = ProviderDescriptor.Get(provider);
            var factory    = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);

            var configuration = new SqlDriverConfiguration {
                EnsureConnectionIsAlive = true
            };
            var driver = factory.GetDriver(new ConnectionInfo(Url), configuration);

            var connection = driver.CreateConnection();

            connection.Open();

            var anotherConnection = driver.CreateConnection();

            anotherConnection.OpenAndInitialize("Use [DO-Tests-1]");
        }
示例#14
0
        /// <inheritdoc/>
        protected override SqlDriver CreateDriver(string connectionString, SqlDriverConfiguration configuration)
        {
            using var connection = new OracleConnection(connectionString);
            if (configuration.DbConnectionAccessors.Count > 0)
            {
                OpenConnectionWithNotification(connection, configuration, false).GetAwaiter().GetResult();
            }
            else
            {
                OpenConnectionFast(connection, configuration, false).GetAwaiter().GetResult();
            }
            var version = string.IsNullOrEmpty(configuration.ForcedServerVersion)
        ? ParseVersion(connection.ServerVersion)
        : new Version(configuration.ForcedServerVersion);
            var defaultSchema = GetDefaultSchema(connection);

            return(CreateDriverInstance(connectionString, version, defaultSchema));
        }
示例#15
0
        protected override SqlDriver CreateDriver(string connectionString, SqlDriverConfiguration configuration)
        {
            using (var connection = new MySqlConnection(connectionString)) {
                connection.Open();
                SqlHelper.ExecuteInitializationSql(connection, configuration);
                var versionString = string.IsNullOrEmpty(configuration.ForcedServerVersion)
          ? connection.ServerVersion
          : configuration.ForcedServerVersion;
                var version = ParseVersion(versionString);

                var builder        = new MySqlConnectionStringBuilder(connectionString);
                var dataSource     = string.Format(DataSourceFormat, builder.Server, builder.Port, builder.Database);
                var defaultSchema  = GetDefaultSchema(connection);
                var coreServerInfo = new CoreServerInfo {
                    ServerVersion            = version,
                    ConnectionString         = connectionString,
                    MultipleActiveResultSets = false,
                    DatabaseName             = defaultSchema.Database,
                    DefaultSchemaName        = defaultSchema.Schema,
                };

                if (version.Major < 5)
                {
                    throw new NotSupportedException(Strings.ExMySqlBelow50IsNotSupported);
                }
                if (version.Major == 5 && version.Minor == 0)
                {
                    return(new v5_0.Driver(coreServerInfo));
                }
                if (version.Major == 5 && version.Minor == 1)
                {
                    return(new v5_1.Driver(coreServerInfo));
                }
                if (version.Major == 5 && version.Minor == 5)
                {
                    return(new v5_5.Driver(coreServerInfo));
                }
                if (version.Major == 5 && version.Minor == 6)
                {
                    return(new v5_6.Driver(coreServerInfo));
                }
                return(new v5_6.Driver(coreServerInfo));
            }
        }
示例#16
0
        private void OpenConnectionWithNotification(SQLiteConnection connection, SqlDriverConfiguration configuration)
        {
            var accessors = configuration.DbConnectionAccessors;

            SqlHelper.NotifyConnectionOpening(accessors, connection);
            try {
                connection.Open();
                if (!string.IsNullOrEmpty(configuration.ConnectionInitializationSql))
                {
                    SqlHelper.NotifyConnectionInitializing(accessors, connection, configuration.ConnectionInitializationSql);
                }
                SqlHelper.ExecuteInitializationSql(connection, configuration);
                SqlHelper.NotifyConnectionOpened(accessors, connection);
            }
            catch (Exception ex) {
                SqlHelper.NotifyConnectionOpeningFailed(accessors, connection, ex);
                throw;
            }
        }
示例#17
0
        private SqlServerConnection CreateAndOpenConnection(string connectionString, SqlDriverConfiguration configuration)
        {
            var connection = new SqlServerConnection(connectionString);

            if (!configuration.EnsureConnectionIsAlive)
            {
                connection.Open();
                SqlHelper.ExecuteInitializationSql(connection, configuration);
                return(connection);
            }

            var testQuery = (string.IsNullOrEmpty(configuration.ConnectionInitializationSql))
        ? CheckConnectionQuery
        : configuration.ConnectionInitializationSql;

            connection.Open();
            EnsureConnectionIsAlive(ref connection, testQuery);
            return(connection);
        }
示例#18
0
        public static async Task <StorageDriver> CreateAsync(
            SqlDriverFactory driverFactory, DomainConfiguration configuration, CancellationToken token)
        {
            ArgumentValidator.EnsureArgumentNotNull(driverFactory, nameof(driverFactory));
            ArgumentValidator.EnsureArgumentNotNull(configuration, nameof(configuration));

            var driverConfiguration = new SqlDriverConfiguration {
                ForcedServerVersion         = configuration.ForcedServerVersion,
                ConnectionInitializationSql = configuration.ConnectionInitializationSql,
                EnsureConnectionIsAlive     = configuration.EnsureConnectionIsAlive,
            };

            var driver = await driverFactory.GetDriverAsync(configuration.ConnectionInfo, driverConfiguration, token)
                         .ConfigureAwait(false);

            var providerInfo = ProviderInfoBuilder.Build(configuration.ConnectionInfo.Provider, driver);

            return(new StorageDriver(driver, providerInfo, configuration, GetNullModel));
        }
示例#19
0
        /// <inheritdoc/>
        protected override async Task <SqlDriver> CreateDriverAsync(
            string connectionString, SqlDriverConfiguration configuration, CancellationToken token)
        {
            var connection = new NpgsqlConnection(connectionString);

            await using (connection.ConfigureAwait(false)) {
                if (configuration.DbConnectionAccessors.Count > 0)
                {
                    await OpenConnectionWithNotification(connection, configuration, true, token).ConfigureAwait(false);
                }
                else
                {
                    await OpenConnectionFast(connection, configuration, true, token).ConfigureAwait(false);
                }
                var version       = GetVersion(configuration, connection);
                var defaultSchema = await GetDefaultSchemaAsync(connection, token : token).ConfigureAwait(false);

                return(CreateDriverInstance(connectionString, version, defaultSchema));
            }
        }
示例#20
0
        /// <inheritdoc/>
        protected override SqlDriver CreateDriver(string connectionString, SqlDriverConfiguration configuration)
        {
            var isPooingOn = !IsPoolingOff(connectionString);

            configuration.EnsureConnectionIsAlive &= isPooingOn;

            using var connection = CreateAndOpenConnection(connectionString, configuration);
            var isEnsureAlive       = configuration.EnsureConnectionIsAlive;
            var forcedServerVersion = configuration.ForcedServerVersion;
            var isForcedVersion     = !string.IsNullOrEmpty(forcedServerVersion);
            var isForcedAzure       = isForcedVersion && forcedServerVersion.Equals("azure", StringComparison.OrdinalIgnoreCase);
            var isAzure             = isForcedAzure || (!isForcedVersion && IsAzure(connection));
            var parser = isAzure ? new ErrorMessageParser() : CreateMessageParser(connection);

            var versionString = isForcedVersion
        ? isForcedAzure ? "10.0.0.0" : forcedServerVersion
        : connection.ServerVersion ?? string.Empty;
            var version       = new Version(versionString);
            var defaultSchema = GetDefaultSchema(connection);

            return(CreateDriverInstance(connectionString, isAzure, version, defaultSchema, parser, isEnsureAlive));
        }
示例#21
0
        private SqlDriver DoCreateDriver(string connectionString, SqlDriverConfiguration configuration)
        {
            using (var connection = new SQLiteConnection(connectionString)) {
                connection.Open();
                SqlHelper.ExecuteInitializationSql(connection, configuration);
                var version        = new Version(connection.ServerVersion);
                var defaultSchema  = GetDefaultSchema(connection);
                var coreServerInfo = new CoreServerInfo {
                    ServerVersion            = version,
                    ConnectionString         = connectionString,
                    MultipleActiveResultSets = false,
                    DatabaseName             = defaultSchema.Database,
                    DefaultSchemaName        = defaultSchema.Schema,
                };

                if (version.Major < 3)
                {
                    throw new NotSupportedException(Strings.ExSqlLiteServerBelow3IsNotSupported);
                }
                return(new v3.Driver(coreServerInfo));
            }
        }
示例#22
0
        public void SqlServerConnectionCheckTest()
        {
            Require.ProviderIs(StorageProvider.SqlServer);
            var descriptor = ProviderDescriptor.Get(provider);
            var factory    = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);

            var configuration = new SqlDriverConfiguration()
            {
                EnsureConnectionIsAlive = false
            };
            var driver = factory.GetDriver(new ConnectionInfo(Url), configuration);

            Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.False);

            configuration = configuration.Clone();
            configuration.EnsureConnectionIsAlive = true;
            driver = factory.GetDriver(new ConnectionInfo(Url), configuration);
            Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.True);

            configuration = configuration.Clone();
            configuration.EnsureConnectionIsAlive = true;
            driver = factory.GetDriver(new ConnectionInfo(provider, ConnectionString + ";pooling=false"), configuration);
            Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.False);

            configuration = configuration.Clone();
            configuration.EnsureConnectionIsAlive = true;
            driver = factory.GetDriver(new ConnectionInfo(provider, ConnectionString + ";Pooling=False"), configuration);
            Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.False);

            configuration = configuration.Clone();
            configuration.EnsureConnectionIsAlive = true;
            driver = factory.GetDriver(new ConnectionInfo(provider, ConnectionString + ";pooling = false"), configuration);
            Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.False);

            configuration = configuration.Clone();
            configuration.EnsureConnectionIsAlive = true;
            driver = factory.GetDriver(new ConnectionInfo(provider, ConnectionString + ";Pooling = False"), configuration);
            Assert.That(GetCheckConnectionIsAliveFlag(driver), Is.False);
        }
示例#23
0
 private void OpenConnectionFast(SQLiteConnection connection, SqlDriverConfiguration configuration)
 {
     connection.Open();
     SqlHelper.ExecuteInitializationSql(connection, configuration);
 }
示例#24
0
        /// <inheritdoc/>
        protected override SqlDriver CreateDriver(string connectionString, SqlDriverConfiguration configuration)
        {
            var isPooingOn = !IsPoolingOff(connectionString);

            configuration.EnsureConnectionIsAlive = isPooingOn && configuration.EnsureConnectionIsAlive;

            using (var connection = CreateAndOpenConnection(connectionString, configuration)) {
                string versionString;
                bool   isAzure;

                var forcedServerVersion = configuration.ForcedServerVersion;
                if (string.IsNullOrEmpty(forcedServerVersion))
                {
                    versionString = connection.ServerVersion;
                    isAzure       = IsAzure(connection);
                }
                else if (forcedServerVersion.Equals("azure", StringComparison.OrdinalIgnoreCase))
                {
                    versionString = "10.0.0.0";
                    isAzure       = true;
                }
                else
                {
                    versionString = forcedServerVersion;
                    isAzure       = false;
                }

                var builder        = new SqlConnectionStringBuilder(connectionString);
                var version        = new Version(versionString);
                var defaultSchema  = GetDefaultSchema(connection);
                var coreServerInfo = new CoreServerInfo {
                    ServerVersion            = version,
                    ConnectionString         = connectionString,
                    MultipleActiveResultSets = builder.MultipleActiveResultSets,
                    DatabaseName             = defaultSchema.Database,
                    DefaultSchemaName        = defaultSchema.Schema,
                };
                if (isAzure)
                {
                    return(new Azure.Driver(coreServerInfo, new ErrorMessageParser(), configuration.EnsureConnectionIsAlive));
                }
                if (version.Major < 9)
                {
                    throw new NotSupportedException(Strings.ExSqlServerBelow2005IsNotSupported);
                }
                var parser = CreateMessageParser(connection);
                if (version.Major == 9)
                {
                    return(new v09.Driver(coreServerInfo, parser, configuration.EnsureConnectionIsAlive));
                }
                if (version.Major == 10)
                {
                    return(new v10.Driver(coreServerInfo, parser, configuration.EnsureConnectionIsAlive));
                }
                if (version.Major == 11)
                {
                    return(new v11.Driver(coreServerInfo, parser, configuration.EnsureConnectionIsAlive));
                }
                if (version.Major == 12)
                {
                    return(new v12.Driver(coreServerInfo, parser, configuration.EnsureConnectionIsAlive));
                }
                if (version.Major == 13)
                {
                    return(new v13.Driver(coreServerInfo, parser, configuration.EnsureConnectionIsAlive));
                }
                return(new v13.Driver(coreServerInfo, parser, configuration.EnsureConnectionIsAlive));
            }
        }
示例#25
0
 /// <inheritdoc/>
 protected override SqlDriver CreateDriver(string connectionString, SqlDriverConfiguration configuration)
 {
     return(DoCreateDriver(connectionString, configuration));
 }
示例#26
0
        public async Task ConnectionAccessorAsyncTest()
        {
            var accessorInstance = new TestConnectionAccessor();
            var accessorsArray   = new[] { accessorInstance };
            var descriptor       = ProviderDescriptor.Get(provider);
            var factory          = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);

            Assert.That(accessorInstance.OpeningCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpeningAsyncCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpenedCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpenedAsyncCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpeningFailedCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpeningFailedAsyncCounter, Is.EqualTo(0));

            var configuration = new SqlDriverConfiguration(accessorsArray);

            _ = await factory.GetDriverAsync(new ConnectionInfo(Url), configuration, CancellationToken.None);

            Assert.That(accessorInstance.OpeningCounter, Is.EqualTo(1));
            Assert.That(accessorInstance.OpeningAsyncCounter, Is.EqualTo(1));
            Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpenedCounter, Is.EqualTo(1));
            Assert.That(accessorInstance.OpenedAsyncCounter, Is.EqualTo(1));
            Assert.That(accessorInstance.OpeningFailedCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpeningFailedAsyncCounter, Is.EqualTo(0));

            configuration = new SqlDriverConfiguration(accessorsArray)
            {
                EnsureConnectionIsAlive = true
            };
            _ = await factory.GetDriverAsync(new ConnectionInfo(Url), configuration, CancellationToken.None);

            Assert.That(accessorInstance.OpeningCounter, Is.EqualTo(2));
            Assert.That(accessorInstance.OpeningAsyncCounter, Is.EqualTo(2));

            if (provider == WellKnown.Provider.SqlServer)
            {
                Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(1));
                Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(1));
            }
            else
            {
                Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(0));
                Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(0));
            }

            Assert.That(accessorInstance.OpenedCounter, Is.EqualTo(2));
            Assert.That(accessorInstance.OpenedAsyncCounter, Is.EqualTo(2));
            Assert.That(accessorInstance.OpeningFailedCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpeningFailedAsyncCounter, Is.EqualTo(0));

            configuration = new SqlDriverConfiguration(accessorsArray)
            {
                ConnectionInitializationSql = InitQueryPerProvider(provider)
            };
            _ = await factory.GetDriverAsync(new ConnectionInfo(Url), configuration, CancellationToken.None);

            Assert.That(accessorInstance.OpeningCounter, Is.EqualTo(3));
            Assert.That(accessorInstance.OpeningAsyncCounter, Is.EqualTo(3));
            if (provider == WellKnown.Provider.SqlServer)
            {
                Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(2));
                Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(2));
            }
            else
            {
                Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(1));
                Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(1));
            }

            Assert.That(accessorInstance.OpenedCounter, Is.EqualTo(3));
            Assert.That(accessorInstance.OpenedAsyncCounter, Is.EqualTo(3));
            Assert.That(accessorInstance.OpeningFailedCounter, Is.EqualTo(0));
            Assert.That(accessorInstance.OpeningFailedAsyncCounter, Is.EqualTo(0));

            configuration = new SqlDriverConfiguration(accessorsArray)
            {
                ConnectionInitializationSql = "dummy string to trigger error"
            };
            try {
                _ = await factory.GetDriverAsync(new ConnectionInfo(Url), configuration, CancellationToken.None);
            }
            catch {
                //skip it
            }

            Assert.That(accessorInstance.OpeningCounter, Is.EqualTo(4));
            Assert.That(accessorInstance.OpeningAsyncCounter, Is.EqualTo(4));

            if (provider == WellKnown.Provider.SqlServer)
            {
                Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(3));
                Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(3));
            }
            else
            {
                Assert.That(accessorInstance.OpeningInitCounter, Is.EqualTo(2));
                Assert.That(accessorInstance.OpeningInitAsyncCounter, Is.EqualTo(2));
            }

            Assert.That(accessorInstance.OpenedCounter, Is.EqualTo(3));
            Assert.That(accessorInstance.OpenedAsyncCounter, Is.EqualTo(3));
            Assert.That(accessorInstance.OpeningFailedCounter, Is.EqualTo(1));
            Assert.That(accessorInstance.OpeningFailedAsyncCounter, Is.EqualTo(1));
        }