public LocalizedResourceDiscoveryTests()
{
var state = new ScanState();
var keyBuilder = new ResourceKeyBuilder(state);
var oldKeyBuilder = new OldResourceKeyBuilder(keyBuilder);
var ctx = new ConfigurationContext();
ctx.TypeFactory.ForQuery <DetermineDefaultCulture.Query>().SetHandler <DetermineDefaultCulture.Handler>();
var queryExecutor = new QueryExecutor(ctx.TypeFactory);
var translationBuilder = new DiscoveredTranslationBuilder(queryExecutor);
_sut = new TypeDiscoveryHelper(new List <IResourceTypeScanner>
{
new LocalizedModelTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedEnumTypeScanner(keyBuilder, translationBuilder),
new LocalizedForeignResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder)
}, ctx);
_expressionHelper = new ExpressionHelper(keyBuilder);
_types = _sut.GetTypesWithAttribute <LocalizedResourceAttribute>().ToList();
Assert.NotEmpty(_types);
}
public DisplaySqlResultsTabControl2012(
object scriptEditor,
SqlEditorTabbedEditorPane sqlScriptEditorControl)
{
m_displaySqlResultsTabControl = sqlScriptEditorControl.DisplaySqlResultsControl.GetValue(scriptEditor);
m_queryExecutor = new QueryExecutor(m_displaySqlResultsTabControl);
}
public ManageShipsController Build()
{
var commandExecutor = new CommandExecutor(_serviceProvider.GetService <ICommandHandlerFactory>());
var queryExecutor = new QueryExecutor(_serviceProvider.GetService <IQueryHandlerFactory>());
return(new ManageShipsController(commandExecutor, queryExecutor, _busRequestSender));
}
public CrawlJob(IOutgoingNotifications outgoingNotifications, IParserProvider parserProvider, ILogger logger, QueryExecutor queryExecutor)
{
_outgoingNotifications = outgoingNotifications;
_parserProvider = parserProvider;
_queryExecutor = queryExecutor;
_logger = logger;
}
static async Task <object> RunQuery(
SqlDatabase <IntegrationDbContext> database,
string query,
Inputs inputs,
GlobalFilters filters,
params object[] entities)
{
using (var dbContext = database.NewDbContext())
{
dbContext.AddRange(entities);
await dbContext.SaveChangesAsync();
}
using (var dbContext = database.NewDbContext())
{
var services = new ServiceCollection();
services.AddSingleton <Query>();
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
return(await QueryExecutor.ExecuteQuery(query, services, dbContext, inputs, filters));
}
}
public void NotInheritedModel_ContainsOnlyDeclaredProperties()
{
var state = new ScanState();
var keyBuilder = new ResourceKeyBuilder(state);
var oldKeyBuilder = new OldResourceKeyBuilder(keyBuilder);
var ctx = new ConfigurationContext();
ctx.TypeFactory.ForQuery <DetermineDefaultCulture.Query>().SetHandler <DetermineDefaultCulture.Handler>();
var queryExecutor = new QueryExecutor(ctx);
var translationBuilder = new DiscoveredTranslationBuilder(queryExecutor);
var sut = new TypeDiscoveryHelper(new List <IResourceTypeScanner>
{
new LocalizedModelTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedEnumTypeScanner(keyBuilder, translationBuilder),
new LocalizedForeignResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder)
}, ctx);
var properties = sut.ScanResources(typeof(SampleViewModelWithBase)).ToList();
var keys = properties.Select(p => p.Key).ToList();
var stringLengthResource = properties.FirstOrDefault(r => r.Key == "DbLocalizationProvider.Tests.DataAnnotations.SampleViewModelWithBase.ChildProperty-StringLength");
Assert.Contains("DbLocalizationProvider.Tests.DataAnnotations.SampleViewModelWithBase.ChildProperty-Description", keys);
Assert.NotNull(stringLengthResource);
Assert.Contains("StringLength", stringLengthResource.Translations.DefaultTranslation());
Assert.DoesNotContain("DbLocalizationProvider.Tests.DataAnnotations.SampleViewModelWithBase.BaseProperty", keys);
Assert.DoesNotContain("DbLocalizationProvider.Tests.DataAnnotations.SampleViewModelWithBase.BaseProperty-Required", keys);
Assert.DoesNotContain("DbLocalizationProvider.Tests.DataAnnotations.SampleViewModelWithBase.ChildProperty-Description-Required", keys);
}
public override JsonValue Evaluate(
QueryExecutor executor,
ExecutionFrame frame
)
{
return(Value);
}
private void Loading()
{
_executor = new QueryExecutor();
Languages = new ObservableCollection <Language>(_executor.GetLanguages());
LanguageProficiencies = new ObservableCollection <LanguageProficiency>(_executor.GetLanguageProficiencies());
}
public async Task QueryShipsByName(CoreDddSampleNhibernateConfigurator nhibernateConfigurator)
{
using (var unitOfWork = new NhibernateUnitOfWork(nhibernateConfigurator))
{
unitOfWork.BeginTransaction();
var shipRepository = new NhibernateRepository <Ship>(unitOfWork);
try
{
var ship = new Ship("lady starlight", tonnage: 10m);
await shipRepository.SaveAsync(ship);
unitOfWork.Flush();
var queryExecutor = new QueryExecutor(new FakeQueryHandlerFactory(unitOfWork));
var getShipByNameQuery = new GetShipsByNameQuery {
ShipName = "lady"
};
var shipDtos = await queryExecutor.ExecuteAsync <GetShipsByNameQuery, ShipDto>(getShipByNameQuery);
Console.WriteLine($"Ship by name query was executed by query executor. Number of ships queried: {shipDtos.Count()}");
await unitOfWork.CommitAsync();
}
catch
{
await unitOfWork.RollbackAsync();
throw;
}
}
}
static async Task <object> RunQuery(
SqlDatabase <IntegrationDbContext> database,
string query,
Inputs?inputs,
Filters?filters,
bool diableTracking,
params object[] entities)
{
var dbContext = database.Context;
dbContext.AddRange(entities);
await dbContext.SaveChangesAsync();
var services = new ServiceCollection();
services.AddSingleton <Query>();
services.AddSingleton <Mutation>();
services.AddSingleton(database.Context);
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
return(await QueryExecutor.ExecuteQuery(query, services, database.NewDbContext(), inputs, filters, diableTracking));
}
public int ExecuteDataPlan(nDumpOptions nDumpOptions, ILogger logger, DataPlan dataPlan)
{
if (nDumpOptions.Export)
{
var queryExecutor = new QueryExecutor(nDumpOptions.SourceConnectionString);
ISelectionFilteringStrategy filteringStrategy = nDumpOptions.ApplyFilters ? (ISelectionFilteringStrategy)
new UseFilterIfPresentStrategy(queryExecutor, logger)
: new IgnoreFilterStrategy();
var exporter = new SqlDataExporter(logger, nDumpOptions.CsvDirectory,
queryExecutor, filteringStrategy);
try
{
exporter.ExportToCsv(dataPlan.SetupScripts, dataPlan.DataSelects);
}
catch (nDumpApplicationException ex)
{
logger.Log("Export To Csv Failed.\n" + ex.StackTrace);
return -1;
}
}
if (nDumpOptions.Transform)
{
var transformer = new DataTransformer(nDumpOptions.SqlDirectory, nDumpOptions.CsvDirectory,
logger);
try
{
transformer.ConvertCsvToSql(dataPlan.DataSelects);
}
catch (nDumpApplicationException ex)
{
logger.Log("Export To Csv Failed.\n" + ex.StackTrace);
return -1;
}
}
if (nDumpOptions.Import)
{
var importer = new SqlDataImporter(logger,
new QueryExecutor(nDumpOptions.TargetConnectionString), new IncrementingNumberSqlScriptFileStrategy(nDumpOptions.SqlDirectory));
try
{
importer.RemoveDataAndImportFromSqlFiles(dataPlan.DataSelects);
}
catch (nDumpApplicationException ex)
{
logger.Log("Import Of Sql Failed.\n" + ex.Message + "\n" + ex.StackTrace);
return -1;
}
}
return 0;
}
public async Task <Product> GetProductById(int selectStoreId, long selectId)
{
string query = "Select * from product where storeid = @0 and id = @1;";
object[] row = await QueryExecutor.SelectSingle(dbConnectionString, query, MySqlDbType.Int32, selectStoreId, MySqlDbType.Int32, selectId);
if (row[0] == null)
{
return(null); // empty record
}
int id = (int)row[0];
int storeId = (int)row[1];
int groupId = (int)row[2];
ProductGroup productGroup = await GetProductGroup(selectStoreId, groupId);
string name = (row[3] == DBNull.Value) ? null : (string)row[3];
string brand = (row[4] == DBNull.Value) ? null : (string)row[4];
double?buyingPrice = (row[5] == null) ? null : (double?)row[5];
double?sellingPrice = (row[6] == null) ? null : (double?)row[6];
string supplier = (row[7] == DBNull.Value) ? null : (string)row[7];
string productNumber = (row[8] == DBNull.Value) ? null : (string)row[8];
string ean = (row[9] == DBNull.Value) ? null : (string)row[9];
Product product = new Product(id, storeId, name, brand, buyingPrice, sellingPrice, supplier, productNumber, ean, productGroup);
return(product);
}
public GetAllUsersUICommand(MainWindowViewModel mainWindowViewModel, CommandExecutor commandExecutor, QueryExecutor queryExecutor, RequestExecutor requestExecutor)
: base(commandExecutor, queryExecutor, requestExecutor)
{
Argument.IsNotNull(mainWindowViewModel, "mainWindowViewModel");
_mainWindowViewModel = mainWindowViewModel;
}
public bool Import(IDatabaseConnection databaseConnection, string tableName, string data)
{
Contract.Requires(!string.IsNullOrEmpty(tableName));
Contract.Requires(!string.IsNullOrEmpty(data));
Contract.Requires(databaseConnection != null);
var rows = data.Split(new[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries);
if (rows.Length < 1)
{
return(false);
}
var columns = rows[0].Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
if (columns.Length < 1)
{
return(false);
}
for (var i = 1; i < rows.Length; i++)
{
var columnValues = rows[i].Split(',');
if (columns.Length == columnValues.Length)
{
var rawQuery = string.Format("INSERT INTO {0}({1}) VALUES({2})", tableName, string.Join(",", columns), string.Join(",", columnValues));
IQuery query = new SqlQuery(rawQuery);
IQueryExecutor queryExecutor = new QueryExecutor();
queryExecutor.Execute(databaseConnection, query);
}
}
return(true);
}
public static void Execute(Action <QueryExecutor> action)
{
ExecuteDbAction(conn => {
var executor = new QueryExecutor(conn);
action(executor);
});
}
public void ShouldBeAbleToQueryAcrossTwoIncludedTables()
{
// Arrange
var departmentName1 = GetRandomString(5);
var departmentId1 = CreateDepartment(departmentName1);
var departmentName2 = GetRandomString(5);
var departmentId2 = CreateDepartment(departmentName2);
var personName = GetRandomString(5);
var personId = CreatePerson(personName);
AssociatePersonWithDepartment(personId, departmentId1);
AssociatePersonWithDepartment(personId, departmentId2);
// Act
var result = QueryExecutor.Execute(
new FindPersonWithDepartments(
personId
)
);
// Assert
Expect(result)
.Not.To.Be.Null();
var person = FindPersonById(personId);
Expect(result)
.To.Intersection.Equal(person);
var departments = FindDepartmentsById(departmentId1, departmentId2);
Expect(result.Departments)
.To.Be.Deep.Equivalent.To(departments);
}
public DataAnnotationsTests()
{
var state = new ScanState();
var keyBuilder = new ResourceKeyBuilder(state);
var oldKeyBuilder = new OldResourceKeyBuilder(keyBuilder);
var ctx = new ConfigurationContext();
ctx.TypeFactory
.ForQuery <DetermineDefaultCulture.Query>().SetHandler <DetermineDefaultCulture.Handler>()
.ForQuery <GetTranslation.Query>().SetHandler <GetTranslationReturnResourceKeyHandler>();
var queryExecutor = new QueryExecutor(ctx);
var translationBuilder = new DiscoveredTranslationBuilder(queryExecutor);
_sut = new TypeDiscoveryHelper(new List <IResourceTypeScanner>
{
new LocalizedModelTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedEnumTypeScanner(keyBuilder, translationBuilder),
new LocalizedForeignResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder)
}, ctx);
var expressHelper = new ExpressionHelper(keyBuilder);
_provider = new LocalizationProvider(keyBuilder, expressHelper, new FallbackLanguagesCollection(), queryExecutor);
}
public int Insert(Customer obj)
{
var Id = QueryExecutor.ExecuteScalar(StoreProcedures.sp_Customer_Insert.ToString(), new {
obj.CountryId,
obj.CityId,
obj.NationalityId,
obj.CustomerTypeId,
obj.CustomerClassId,
obj.GenderId,
obj.CurrencyId,
obj.CustomerNameA,
obj.CustomerNameE,
obj.AddressArb,
obj.AddressEng,
obj.Phone,
obj.Email,
obj.Occupation,
obj.AnotherPhone,
obj.Street,
obj.Suburb,
obj.PostCode,
obj.State,
obj.BirthDate,
obj.CreatedOn,
obj.CreatedBy
});
if (obj.CustomerDocument != null && obj.CustomerDocument.DocumentTypeId > 0)
{
obj.CustomerDocument.CustomerId = Convert.ToInt32(Id);
new CustomerDocumentRepository().Insert(obj.CustomerDocument);
}
return(1);
}
public void TestData()
{
var db = Database.Opener.OpenConnection(_ConnectionString, _ProviderName);
var queryText = "db.t20150201file.All().Where(db.t20150201file.id < 100);";
var executor = new QueryExecutor(queryText);
object result;
executor.CompileAndRun(db, out result);
Data = FormatResult(result);
// IEnumerable<dynamic> list = db.t20150201file.All()
// .Where(db.t20150201file.id < 100)
// .ToList();
// var firstRow = list.FirstOrDefault() as IDictionary<string, object>;
// var table = new DataTable();
// foreach (var kvp in firstRow)
// {
// table.Columns.Add(kvp.Key);
// }
// foreach (var row in list.Cast<IDictionary<string, object>>())
// {
// table.Rows.Add(row.Values.ToArray());
// }
// Data = table.DefaultView;
}
private static List <PremiseRaw> LoadPremises(string path)
{
Logger.Write(string.Format("Load data from file {0}", path), MsgType.InformationMsg);
var executor = new QueryExecutor("\t", "\r\n", true, true);
var tableJoin = executor.Execute("SELECT * FROM \"" + path + "\"");
var premises = new List <PremiseRaw>();
foreach (var row in tableJoin.Rows)
{
premises.Add(new PremiseRaw
{
CRN = row.Cells[0].Value.AsString().Value(), // feb, mar, apr, may, jun, jul, aug, sept, oct 0, nov 0
Account = row.Cells[1].Value.AsString().Value(), // feb, mar, apr, may, jun 2, jul 1, aug, sept, oct 2, nov 0
Tenant = row.Cells[2].Value.AsString().Value(), // feb, mar, apr, may, jun 3, jul 2, aug, sept, oct 3, nov 0
RawAddress = row.Cells[3].Value.AsString().Value(), // feb, mar, apr, may, jun 4, jul 3, aug, sept, oct 4, nov 0
RawType = row.Cells[4].Value.AsString().Value(), // feb 7, mar, apr 8, may, jun 6, jul 5, aug, sept, oct 8, nov 6
TotalArea = row.Cells[5].Value.AsString().Value(), // feb 8, mar, apr 9, may, jun 7, jul 6, aug, sept, oct 9, nov 7
LivingArea = row.Cells[6].Value.AsString().Value(), // feb 9, mar, apr 10, may, jun 8, jul 7, aug, sept, oct 10, nov 8
Prescribed = row.Cells[7].Value.AsString().Value(), // feb 10, mar, apr 11, may, jun 9, jul 8, aug, sept, oct 11, nov 9
BalanceInput = row.Cells[8].Value.AsString().Value(), // feb 11, mar, apr 12, may, jun 10, jul 9, aug, sept, oct 12, nov 10
BalanceTenancy = row.Cells[9].Value.AsString().Value(), // feb 12, mar, apr 13, may 11, jun 13, jul 10, aug, sept, oct 15, nov 13
Penalties = row.Cells[10].Value.AsString().Value(),
BalanceOutput = row.Cells[11].Value.AsString().Value(), // feb 14, mar 15, apr 16, may 14, jun 16, jul 13, aug, sept 18, oct 19, nov 16
DzPadun = row.Cells[12].Value.AsString().Value(),
DzPkk = row.Cells[13].Value.AsString().Value(),
DzDgi = row.Cells[14].Value.AsString().Value(), // feb, mar empty, apr 15, may 13, jun 15, jul 12, aug, sept 17, oct 18, nov 15
});
}
return(premises);
}
public StandardQueryViewModel(ConnectionStrings connectionStrings, IQuery query, IQueryCollection httpQueries)
{
_query = query;
_queryExecutor = new QueryExecutor(connectionStrings, _query, httpQueries);
_queryExecutor.Run();
}
public async Task <IActionResult> GetAsync([FromQuery] string name, [FromQuery] int recordCount = defaultRecordCount)
{
string returnString = string.Empty;
int? statusCode = Microsoft.AspNetCore.Http.StatusCodes.Status200OK;
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
try
{
string cachedString = string.Empty;
if (EnableCache && MemoryCache.TryGetValue(name, out cachedString))
{
returnString = cachedString;
}
else
{
using (QueryExecutor queryExecutor = new QueryExecutor(Configuration["Data:DefaultConnection:ConnectionString"]))
{
var returnList = await queryExecutor.QueryAsync <object>(
GetQuery(recordCount),
r =>
{
return(new
{
InternalValueSetEntryID = r.GetInt64(0),
InternalValueSetID = r.GetInt64(1),
ExtJson = r.GetString(2),
ExtraColumn = r.GetString(3)
});
},
new { Name = name }
);
returnString = JsonSerializer.Serialize(returnList);
if (EnableCache)
{
MemoryCache.Set <string>(name, returnString);
}
}
}
stopWatch.Stop();
Logger.LogInformation("GetAsync call with {0} took {1} ms", name, stopWatch.ElapsedMilliseconds);
}
catch (Exception ex)
{
Logger.LogError("Excption on GetAsync call with {0} : {1}", name, ex.Message);
statusCode = Microsoft.AspNetCore.Http.StatusCodes.Status500InternalServerError;
returnString = ex.Message;
}
return(new ContentResult()
{
Content = returnString,
StatusCode = statusCode,
ContentType = "application/fhir+json;charset=utf-8"
});
}
public SqlToExpressionParsing()
{
TablesMetadata tablesMetadata = new TablesMetadata();
tablesMetadata.AddTable(new TableMetadata("project", typeof(Project)));
var queryExecutor = new QueryExecutor(
new TableResolver(),
new DefaultFromTableExecutorFactory(),
new DefaultWhereExecutorFactory(),
new DefaultGroupByExecutorFactory(),
new DefaultSelectExecutorFactory(),
new DefaultOrderByExecutorFactory(),
new DefaultOffsetExecutorFactory(),
new DefaultDistinctExecutorFactory(),
new DefaultAggregateFunctionFactory());
sqlExecutor = new SqlExecutor(
new AntlrSqlParser(),
tablesMetadata,
queryExecutor,
new DefaultSearchExpressionProvider(),
new DefaultOperationsProvider());
sql150Parser = new TSql150Parser(true);
}
public int Insert(Gender obj)
{
return(QueryExecutor.Execute(StoreProcedures.sp_Gender_Insert.ToString(), new {
obj.GenderNameA,
obj.GenderNameE
}));
}
public LocalizedEnumTests()
{
var types = new[] { typeof(DocumentEntity) };
var state = new ScanState();
var keyBuilder = new ResourceKeyBuilder(state);
var oldKeyBuilder = new OldResourceKeyBuilder(keyBuilder);
var ctx = new ConfigurationContext();
ctx.TypeFactory.ForQuery <DetermineDefaultCulture.Query>().SetHandler <DetermineDefaultCulture.Handler>();
var queryExecutor = new QueryExecutor(ctx.TypeFactory);
var translationBuilder = new DiscoveredTranslationBuilder(queryExecutor);
_sut = new TypeDiscoveryHelper(new List <IResourceTypeScanner>
{
new LocalizedModelTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedEnumTypeScanner(keyBuilder, translationBuilder),
new LocalizedForeignResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder)
}, ctx);
_expressionHelper = new ExpressionHelper(keyBuilder);
Assert.NotEmpty(types);
_properties = types.SelectMany(t => _sut.ScanResources(t));
}
public int AddProvider(Provider provider)
{
var obj = new
{
Action_Type = 101, // TODO: not sure if this is correct
Name = provider.Name,
Code = provider.Code,
Address = provider.Address,
CountryID = provider.CountryID,
CurrencyID = provider.CountryID,
TelephoneNo = provider.TelephoneNo,
Fax = provider.Fax,
POBoxNo = provider.POBoxNo,
Email = provider.Email,
ProfilePicture = provider.ProfilePicture,
ProviderTypeID = provider.ProviderTypeID,
InNetwork = provider.InNetwork,
Within_Outside_Network = provider.Within_Outside_Network,
CreatedOn = DateTime.Now, // TODO: need to pass correct value
CreatedBy = provider.CreatedBy,
UpdatedOn = DateTime.Now, // TODO: need to pass correct value
UpdatedBy = provider.UpdatedBy,
};
DynamicParameters dynamicParameters = new DynamicParameters(obj);
dynamicParameters.Add("@ID", dbType: DbType.Int32, direction: ParameterDirection.Output);
return(QueryExecutor.ExecuteWithReturnValue <int>(StoreProcedures.usp_GetSaveUpdateTPAProvider.ToString(), "ID", dynamicParameters, CommandType.StoredProcedure));
}
public void ShouldBeAbleToUseAllResultSets()
{
// Arrange
var personName = GetRandomString(5);
var personId = CreatePerson(personName);
var departmentName = GetRandomString(5);
var departmentId = CreateDepartment(departmentName);
// Act
var result = QueryExecutor.Execute(
new FindAllPeopleAndDepartments()
);
// Assert
// result likely has more than just the entities
// created in this test -- which is OK
Expect(result.People)
.Not.To.Be.Empty();
var person = FindPersonById(personId);
Expect(result.People)
.To.Contain.Exactly(1)
.Deep.Equal.To(person);
Expect(result.Departments)
.Not.To.Be.Empty();
var department = FindDepartmentsById(departmentId).Single();
Expect(result.Departments)
.To.Contain.Exactly(1)
.Deep.Equal.To(department);
}
public RoleService(QueryExecutor queryExecutor, ModelMapper modelMapper, IMapper autoMapper, SqlCommands sqlCommands)
{
this._queryExecutor = queryExecutor;
this._modelMapper = modelMapper;
this._autoMapper = autoMapper;
this._sqlCommands = sqlCommands;
}
public void Execute_NoHandlerDefined_ThrowsException()
{
var queryExecutor = new QueryExecutor(t => {throw new Exception();});
var expectedMessage = string.Format("Can not resolve handler for IQueryHandler<{0}, {1}>", typeof(IQuery<object>).Name, typeof(object).Name);
Assert.That(() => queryExecutor.Execute<IQuery<object>, object>(_query), Throws.InstanceOf<ResolverException>().And.Message.EqualTo(expectedMessage));
}
public AuthService(JwtGenerator jwtGenerator, QueryExecutor queryExecutor, ModelMapper modelMapper, SqlCommands sqlCommands)
{
this._jwtGenerator = jwtGenerator;
this._queryExecutor = queryExecutor;
this._modelMapper = modelMapper;
this._sqlCommands = sqlCommands;
}
public void Setup()
{
tpchData = new TpchData();
TablesMetadata tablesMetadata = new TablesMetadata();
tablesMetadata.AddTable(new TableMetadata("typetest", typeof(TypeTest), new InMemoryOperationsProvider()));
tablesMetadata.AddTable(new TableMetadata("typetestdefaultoperationprovider", typeof(TypeTest)));
var queryExecutor = new QueryExecutor(
new TypeTestTableResolver(),
new DefaultFromTableExecutorFactory(),
new DefaultWhereExecutorFactory(),
new DefaultGroupByExecutorFactory(),
new DefaultSelectExecutorFactory(),
new DefaultOrderByExecutorFactory(),
new DefaultOffsetExecutorFactory(),
new DefaultDistinctExecutorFactory(),
new DefaultAggregateFunctionFactory());
sqlExecutor = new SqlExecutor(
new AntlrSqlParser(),
tablesMetadata,
queryExecutor,
new DefaultSearchExpressionProvider(),
new DefaultOperationsProvider());
}
public DbFieldReader(QueryExecutor executor, DbDataReader reader)
{
this.executor = executor;
this.reader = reader;
this.Init();
}
public static string Create(string xml)
{
var result = string.Empty;
var dt = new System.Data.DataTable();
var data = new AnalyticsData(xml, AnalyticsType.Frequent, AnalyticsAction.Create);
try
{
var exec = new QueryExecutor(SPContext.Current.Web);
dt = exec.ExecuteEpmLiveQuery(
FRFQueryFactory.GetQuery(data),
FRFQueryParamFactory.GetParam(data));
if (dt != null && dt.Rows.Count > 0)
{
result = string.Join(",", dt.Rows[0].ItemArray);
}
ClearCache(data);
}
catch (Exception e)
{
result = "error: " + e.Message;
}
return(result);
}
protected BaseInteractionHandler(QueryExecutor queryExecutor, UnitOfWork unitOfWork)
{
Argument.IsNotNull(queryExecutor, "queryExecutor");
Argument.IsNotNull(unitOfWork, "unitOfWork");
QueryExecutor = queryExecutor;
UnitOfWork = unitOfWork;
}
public void Execute_QueryHandlerResolved_CallsHandleMethod()
{
var queryExecutor = new QueryExecutor(t => _handler);
queryExecutor.Execute<IQuery<object>, object>(_query);
_handler.CallsTo(m => m.Handle(_query)).MustHaveHappened(Repeated.Exactly.Once);
}
public DbTestingUtility(QueryExecutor queryExecutor, ILogger logger = null)
{
this.queryExecutor = queryExecutor;
this.logger = logger ?? new DebugLogger();
errors = new List<Exception>();
schemaScripts = new List<IExecutableScript>();
setupScripts = new List<IExecutableScript>();
tearDownScripts = new List<IExecutableScript>();
}
public void CanExecuteQuery()
{
var database = Database.OpenConnection("data source=.;initial catalog=SimpleTest;integrated security=true");
var query = "db.Users.FindById(1)";
var executor = new QueryExecutor(query);
object result;
Assert.True(executor.CompileAndRun(database, out result));
var dict = result as IDictionary<string, object>;
Assert.NotNull(dict);
}
protected BaseUICommand(CommandExecutor commandExecutor, QueryExecutor queryExecutor, RequestExecutor requestExecutor)
{
Argument.IsNotNull(commandExecutor, "commandExecutor");
Argument.IsNotNull(queryExecutor, "queryExecutor");
Argument.IsNotNull(requestExecutor, "requestExecutor");
CommandExecutor = commandExecutor;
QueryExecutor = queryExecutor;
RequestExecutor = requestExecutor;
}
public void Execute(QueryExecutor queryExecutor, string connectionString)
{
cfg.Properties[Environment.ConnectionString] = connectionString;
var exporter = new SchemaExport(cfg)
.SetDelimiter(delimiter);
if (!string.IsNullOrEmpty(outputFile)) {
exporter.SetOutputFile(outputFile);
}
exporter.Execute(script: false, export: true, justDrop: false);
}
public void Context()
{
var container = Stub<IContainer>();
IoC.Initialize(container);
_testQueryHandler = Mock<IQueryHandler<TestQuery>>();
_testQuery = new TestQuery();
_testQueryHandler.Expect(a => a.Execute<bool>(Arg<TestQuery>.Matches(p => p == _testQuery))).Return(new[] { true });
container.Stub(x => x.Resolve<IQueryHandler<TestQuery>>()).Return(_testQueryHandler);
var queryExecutor = new QueryExecutor();
_result = queryExecutor.Execute<TestQuery, bool>(_testQuery);
}
public void Execute_CallsResolverWithExpectedType()
{
bool wasCalledWithExpectedType = false;
var queryExecutor = new QueryExecutor(t =>
{
if (t == typeof(IQueryHandler<IQuery<object>, object>))
{
wasCalledWithExpectedType = true;
}
return _handler;
});
queryExecutor.Execute<IQuery<object>, object>(_query);
Assert.That(wasCalledWithExpectedType, Is.True);
}
public void QueryOverModelExecutesFastEnough()
{
const int REPETITIONS = 1000;
AddTestData();
var count = 0;
using (var connection = CreateConnection())
{
Stopwatch sw = new Stopwatch();
sw.Start();
var executor = new QueryExecutor(connection.ConnectionString);
for (var i = 0; i < REPETITIONS; i++)
count = executor.LoadObjects<Role>(@"select * from Role", new Dictionary<string, object>()).ToList().Count;
sw.Stop();
Console.WriteLine("ELEMENTS: {0}", count);
Console.WriteLine("SQL + EXECUTOR: {0}", sw.Elapsed);
sw.Reset();
sw.Start();
for (var i = 0; i < REPETITIONS; i++)
count = connection.Query<User>(@"select * from Role").Count();
sw.Stop();
Console.WriteLine("ELEMENTS: {0}", count);
Console.WriteLine("SQL + DAPPER: {0}", sw.Elapsed);
sw.Reset();
sw.Start();
for (var i = 0; i < REPETITIONS; i++)
{
Expression<Func<IQuery<Role>>> roles = () => from r in builder.Table<Role>() select r;
roles.ToString();
count = connection.Query<User>(@"select * from Role").Count();
}
sw.Stop();
Console.WriteLine("ELEMENTS: {0}", count);
Console.WriteLine("CACHED LINQ + DAPPER: {0}", sw.Elapsed);
sw.Reset();
sw.Start();
for (var i = 0; i < REPETITIONS; i++)
count = connection.Query(from r in builder.Table<Role>() select r).Count();
sw.Stop();
Console.WriteLine("ELEMENTS: {0}", count);
Console.WriteLine("LINQ + DAPPER: {0}", sw.Elapsed);
}
}
public void SetUp()
{
builder = new QueryBuilder();
var dir = Directory.GetCurrentDirectory();
executor = new QueryExecutor(@"Data Source=(LocalDB)\v11.0;AttachDbFilename=" + dir + @"\App_Data\TestData.mdf;Integrated Security=True;Connect Timeout=30");
}
public QueryForm(MainForm Parent, SqlConnector DataProvider, string Script = "")
{
InitializeComponent();
this.Parent = Parent;
this.DataProvider = DataProvider;
Query.Text = Script;
CurrentScript = Script;
Executor = new QueryExecutor();
if (DataProvider != null && !String.IsNullOrEmpty(DataProvider.ConnectionString))
Executor.Initialize(DataProvider.ConnectionString);
Executor.FinishExec += new ProcessingQuery(Conx_FinishExec);
Executor.StartExec += new ProcessingQuery(Conx_StartExec);
ServerTxt.Text = DataProvider.Server;
BDTxt.Text = DataProvider.DataBase;
ConnectionGroup = Parent.ConxGroup;
ConnectionName = Parent.ConxName;
#region Code to load the Highlight rules(files in resources) and the folding strategy class
try
{
HighlightingManager.Manager.AddSyntaxModeFileProvider(new FileSyntaxModeProvider(MainForm.DataStorageDir + "\\SintaxHighLight\\"));
Query.Document.HighlightingStrategy = HighlightingManager.Manager.FindHighlighter("SQL");
Query.Document.FormattingStrategy = new Ez_SQL.TextEditorClasses.SqlBracketMatcher();
Query.Document.FoldingManager.FoldingStrategy = new Ez_SQL.TextEditorClasses.SqlFolder();
Query.Document.FoldingManager.UpdateFoldings(null, null);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
#endregion
#region Code to assign the method that will handle the key press event and the method to refresh the folding
//Method that handles autocomplete and key shortcuts
Query.ActiveTextAreaControl.TextArea.DoProcessDialogKey += Query_DoProcessDialogKey;
//Method that refresh the folding
Query.Document.DocumentChanged += Query_DocumentChanged;
#endregion
//capture mouse click, to manage ctr + click
Query.ActiveTextAreaControl.TextArea.MouseClick += MouseClicked;
this.AutoScroll = false;
//handle mouse click, to show a context menu for the tabs
TabHolder.MouseClick += new MouseEventHandler(TabHolder_MouseClick);
//for locked tabs there can be some "comments" shown as tooltip
TabHolder.ShowToolTips = true;
#region Matching types, between SQL and C#, both ways
if (SqlVsCSharp == null)
{
SqlVsCSharp = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
SqlVsCSharp.Add("bigint", "int");
SqlVsCSharp.Add("binary", "int");
SqlVsCSharp.Add("bit", "bool");
SqlVsCSharp.Add("char", "string");
SqlVsCSharp.Add("date", "DateTime");
SqlVsCSharp.Add("datetime", "DateTime");
SqlVsCSharp.Add("datetime2", "DateTime");
SqlVsCSharp.Add("float", "double");
SqlVsCSharp.Add("int", "int");
SqlVsCSharp.Add("decimal", "double");
SqlVsCSharp.Add("money", "double");
SqlVsCSharp.Add("nchar", "string");
SqlVsCSharp.Add("ntext", "string");
SqlVsCSharp.Add("numeric", "int");
SqlVsCSharp.Add("nvarchar", "string");
SqlVsCSharp.Add("real", "double");
SqlVsCSharp.Add("smalldatetime", "DateTime");
SqlVsCSharp.Add("smallint", "int");
SqlVsCSharp.Add("smallmoney", "double");
SqlVsCSharp.Add("sysname", "string");
SqlVsCSharp.Add("text", "string");
SqlVsCSharp.Add("timestamp", "DateTime");
SqlVsCSharp.Add("tinyint", "int");
SqlVsCSharp.Add("varbinary", "int");
SqlVsCSharp.Add("varchar", "string");
SqlVsCSharp.Add("System.Boolean", "bool");
SqlVsCSharp.Add("System.Int32", "int");
SqlVsCSharp.Add("System.String", "string");
SqlVsCSharp.Add("System.Decimal", "float");
SqlVsCSharp.Add("System.Double", "float");
SqlVsCSharp.Add("System.DateTime", "DateTime");
}
if (SqlVsCSharpDb == null)
{
SqlVsCSharpDb = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
SqlVsCSharpDb.Add("bigint", "SqlDbType.BigInt");
SqlVsCSharpDb.Add("binary", "SqlDbType.Binary");
SqlVsCSharpDb.Add("bit", "SqlDbType.Bit");
SqlVsCSharpDb.Add("char", "SqlDbType.Char");
SqlVsCSharpDb.Add("datetime", "SqlDbType.DateTime");
SqlVsCSharpDb.Add("float", "SqlDbType.Float");
SqlVsCSharpDb.Add("int", "SqlDbType.Int");
SqlVsCSharpDb.Add("decimal", "SqlDbType.Decimal");
SqlVsCSharpDb.Add("money", "SqlDbType.Float");
SqlVsCSharpDb.Add("nchar", "SqlDbType.NChar");
SqlVsCSharpDb.Add("ntext", "SqlDbType.NText");
SqlVsCSharpDb.Add("numeric", "SqlDbType.Int");
SqlVsCSharpDb.Add("nvarchar", "SqlDbType.NVarChar");
SqlVsCSharpDb.Add("real", "SqlDbType.Real");
SqlVsCSharpDb.Add("smalldatetime", "SqlDbType.SmallDateTime");
SqlVsCSharpDb.Add("smallint", "SqlDbType.SmallInt");
SqlVsCSharpDb.Add("smallmoney", "SqlDbType.SmallMoney");
SqlVsCSharpDb.Add("sysname", "SqlDbType.Text");
SqlVsCSharpDb.Add("text", "SqlDbType.Text");
SqlVsCSharpDb.Add("timestamp", "SqlDbType.Timestamp");
SqlVsCSharpDb.Add("tinyint", "SqlDbType.TinyInt");
SqlVsCSharpDb.Add("varbinary", "SqlDbType.VarBinary");
SqlVsCSharpDb.Add("varchar", "SqlDbType.VarChar");
}
if (CSharpVsSql == null)
{
CSharpVsSql = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
CSharpVsSql.Add("System.Char", "char");
CSharpVsSql.Add("System.Boolean", "bit");
CSharpVsSql.Add("System.Int16", "int");
CSharpVsSql.Add("System.Int32", "int");
CSharpVsSql.Add("System.Int64", "int");
CSharpVsSql.Add("System.String", "varchar");
CSharpVsSql.Add("System.Single", "float");
CSharpVsSql.Add("System.Decimal", "float");
CSharpVsSql.Add("System.Double", "float");
CSharpVsSql.Add("System.DateTime", "DateTime");
}
#endregion
}
public void Execute(QueryExecutor queryExecutor, string connectionString)
{
script.Execute(queryExecutor, connectionString);
}
public StartBlogApplicationUICommand(CommandExecutor commandExecutor, QueryExecutor queryExecutor, RequestExecutor requestExecutor)
: base(commandExecutor, queryExecutor, requestExecutor)
{
}
public void Execute(QueryExecutor queryExecutor, string connectionString)
{
queryExecutor.ExecuteNonQuery(queryRetriever(), connectionString);
}
public void ReadObject(IList<object> otherPrimValues, string propertyName, QueryExecutor executor)
{
throw new System.NotImplementedException();
}
void RunImpl()
{
SaveSettings();
if (_queryText == null)
{
TraceOutput = "Please Write a query first and then hit run";
return;
}
TraceOutput = string.Empty;
var database = CreateDatabase();
var executor = new QueryExecutor(_queryText);
object result;
DataAvailable = executor.CompileAndRun(database, out result);
ResultColor = DataAvailable ? Colors.Black : Colors.Red;
Data = FormatResult(result);
}
public void Execute(QueryExecutor queryExecutor, string connectionString)
{
string data;
using (var stream = assembly.GetManifestResourceStream(resourceName)) {
if (stream == null) {
var message = string.Format("Resource {0} not found in {1}", resourceName, assembly);
throw new Exception(message);
}
data = new StreamReader(stream).ReadToEnd();
}
queryExecutor.ExecuteNonQuery(data, connectionString);
}
void RunImpl()
{
SaveSettings();
TraceOutput = string.Empty;
var database = CreateDatabase();
var executor = new QueryExecutor(_queryText);
object result;
DataAvailable = executor.CompileAndRun(database, out result);
ResultColor = DataAvailable ? Colors.Black : Colors.Red;
Data = FormatResult(result);
}
public QueryExecutorTests()
{
_resolverMock = Substitute.For<IResolver>();
_queryExecutor = new QueryExecutor(_resolverMock, new IExecutionDecorator[0]);
}
public OTrackingQueryExecutor(ITrackingRepository repository, QueryExecutor executor)
: base(repository, executor)
{
}
public OFieldReader(QueryExecutor executor, DbDataReader reader)
: base(executor, reader)
{
}
