< Summary

Class:Microsoft.Azure.Search.Models.DataSource
Assembly:Microsoft.Azure.Search.Service
File(s):C:\Git\azure-sdk-for-net\sdk\search\Microsoft.Azure.Search.Service\src\Customizations\DataSources\Models\DataSource.Customization.cs
C:\Git\azure-sdk-for-net\sdk\search\Microsoft.Azure.Search.Service\src\Generated\Models\DataSource.cs
Covered lines:90
Uncovered lines:30
Coverable lines:120
Total lines:463
Line coverage:75% (90 of 120)
Covered branches:7
Total branches:12
Branch coverage:58.3% (7 of 12)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
AzureSql(...)-100%100%
AzureSql(...)-100%100%
AzureSql(...)-100%100%
SqlServerOnAzureVM(...)-100%100%
SqlServerOnAzureVM(...)-100%100%
SqlServerOnAzureVM(...)-100%100%
CosmosDb(...)-100%100%
DocumentDb(...)-0%0%
AzureBlobStorage(...)-100%100%
AzureTableStorage(...)-100%100%
CreateSqlDataSource(...)-100%100%
.ctor()-100%100%
.ctor(...)-0%100%
get_Name()-100%100%
get_Description()-100%100%
get_Type()-100%100%
get_Credentials()-100%100%
get_Container()-100%100%
get_DataChangeDetectionPolicy()-100%100%
get_DataDeletionDetectionPolicy()-100%100%
get_ETag()-100%100%
Validate()-66.67%62.5%

File(s)

C:\Git\azure-sdk-for-net\sdk\search\Microsoft.Azure.Search.Service\src\Customizations\DataSources\Models\DataSource.Customization.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License. See License.txt in the project root for
 3// license information.
 4
 5namespace Microsoft.Azure.Search.Models
 6{
 7    using Common;
 8    using System;
 9
 10    public partial class DataSource : IResourceWithETag
 11    {
 12        /// <summary>
 13        /// Creates a new DataSource to connect to an Azure SQL database.
 14        /// </summary>
 15        /// <param name="name">The name of the datasource.</param>
 16        /// <param name="sqlConnectionString">The connection string for the Azure SQL database.</param>
 17        /// <param name="tableOrViewName">The name of the table or view from which to read rows.</param>
 18        /// <param name="deletionDetectionPolicy">Optional. The data deletion detection policy for the datasource.</para
 19        /// <param name="description">Optional. Description of the datasource.</param>
 20        /// <returns>A new DataSource instance.</returns>
 21        public static DataSource AzureSql(
 22            string name,
 23            string sqlConnectionString,
 24            string tableOrViewName,
 25            DataDeletionDetectionPolicy deletionDetectionPolicy = null,
 26            string description = null)
 27        {
 9028            return CreateSqlDataSource(name, sqlConnectionString, tableOrViewName, description, null, deletionDetectionP
 29        }
 30
 31        /// <summary>
 32        /// Creates a new DataSource to connect to an Azure SQL database with change detection enabled.
 33        /// </summary>
 34        /// <param name="name">The name of the datasource.</param>
 35        /// <param name="sqlConnectionString">The connection string for the Azure SQL database.</param>
 36        /// <param name="tableOrViewName">The name of the table or view from which to read rows.</param>
 37        /// <param name="changeDetectionPolicy">The change detection policy for the datasource.</param>
 38        /// <param name="description">Optional. Description of the datasource.</param>
 39        /// <returns>A new DataSource instance.</returns>
 40        public static DataSource AzureSql(
 41            string name,
 42            string sqlConnectionString,
 43            string tableOrViewName,
 44            DataChangeDetectionPolicy changeDetectionPolicy,
 45            string description = null)
 46        {
 847            Throw.IfArgumentNull(changeDetectionPolicy, nameof(changeDetectionPolicy));
 848            return CreateSqlDataSource(name, sqlConnectionString, tableOrViewName, description, changeDetectionPolicy);
 49        }
 50
 51        /// <summary>
 52        /// Creates a new DataSource to connect to an Azure SQL database with change detection and deletion detection en
 53        /// </summary>
 54        /// <param name="name">The name of the datasource.</param>
 55        /// <param name="sqlConnectionString">The connection string for the Azure SQL database.</param>
 56        /// <param name="tableOrViewName">The name of the table or view from which to read rows.</param>
 57        /// <param name="changeDetectionPolicy">The change detection policy for the datasource. Note that only high wate
 58        /// allowed for Azure SQL when deletion detection is enabled.</param>
 59        /// <param name="deletionDetectionPolicy">The data deletion detection policy for the datasource.</param>
 60        /// <param name="description">Optional. Description of the datasource.</param>
 61        /// <returns>A new DataSource instance.</returns>
 62        public static DataSource AzureSql(
 63            string name,
 64            string sqlConnectionString,
 65            string tableOrViewName,
 66            HighWaterMarkChangeDetectionPolicy changeDetectionPolicy,
 67            DataDeletionDetectionPolicy deletionDetectionPolicy,
 68            string description = null)
 69        {
 870            Throw.IfArgumentNull(changeDetectionPolicy, nameof(changeDetectionPolicy));
 871            Throw.IfArgumentNull(deletionDetectionPolicy, nameof(deletionDetectionPolicy));
 72
 873            return CreateSqlDataSource(name, sqlConnectionString, tableOrViewName, description, changeDetectionPolicy, d
 74        }
 75
 76        /// <summary>
 77        /// Creates a new DataSource to connect to a VM-hosted SQL Server database.
 78        /// </summary>
 79        /// <param name="name">The name of the datasource.</param>
 80        /// <param name="sqlConnectionString">The connection string for the SQL Server database.</param>
 81        /// <param name="tableOrViewName">The name of the table or view from which to read rows.</param>
 82        /// <param name="deletionDetectionPolicy">Optional. The data deletion detection policy for the datasource.</para
 83        /// <param name="description">Optional. Description of the datasource.</param>
 84        /// <returns>A new DataSource instance.</returns>
 85        public static DataSource SqlServerOnAzureVM(
 86            string name,
 87            string sqlConnectionString,
 88            string tableOrViewName,
 89            DataDeletionDetectionPolicy deletionDetectionPolicy = null,
 90            string description = null)
 91        {
 892            return AzureSql(name, sqlConnectionString, tableOrViewName, deletionDetectionPolicy, description);
 93        }
 94
 95        /// <summary>
 96        /// Creates a new DataSource to connect to a VM-hosted SQL Server database with change detection enabled.
 97        /// </summary>
 98        /// <param name="name">The name of the datasource.</param>
 99        /// <param name="sqlConnectionString">The connection string for the SQL Server database.</param>
 100        /// <param name="tableOrViewName">The name of the table or view from which to read rows.</param>
 101        /// <param name="changeDetectionPolicy">The change detection policy for the datasource.</param>
 102        /// <param name="description">Optional. Description of the datasource.</param>
 103        /// <returns>A new DataSource instance.</returns>
 104        public static DataSource SqlServerOnAzureVM(
 105            string name,
 106            string sqlConnectionString,
 107            string tableOrViewName,
 108            DataChangeDetectionPolicy changeDetectionPolicy,
 109            string description = null)
 110        {
 4111            return AzureSql(name, sqlConnectionString, tableOrViewName, changeDetectionPolicy, description);
 112        }
 113
 114        /// <summary>
 115        /// Creates a new DataSource to connect to a VM-hosted SQL Server database with change detection and deletion de
 116        /// </summary>
 117        /// <param name="name">The name of the datasource.</param>
 118        /// <param name="sqlConnectionString">The connection string for the SQL Server database.</param>
 119        /// <param name="tableOrViewName">The name of the table or view from which to read rows.</param>
 120        /// <param name="changeDetectionPolicy">The change detection policy for the datasource. Note that only high wate
 121        /// allowed for SQL Server when deletion detection is enabled.</param>
 122        /// <param name="deletionDetectionPolicy">The data deletion detection policy for the datasource.</param>
 123        /// <param name="description">Optional. Description of the datasource.</param>
 124        /// <returns>A new DataSource instance.</returns>
 125        public static DataSource SqlServerOnAzureVM(
 126            string name,
 127            string sqlConnectionString,
 128            string tableOrViewName,
 129            HighWaterMarkChangeDetectionPolicy changeDetectionPolicy,
 130            DataDeletionDetectionPolicy deletionDetectionPolicy,
 131            string description = null)
 132        {
 4133            return AzureSql(name, sqlConnectionString, tableOrViewName, changeDetectionPolicy, deletionDetectionPolicy, 
 134        }
 135
 136        /// <summary>
 137        /// Creates a new DataSource to connect to a CosmosDb database.
 138        /// </summary>
 139        /// <param name="name">The name of the datasource.</param>
 140        /// <param name="cosmosDbConnectionString">The connection string for the CosmosDb database. It must follow this 
 141        /// "AccountName|AccountEndpoint=[your account name or endpoint];AccountKey=[your account key];Database=[your da
 142        /// <param name="collectionName">The name of the collection from which to read documents.</param>
 143        /// <param name="query">Optional. A query that is applied to the collection when reading documents.</param>
 144        /// <param name="useChangeDetection">Optional. Indicates whether to use change detection when indexing. Default 
 145        /// <param name="deletionDetectionPolicy">Optional. The data deletion detection policy for the datasource.</para
 146        /// <param name="description">Optional. Description of the datasource.</param>
 147        /// <returns>A new DataSource instance.</returns>
 148        public static DataSource CosmosDb(
 149            string name,
 150            string cosmosDbConnectionString,
 151            string collectionName,
 152            string query = null,
 153            bool useChangeDetection = true,
 154            DataDeletionDetectionPolicy deletionDetectionPolicy = null,
 155            string description = null)
 156        {
 18157            Throw.IfArgumentNullOrEmpty(name, nameof(name));
 18158            Throw.IfArgumentNullOrEmpty(collectionName, nameof(collectionName));
 18159            Throw.IfArgumentNullOrEmpty(cosmosDbConnectionString, nameof(cosmosDbConnectionString));
 160
 18161            return new DataSource()
 18162            {
 18163                Type = DataSourceType.CosmosDb,
 18164                Name = name,
 18165                Description = description,
 18166                Container = new DataContainer()
 18167                {
 18168                    Name = collectionName,
 18169                    Query = query
 18170                },
 18171                Credentials = new DataSourceCredentials(cosmosDbConnectionString),
 18172                DataChangeDetectionPolicy = useChangeDetection ? new HighWaterMarkChangeDetectionPolicy("_ts") : null,
 18173                DataDeletionDetectionPolicy = deletionDetectionPolicy
 18174            };
 175        }
 176
 177        /// <summary>
 178        /// Creates a new DataSource to connect to a DocumentDb database.
 179        /// </summary>
 180        /// <param name="name">The name of the datasource.</param>
 181        /// <param name="documentDbConnectionString">The connection string for the DocumentDb database. It must follow t
 182        /// "AccountName|AccountEndpoint=[your account name or endpoint];AccountKey=[your account key];Database=[your da
 183        /// <param name="collectionName">The name of the collection from which to read documents.</param>
 184        /// <param name="query">Optional. A query that is applied to the collection when reading documents.</param>
 185        /// <param name="useChangeDetection">Optional. Indicates whether to use change detection when indexing. Default 
 186        /// <param name="deletionDetectionPolicy">Optional. The data deletion detection policy for the datasource.</para
 187        /// <param name="description">Optional. Description of the datasource.</param>
 188        /// <returns>A new DataSource instance.</returns>
 189        [Obsolete("Use CosmosDb instead.")]
 190        public static DataSource DocumentDb(
 191            string name,
 192            string documentDbConnectionString,
 193            string collectionName,
 194            string query = null,
 195            bool useChangeDetection = true,
 196            DataDeletionDetectionPolicy deletionDetectionPolicy = null,
 197            string description = null)
 198        {
 0199            Throw.IfArgumentNullOrEmpty(name, nameof(name));
 0200            Throw.IfArgumentNullOrEmpty(collectionName, nameof(collectionName));
 0201            Throw.IfArgumentNullOrEmpty(documentDbConnectionString, nameof(documentDbConnectionString));
 202
 0203            return new DataSource()
 0204            {
 0205                Type = DataSourceType.DocumentDb,
 0206                Name = name,
 0207                Description = description,
 0208                Container = new DataContainer()
 0209                {
 0210                    Name = collectionName,
 0211                    Query = query
 0212                },
 0213                Credentials = new DataSourceCredentials(documentDbConnectionString),
 0214                DataChangeDetectionPolicy = useChangeDetection ? new HighWaterMarkChangeDetectionPolicy("_ts") : null,
 0215                DataDeletionDetectionPolicy = deletionDetectionPolicy
 0216            };
 217        }
 218
 219        /// <summary>
 220        /// Creates a new DataSource to connect to an Azure Blob container.
 221        /// </summary>
 222        /// <param name="name">The name of the datasource.</param>
 223        /// <param name="storageConnectionString">The connection string for the Azure Storage account. It must follow th
 224        /// "DefaultEndpointsProtocol=https;AccountName=[your storage account];AccountKey=[your account key];" Note that
 225        /// <param name="containerName">The name of the container from which to read blobs.</param>
 226        /// <param name="pathPrefix">Optional. If specified, the datasource will include only blobs with names starting 
 227        /// useful when blobs are organized into "virtual folders", for example.</param>
 228        /// <param name="deletionDetectionPolicy">Optional. The data deletion detection policy for the datasource.</para
 229        /// <param name="description">Optional. Description of the datasource.</param>
 230        /// <returns>A new DataSource instance.</returns>
 231        public static DataSource AzureBlobStorage(
 232            string name,
 233            string storageConnectionString,
 234            string containerName,
 235            string pathPrefix = null,
 236            DataDeletionDetectionPolicy deletionDetectionPolicy = null,
 237            string description = null)
 238        {
 10239            Throw.IfArgumentNullOrEmpty(name, nameof(name));
 10240            Throw.IfArgumentNullOrEmpty(containerName, nameof(containerName));
 10241            Throw.IfArgumentNullOrEmpty(storageConnectionString, nameof(storageConnectionString));
 242
 10243            return new DataSource()
 10244            {
 10245                Type = DataSourceType.AzureBlob,
 10246                Name = name,
 10247                Description = description,
 10248                Container = new DataContainer()
 10249                {
 10250                    Name = containerName,
 10251                    Query = pathPrefix
 10252                },
 10253                Credentials = new DataSourceCredentials(storageConnectionString),
 10254                DataDeletionDetectionPolicy = deletionDetectionPolicy
 10255            };
 256        }
 257
 258        /// <summary>
 259        /// Creates a new DataSource to connect to an Azure Table.
 260        /// </summary>
 261        /// <param name="name">The name of the datasource.</param>
 262        /// <param name="storageConnectionString">The connection string for the Azure Storage account. It must follow th
 263        /// "DefaultEndpointsProtocol=https;AccountName=[your storage account];AccountKey=[your account key];" Note that
 264        /// <param name="tableName">The name of the table from which to read rows.</param>
 265        /// <param name="query">Optional. A query that is applied to the table when reading rows.</param>
 266        /// <param name="deletionDetectionPolicy">Optional. The data deletion detection policy for the datasource.</para
 267        /// <param name="description">Optional. Description of the datasource.</param>
 268        /// <returns>A new DataSource instance.</returns>
 269        public static DataSource AzureTableStorage(
 270            string name,
 271            string storageConnectionString,
 272            string tableName,
 273            string query = null,
 274            DataDeletionDetectionPolicy deletionDetectionPolicy = null,
 275            string description = null)
 276        {
 8277            Throw.IfArgumentNullOrEmpty(name, nameof(name));
 8278            Throw.IfArgumentNullOrEmpty(tableName, nameof(tableName));
 8279            Throw.IfArgumentNullOrEmpty(storageConnectionString, nameof(storageConnectionString));
 280
 8281            return new DataSource()
 8282            {
 8283                Type = DataSourceType.AzureTable,
 8284                Name = name,
 8285                Description = description,
 8286                Container = new DataContainer()
 8287                {
 8288                    Name = tableName,
 8289                    Query = query
 8290                },
 8291                Credentials = new DataSourceCredentials(storageConnectionString),
 8292                DataDeletionDetectionPolicy = deletionDetectionPolicy
 8293            };
 294        }
 295
 296        private static DataSource CreateSqlDataSource(
 297            string name,
 298            string sqlConnectionString,
 299            string tableOrViewName,
 300            string description,
 301            DataChangeDetectionPolicy changeDetectionPolicy = null,
 302            DataDeletionDetectionPolicy deletionDetectionPolicy = null)
 303        {
 106304            Throw.IfArgumentNullOrEmpty(name, nameof(name));
 106305            Throw.IfArgumentNullOrEmpty(tableOrViewName, nameof(tableOrViewName));
 106306            Throw.IfArgumentNullOrEmpty(sqlConnectionString, nameof(sqlConnectionString));
 307
 106308            return new DataSource()
 106309            {
 106310                Type = DataSourceType.AzureSql,
 106311                Name = name,
 106312                Description = description,
 106313                Container = new DataContainer()
 106314                {
 106315                    Name = tableOrViewName
 106316                },
 106317                Credentials = new DataSourceCredentials(sqlConnectionString),
 106318                DataChangeDetectionPolicy = changeDetectionPolicy,
 106319                DataDeletionDetectionPolicy = deletionDetectionPolicy
 106320            };
 321        }
 322    }
 323}

C:\Git\azure-sdk-for-net\sdk\search\Microsoft.Azure.Search.Service\src\Generated\Models\DataSource.cs

#LineLine coverage
 1// <auto-generated>
 2// Copyright (c) Microsoft Corporation. All rights reserved.
 3// Licensed under the MIT License. See License.txt in the project root for
 4// license information.
 5//
 6// Code generated by Microsoft (R) AutoRest Code Generator.
 7// Changes may cause incorrect behavior and will be lost if the code is
 8// regenerated.
 9// </auto-generated>
 10
 11namespace Microsoft.Azure.Search.Models
 12{
 13    using Microsoft.Rest;
 14    using Newtonsoft.Json;
 15    using System.Linq;
 16
 17    /// <summary>
 18    /// Represents a datasource definition, which can be used to configure an
 19    /// indexer.
 20    /// </summary>
 21    public partial class DataSource
 22    {
 23        /// <summary>
 24        /// Initializes a new instance of the DataSource class.
 25        /// </summary>
 32426        public DataSource()
 27        {
 28            CustomInit();
 32429        }
 30
 31        /// <summary>
 32        /// Initializes a new instance of the DataSource class.
 33        /// </summary>
 34        /// <param name="name">The name of the datasource.</param>
 35        /// <param name="type">The type of the datasource. Possible values
 36        /// include: 'azuresql', 'cosmosdb', 'azureblob', 'azuretable'</param>
 37        /// <param name="credentials">Credentials for the datasource.</param>
 38        /// <param name="container">The data container for the
 39        /// datasource.</param>
 40        /// <param name="description">The description of the
 41        /// datasource.</param>
 42        /// <param name="dataChangeDetectionPolicy">The data change detection
 43        /// policy for the datasource.</param>
 44        /// <param name="dataDeletionDetectionPolicy">The data deletion
 45        /// detection policy for the datasource.</param>
 46        /// <param name="eTag">The ETag of the DataSource.</param>
 047        public DataSource(string name, DataSourceType type, DataSourceCredentials credentials, DataContainer container, 
 48        {
 049            Name = name;
 050            Description = description;
 051            Type = type;
 052            Credentials = credentials;
 053            Container = container;
 054            DataChangeDetectionPolicy = dataChangeDetectionPolicy;
 055            DataDeletionDetectionPolicy = dataDeletionDetectionPolicy;
 056            ETag = eTag;
 57            CustomInit();
 058        }
 59
 60        /// <summary>
 61        /// An initialization method that performs custom operations like setting defaults
 62        /// </summary>
 63        partial void CustomInit();
 64
 65        /// <summary>
 66        /// Gets or sets the name of the datasource.
 67        /// </summary>
 68        [JsonProperty(PropertyName = "name")]
 91669        public string Name { get; set; }
 70
 71        /// <summary>
 72        /// Gets or sets the description of the datasource.
 73        /// </summary>
 74        [JsonProperty(PropertyName = "description")]
 57675        public string Description { get; set; }
 76
 77        /// <summary>
 78        /// Gets or sets the type of the datasource. Possible values include:
 79        /// 'azuresql', 'cosmosdb', 'azureblob', 'azuretable'
 80        /// </summary>
 81        [JsonProperty(PropertyName = "type")]
 79282        public DataSourceType Type { get; set; }
 83
 84        /// <summary>
 85        /// Gets or sets credentials for the datasource.
 86        /// </summary>
 87        [JsonProperty(PropertyName = "credentials")]
 100888        public DataSourceCredentials Credentials { get; set; }
 89
 90        /// <summary>
 91        /// Gets or sets the data container for the datasource.
 92        /// </summary>
 93        [JsonProperty(PropertyName = "container")]
 124894        public DataContainer Container { get; set; }
 95
 96        /// <summary>
 97        /// Gets or sets the data change detection policy for the datasource.
 98        /// </summary>
 99        [JsonProperty(PropertyName = "dataChangeDetectionPolicy")]
 486100        public DataChangeDetectionPolicy DataChangeDetectionPolicy { get; set; }
 101
 102        /// <summary>
 103        /// Gets or sets the data deletion detection policy for the datasource.
 104        /// </summary>
 105        [JsonProperty(PropertyName = "dataDeletionDetectionPolicy")]
 528106        public DataDeletionDetectionPolicy DataDeletionDetectionPolicy { get; set; }
 107
 108        /// <summary>
 109        /// Gets or sets the ETag of the DataSource.
 110        /// </summary>
 111        [JsonProperty(PropertyName = "@odata.etag")]
 376112        public string ETag { get; set; }
 113
 114        /// <summary>
 115        /// Validate the object.
 116        /// </summary>
 117        /// <exception cref="ValidationException">
 118        /// Thrown if validation fails
 119        /// </exception>
 120        public virtual void Validate()
 121        {
 152122            if (Name == null)
 123            {
 0124                throw new ValidationException(ValidationRules.CannotBeNull, "Name");
 125            }
 152126            if (Credentials == null)
 127            {
 0128                throw new ValidationException(ValidationRules.CannotBeNull, "Credentials");
 129            }
 152130            if (Container == null)
 131            {
 0132                throw new ValidationException(ValidationRules.CannotBeNull, "Container");
 133            }
 152134            if (Container != null)
 135            {
 152136                Container.Validate();
 137            }
 152138        }
 139    }
 140}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:47:18 PM
GitHub | www.palmmedia.de

Methods/Properties

AzureSql(...)
AzureSql(...)
AzureSql(...)
SqlServerOnAzureVM(...)
SqlServerOnAzureVM(...)
SqlServerOnAzureVM(...)
CosmosDb(...)
DocumentDb(...)
AzureBlobStorage(...)
AzureTableStorage(...)
CreateSqlDataSource(...)
.ctor()
.ctor(...)
get_Name()
get_Description()
get_Type()
get_Credentials()
get_Container()
get_DataChangeDetectionPolicy()
get_DataDeletionDetectionPolicy()
get_ETag()
Validate()