public List <T> GetAll() { var selectAllCommand = QueryMapper.ReturnSqlQuery(_entityMap, QueryType.SelectAll); using IDbConnection db = new SqlConnection(_connectionString); return(db.Query <T>(selectAllCommand, null, commandType: CommandType.Text).ToList()); }
public int QuantidadeRegistros() { var selectCountCommand = $"SELECT COUNT(*) FROM {QueryMapper.GetTableName(typeof(T))};"; using IDbConnection db = new SqlConnection(_connectionString); return(db.ExecuteScalar <int>(selectCountCommand, null, commandType: CommandType.Text)); }
private static IQuery CreateNewMapper(List <string> errors) { IQuery m = new QueryMapper(new SqlConnection(Util.Settings.MasterConnectionString.Replace("Database=master;", "Database=ProductCatalogDemo;"))); m.OnError(ex => errors.Add(ex.Message)); return(m); }
public async Task OnChangeEventHandler() { // Arrange IQueryMapper sut = new QueryMapper(Util.Settings.ProductCatalogConnectionString); bool isChanged = false; ICommand c = new Belgrade.SqlClient.SqlDb.Command(Util.Settings.ProductCatalogConnectionString); await c.Sql("ALTER DATABASE ProductCatalogDemo SET ENABLE_BROKER;").Exec(); SqlDependency.Start(Util.Settings.ProductCatalogConnectionString); await c.Sql("DROP TABLE IF EXISTS dbo.d2;").Exec(); await c.Sql("SELECT TOP 10 object_id INTO dbo.d2 FROM sys.objects;").Exec(); // Action sut .Sql("SELECT object_id FROM dbo.d2") .OnChange((sender, e) => { if (e.Type == SqlNotificationType.Change) { isChanged = true; } }) .Map(reader => { }).Wait(); c.Sql("DELETE FROM dbo.d2;").Exec().Wait(); await Task.Delay(5000); SqlDependency.Stop(Util.Settings.ProductCatalogConnectionString); // Assert Assert.True(isChanged); }
public TR FindSingleAs <TR>(object id) where TR : class { int intId = (int)id; Expression <Func <T, TR> > exp = QueryMapper.GetExpression <T, TR>(); return(Loader.Where(d => d.Id == intId).Select(exp).FirstOrDefault()); }
public static void Main() { var mapper = new QueryMapper(); mapper.MySql(); Console.ReadLine(); }
public List <T> Query <T>(string formId) where T : new() { QueryMapper <T> mapper = new QueryMapper <T>(formId); ColumnSet columnSet = Query(mapper.QueryModel); return(mapper.Map(columnSet)); }
public void DataAccessSetUp() { #if (NETCOREAPP2_1) DbProviderFactories.RegisterFactory("System.Data.SqlClient", SqlClientFactory.Instance); #endif TransactionScopeFactory = new DefaultTransactionScopeFactory(true, IsolationLevel.ReadCommitted, TimeSpan.FromSeconds(120)); DatabaseGateway = new DatabaseGateway(); DataRowMapper = new DataRowMapper(); DatabaseContextCache = new ThreadStaticDatabaseContextCache(); var connectionConfigurationProvider = new Mock <IConnectionConfigurationProvider>(); connectionConfigurationProvider.Setup(m => m.Get(It.IsAny <string>())).Returns( new ConnectionConfiguration( "Abacus", "System.Data.SqlClient", "Data Source=.\\sqlexpress;Initial Catalog=Abacus;Integrated Security=SSPI;")); DatabaseContextFactory = new DatabaseContextFactory( connectionConfigurationProvider.Object, new DbConnectionFactory(), new DbCommandFactory(), new ThreadStaticDatabaseContextCache()); DatabaseContextFactory.ConfigureWith("Abacus"); QueryMapper = new QueryMapper(DatabaseGateway, DataRowMapper); }
public LinqToCloudIndexWithSpatial(CloudSearchSearchContext context, IExecutionContext[] executionContexts) : base(context, executionContexts) { var parameters = new CloudIndexParameters(context.Index.Configuration.IndexFieldStorageValueFormatter, context.Index.Configuration.VirtualFields, context.Index.FieldNameTranslator, typeof(TItem), false, executionContexts, context.Index.Schema); this.queryMapper = new CloudSpatialQueryMapper(parameters); this.queryOptimizer = new SpatialCloudQueryOptimizer(); }
public ApiClient(IOptions <ApiClientConfiguration> configuration, TokenContainer token, HttpClient http, CommandMapper commandMapper, QueryMapper queryMapper, IExceptionHandler exceptionHandler, IEventDispatcher eventDispatcher, Interop interop, ILogFactory logFactory, Json json) { Ensure.NotNull(configuration, "configuration"); Ensure.NotNull(token, "token"); Ensure.NotNull(http, "http"); Ensure.NotNull(commandMapper, "commandMapper"); Ensure.NotNull(queryMapper, "queryMapper"); Ensure.NotNull(exceptionHandler, "exceptionHandler"); Ensure.NotNull(eventDispatcher, "eventDispatcher"); Ensure.NotNull(interop, "interop"); Ensure.NotNull(logFactory, "logFactory"); Ensure.NotNull(json, "json"); this.configuration = configuration.Value; this.token = token; this.http = http; this.commandMapper = commandMapper; this.queryMapper = queryMapper; this.exceptionHandler = exceptionHandler; this.eventDispatcher = eventDispatcher; this.interop = interop; this.log = logFactory.Scope("ApiClient"); this.json = json; http.BaseAddress = this.configuration.ApiUrl; EnsureAuthorization(); }
public bool Insert(T entity) { var parms = ParametersMapper.RetornaParametros(entity, _entityMap, QueryType.Insert); var insertCommand = QueryMapper.ReturnSqlQuery(_entityMap, QueryType.InsertWithCount); using IDbConnection db = new SqlConnection(_connectionString); return(db.ExecuteScalar <int>(insertCommand, parms, commandType: CommandType.Text) > 0); }
public T GetById(T entity) { var parms = ParametersMapper.RetornaParametros(entity, _entityMap, QueryType.SelectById); var selectByIdCommand = QueryMapper.ReturnSqlQuery(_entityMap, QueryType.SelectById); using IDbConnection db = new SqlConnection(_connectionString); return(db.Query <T>(selectByIdCommand, parms, commandType: CommandType.Text).FirstOrDefault()); }
public T GetById(dynamic id) { DynamicParameters parms = ParametersMapper.RetornaParametroPrimaryKeyUnica <T>(id, _entityMap); var selectAllCommand = QueryMapper.ReturnSqlQuery(_entityMap, QueryType.SelectById); using IDbConnection db = new SqlConnection(_connectionString); return(db.Query <T>(selectAllCommand, parms, commandType: CommandType.Text).FirstOrDefault()); }
private QueryBinder(QueryMapper mapper, Expression root) { this.mapper = mapper; this.language = mapper.Translator.Linguist.Language; this.map = new Dictionary <ParameterExpression, Expression>(); this.groupByMap = new Dictionary <Expression, GroupByInfo>(); this.root = root; }
public QueryResult Insert(List <T> entityList) { var parms = ParametersMapper.RetornaParametros(entityList, _entityMap, QueryType.InsertMultiple); var insertCommand = QueryMapper.ReturnSqlQuery(entityList.Count, _entityMap, QueryType.InsertMultiple); using IDbConnection db = new SqlConnection(_connectionString); var queryReturn = db.Query(insertCommand, parms, commandType: CommandType.Text).FirstOrDefault(); return(GetSqlTransactionReturn(queryReturn)); }
public LinqToLuceneIndexWithSpatial(LuceneSearchWithSpatialContext context, IExecutionContext[] executionContext) : base(context, executionContext) { this.context = context; this.executionContext = executionContext; queryMapper = new Sitecore.ContentSearch.Spatial.Query.LuceneQueryMapperWithSpatial(new LuceneIndexParameters(context.Index.Configuration.IndexFieldStorageValueFormatter, ((LuceneIndexConfiguration)context.Index.Configuration).Analyzer, context.Index.Configuration.VirtualFieldProcessors, context.Index.FieldNameTranslator, executionContext)); queryOptimizer = new Sitecore.ContentSearch.Spatial.Query.LuceneQueryOptimizerWithSpatial(); linqToLuceneIndex = new LinqToLuceneIndex <TItem>(context, executionContext); }
public ElasticSearchIndex(ElasticSearchIndexParameters parameters) { _queryOptimizer = new ElasticSearchQueryOptimizer(); if (parameters == null) { throw new ArgumentNullException("parameters"); } _queryMapper = new ElasticSearchQueryMapper(parameters); _parameters = parameters; }
public LinqToSolrIndexWithSpatial(SolrSearchContext context, IExecutionContext[] executionContexts) : base(context, executionContexts) { var parameters = new SolrIndexParameters( context.Index.Configuration.IndexFieldStorageValueFormatter, context.Index.Configuration.VirtualFieldProcessors, context.Index.FieldNameTranslator, executionContexts, context.Index.Configuration.FieldMap); this.queryMapper = new SolrSpatialQueryMapper(parameters); this.queryOptimizer = new SpatialSolrQueryOptimizer(); }
public void TestIntegrationWhithoutGlobalCacheResultOneToManyMapperQuery() { using (var queryMapper = new QueryMapper()) { var queryRunner = QueryRunner.CreateHelper(dataAccessSettings, queryMapper); var user = queryRunner.Execute <NameValue>(new QueryOneToManyMapObject(1)).ToFirstOrDefault(); Assert.AreEqual("123456", user.Phones.FirstOrDefault(p => p.Id == 1).Name); Assert.AreEqual("*****@*****.**", user.Emails.FirstOrDefault(e => e.Id == 1).Name); } }
public void DataAccessSetUp() { DbProviderFactories.RegisterFactory("System.Data.SqlClient", SqlClientFactory.Instance); TransactionScopeFactory = new DefaultTransactionScopeFactory(true, IsolationLevel.ReadCommitted, TimeSpan.FromSeconds(120)); DatabaseGateway = new DatabaseGateway(); DatabaseContextCache = new ThreadStaticDatabaseContextCache(); DatabaseContextFactory = new DatabaseContextFactory(new ConnectionConfigurationProvider(), new DbConnectionFactory(), new DbCommandFactory(), DatabaseContextCache); DatabaseContextFactory.ConfigureWith("DocumentStore"); QueryMapper = new QueryMapper(DatabaseGateway, new DataRowMapper()); }
public ApiController(FormatterContainer formatters, ICommandDispatcher commandDispatcher, IQueryDispatcher queryDispatcher, CommandMapper commandMapper, QueryMapper queryMapper) { Ensure.NotNull(formatters, "formatters"); Ensure.NotNull(commandDispatcher, "commandDispatcher"); Ensure.NotNull(queryDispatcher, "queryDispatcher"); Ensure.NotNull(commandMapper, "commandMapper"); Ensure.NotNull(queryMapper, "queryMapper"); this.formatters = formatters; this.commandDispatcher = commandDispatcher; this.queryDispatcher = queryDispatcher; this.commandMapper = commandMapper; this.queryMapper = queryMapper; }
public void TestIntegrationFirstOrDefaultWithResultMapperQuery() { using (var queryMapper = new QueryMapper()) { var queryRunner = QueryRunner.CreateHelper(dataAccessSettings, queryMapper); var user = queryRunner.Execute(new QueryUsers()).ToFirstOrDefault(); Assert.IsNotNull(user); Assert.AreEqual(1, user.Id); Assert.AreEqual("Diana Hendrix", user.Name); } }
public void TestIntegrationWhithoutExecuteCacheResultMapperQuery() { QueryMapper.RemoveCacheAfterExecuteQuery = false; using (var queryMapper = new QueryMapper()) { var queryRunner = QueryRunner.CreateHelper(dataAccessSettings, queryMapper); var user = queryRunner.Execute(new QueryUsers(1), keepCache: false).ToSingle(); var phone = queryRunner.Execute(new QueryPhone(1), keepCache: false).ToSingle(); Assert.AreEqual(1, phone.Id); Assert.AreNotEqual(user.Name, phone.Name); } }
protected override TQuery GetQuery(Expression expression) { Trace(expression, "Expression"); // here we inject a special expression parser that fixes a few issues slated to be resolved in later releases of SC7 IndexQuery rawQuery = new ExpressionParserWithSpatial(typeof(TElement), ItemType, FieldNameTranslator).Parse(expression); Trace(rawQuery, "Raw query:"); IndexQuery optimizedQuery = QueryOptimizer.Optimize(rawQuery); Trace(optimizedQuery, "Optimized query:"); TQuery mappedQuery = QueryMapper.MapQuery(optimizedQuery); return(mappedQuery); }
public void Insert(T entity, IDbConnection cnn, IDbTransaction trans) { if (cnn == null) { throw new ArgumentNullException(nameof(cnn), "Conexão não pode ser nula"); } if (trans == null) { throw new ArgumentNullException(nameof(trans), "Transação não pode ser nula"); } var parms = ParametersMapper.RetornaParametros <T>(entity, _entityMap, QueryType.Insert); var insertCommand = QueryMapper.ReturnSqlQuery <T>(_entityMap, QueryType.Insert); cnn.Query(insertCommand, parms, trans, commandType: CommandType.Text); }
private static IQueryMapper CreateQueryMapper(Option options, IServiceProvider sp) { var m = new QueryMapper(new SqlConnection(options.ReadScaleOut? (options.ReadOnlyConnString ?? (options.ConnString + "ApplicationIntent=ReadOnly;")): options.ConnString)); var logger = TryGetLogger <QueryPipe>(sp); if (logger != null) { m.AddLogger(logger); } if (options.SessionContext != null && options.SessionContext.Count >= 1) { foreach (var rls in options.SessionContext) { m.AddContextVariable(rls.Key, () => rls.Value(sp)); } } return(m); }
public void TestIntegrationOneToManyMapperQuery() { using (var queryMapper = new QueryMapper()) { var queryRunner = QueryRunner.CreateHelper(dataAccessSettings, queryMapper); var users = queryRunner.Execute <SimpleDto>(new QueryOneToMany()).ToList(); Assert.IsNotNull(users); // ReSharper disable PossibleMultipleEnumeration Assert.AreEqual(3, users.Count()); var user = users.First(); // ReSharper restore PossibleMultipleEnumeration Assert.IsNotNull(user.Phones); Assert.AreEqual(2, user.Phones.Count()); } }
public void Delete(T entity, IDbConnection cnn, IDbTransaction trans) { if (cnn == null) { throw new ArgumentNullException("cnn", "Conexão não pode ser nula"); } if (trans == null) { throw new ArgumentNullException("trans", "Transação não pode ser nula"); } var parms = ParametersMapper.RetornaParametros(entity, _entityMap, QueryType.Delete); var deleteSql = QueryMapper.ReturnSqlQuery(_entityMap, QueryType.Delete); using IDbConnection db = new SqlConnection(_connectionString); cnn.Execute(deleteSql, parms, trans, commandType: CommandType.Text); }
public ApiClient(TokenContainer token, HttpClient http, CommandMapper commandMapper, QueryMapper queryMapper, IExceptionHandler exceptionHandler, IEventDispatcher eventDispatcher) { Ensure.NotNull(token, "token"); Ensure.NotNull(http, "http"); Ensure.NotNull(commandMapper, "commandMapper"); Ensure.NotNull(queryMapper, "queryMapper"); Ensure.NotNull(exceptionHandler, "exceptionHandler"); Ensure.NotNull(eventDispatcher, "eventDispatcher"); this.token = token; this.http = http; this.commandMapper = commandMapper; this.queryMapper = queryMapper; this.exceptionHandler = exceptionHandler; this.eventDispatcher = eventDispatcher; http.BaseAddress = new Uri(rootUrl); EnsureAuthorization(); }
public ApiClient(ApiVersionChecker versionChecker, HttpClient http, CommandMapper commandMapper, QueryMapper queryMapper, IExceptionHandler exceptionHandler, ApiAuthenticationStateProvider authenticationState, ILogFactory logFactory, Json json, FormatterContainer formatters) { Ensure.NotNull(versionChecker, "versionChecker"); Ensure.NotNull(http, "http"); Ensure.NotNull(commandMapper, "commandMapper"); Ensure.NotNull(queryMapper, "queryMapper"); Ensure.NotNull(exceptionHandler, "exceptionHandler"); Ensure.NotNull(authenticationState, "authenticationState"); Ensure.NotNull(logFactory, "logFactory"); Ensure.NotNull(json, "json"); Ensure.NotNull(formatters, "formatters"); this.versionChecker = versionChecker; this.http = http; this.commandMapper = commandMapper; this.queryMapper = queryMapper; this.exceptionHandler = exceptionHandler; this.authenticationState = authenticationState; this.log = logFactory.Scope("ApiClient"); this.json = json; this.formatters = formatters; }