/// <summary> /// Initializes a new instance of the <see cref="JsonInsert{T}"/> class. /// </summary> /// <param name="databaseContext"> /// The database context. /// </param> public JsonInsert([NotNull] IDatabaseContext databaseContext) : base(Singleton <JsonCommandFactory> .Instance, databaseContext) { if (databaseContext == null) { throw new ArgumentNullException(nameof(databaseContext)); } this.nameQualifier = this.DatabaseContext.RepositoryAdapter.NameQualifier; }
/// <summary> /// The mock command provider. /// </summary> /// <param name="items"> /// The merge items. /// </param> /// <param name="definitionProvider"> /// The definition provider. /// </param> /// <param name="nameQualifier"> /// The name qualifier. /// </param> /// <typeparam name="T"> /// The type of item in the list to create an <see cref="IDbTableCommandFactory"/> mock for. /// </typeparam> /// <returns> /// The <see cref="Mock"/>. /// </returns> public static Mock <IDbTableCommandFactory> MockCommandFactory <T>( [NotNull] this IReadOnlyCollection <T> items, [NotNull] IEntityDefinitionProvider definitionProvider, [NotNull] INameQualifier nameQualifier) { if (items == null) { throw new ArgumentNullException(nameof(items)); } if (definitionProvider == null) { throw new ArgumentNullException(nameof(definitionProvider)); } if (nameQualifier == null) { throw new ArgumentNullException(nameof(nameQualifier)); } var structureDefinition = definitionProvider.Resolve <T>(); var orderedAttributes = structureDefinition.ReturnableAttributes.OrderBy(definition => definition.Ordinal).ToList(); var reader = items.MockDataReaderForList(orderedAttributes); var command = new Mock <IDbCommand>(); command.Setup(dbCommand => dbCommand.ExecuteReader()).Returns(reader.Object); var commandProvider = new Mock <IDbTableCommandFactory>(); var databaseContext = new Mock <IDatabaseContext>(); var repositoryAdapter = new Mock <IRepositoryAdapter>(); repositoryAdapter.Setup(adapter => adapter.NameQualifier).Returns(nameQualifier); repositoryAdapter.Setup(adapter => adapter.DefinitionProvider).Returns(definitionProvider); databaseContext.Setup(context => context.RepositoryAdapter).Returns(repositoryAdapter.Object); ////commandProvider.Setup(provider => provider.DatabaseContext).Returns(databaseContext.Object); ////commandProvider //// .Setup(provider => provider.Create(It.IsAny<ITableCommand>(), It.IsAny<DataTable>(), It.IsAny<IDbTransaction>())) //// .Returns(command.Object); commandProvider .Setup(provider => provider.Create(It.IsAny <IDatabaseContext>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IEnumerable <T> >())) .Returns(command.Object); return(commandProvider); }
public SqlAnalyzer(string connectionString, INameQualifier nameQualifier = null, TimeSpan cacheDuration = default(TimeSpan)) { nameQualifier = nameQualifier ?? new SqlNameQualifier(); if(cacheDuration == default(TimeSpan)) cacheDuration = _defaultCacheDuration(); _connectionString = connectionString; NameQualifier = nameQualifier; // We use function references instead of directly exposing the functions so // that we can build in caching without much work. // We'll do caching using Memoize - it'll cache the results of the function // for as long as cacheDuration. // Also, in some subclasses (ie, SqlMetaAnalyzer), we implement a different // caching scheme - using these function references lets us do that without // having to change anything here. // Why didn't we just do this through polymorphism, you ask? // Well, if we did, we wouldn't be able to compose our functions easily - we can't // override a function and just say "hey, use a memoized version of this function instead // of the base-class version" - we'd have to implement memoization from scratch in each // method. That's just a silly waste of time. Also, when we subclass, we'd have to implement // all of the memoization and cache invalidation we do in SqlMetaAnalyzer for each of these // methods again! Polymorphism doesn't allow us to do any manipulation of our functions - all you // can do is reimplement them, you can't get at the underlying binding and change it. That is to say, // there's no way using override to say "replace this method with a memoized version of it" - all you // can do is implement the guts of memoize inside your function, and repeat it for every function // you want to do the same thing to. var schemaEvents = Observable.FromEvent<string>(d => OnInvalidateSchemaCache += d, d => OnInvalidateSchemaCache -= d); var tableEvents = Observable.FromEvent<string>(d => OnInvalidateTableCache += d, d => OnInvalidateTableCache -= d); _getAutonumberKey = new Func<string, string>(_getAutonumberKeyFromDB).Memoize(cacheDuration, tableEvents); _getFieldTypes = new Func<string, Dictionary<string,SqlColumnType>>(_getFieldTypesFromDB).Memoize(cacheDuration, tableEvents); _getPrimaryKeys = new Func<string, ICollection<string>>(_getPrimaryKeysFromDB).Memoize(cacheDuration, tableEvents); _tableExists = new Func<string, bool>(_tableExistsFromDB).Memoize(cacheDuration, tableEvents); _schemaExists = new Func<string, bool>(_schemaExistsFromDb).Memoize(cacheDuration, schemaEvents); }
/// <summary> /// Initializes a new instance of the <see cref="JoinClause"/> class. /// </summary> /// <param name="definitionProvider"> /// The definition provider. /// </param> /// <param name="nameQualifier"> /// The SQL name qualifier. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="definitionProvider"/> or <paramref name="nameQualifier"/> is null. /// </exception> public JoinClause([NotNull] IEntityDefinitionProvider definitionProvider, [NotNull] INameQualifier nameQualifier) { this.definitionProvider = definitionProvider ?? throw new ArgumentNullException(nameof(definitionProvider)); this.nameQualifier = nameQualifier ?? throw new ArgumentNullException(nameof(nameQualifier)); }