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;
}
