protected override Provider VisitSelect(SelectProvider provider)
{
var requiredColumns = mappings[provider];
var remappedColumns = requiredColumns
.Select(c => provider.ColumnIndexes[c])
.ToList(requiredColumns.Count);
mappings[provider.Source] = remappedColumns;
var source = VisitCompilable(provider.Source);
var sourceMap = mappings[provider.Source];
var indexColumns = new List <int>(provider.ColumnIndexes.Count);
var newMappings = new List <int>(provider.ColumnIndexes.Count);
var currentItemIndex = 0;
foreach (var item in provider.ColumnIndexes)
{
var indexInMap = sourceMap.IndexOf(item);
if (indexInMap >= 0)
{
indexColumns.Add(indexInMap);
newMappings.Add(currentItemIndex);
}
currentItemIndex++;
}
mappings[provider] = newMappings;
return(source == provider.Source
? provider
: new SelectProvider(source, indexColumns.ToArray()));
}
public void GetSelectFieldsTest()
{
var type = typeof(AttributeModel);
var tableInfo = new DbTableInfo(type).SetFields(
new DbFieldInfo("IntProperty", "IntKey"),
new DbFieldInfo("NotField").SetNotDbField());
var select = new SelectProvider <AttributeModel>(null, null);
var select2 = new SelectProvider <AttributeModel>(tableInfo, null);
var test1 = select.Fields(null).GetSelectFields();
var test2 = select.Fields("").GetSelectFields();
var test3 = select.Fields("ID,StringProperty,IntProperty").GetSelectFields();
var test4 = select.Fields("ID,StringProperty,IntField").GetSelectFields();
var test5 = select2.Fields("").GetSelectFields();
var test6 = select2.Fields("ID,StringProperty,IntProperty").GetSelectFields();
var expected1 = @"ID,StringProperty,IntField AS IntProperty";
var expected2 = @"ID,StringProperty,IntField";
var expected3 = @"ID,StringProperty,IntKey AS IntProperty";
Assert.AreEqual("*", test1);
Assert.AreEqual(expected1, test2);
Assert.AreEqual(expected1, test3);
Assert.AreEqual(expected2, test4);
Assert.AreEqual(expected3, test5);
Assert.AreEqual(expected3, test6);
}
private static ProjectionExpression Optimize(ProjectionExpression origin)
{
var originProvider = origin.ItemProjector.DataSource;
var usedColumns = origin.ItemProjector
.GetColumns(ColumnExtractionModes.KeepSegment | ColumnExtractionModes.KeepTypeId | ColumnExtractionModes.OmitLazyLoad)
.ToList();
if (usedColumns.Count == 0)
{
usedColumns.Add(0);
}
if (usedColumns.Count < origin.ItemProjector.DataSource.Header.Length)
{
var resultProvider = new SelectProvider(originProvider, usedColumns.ToArray());
var itemProjector = origin.ItemProjector.Remap(resultProvider, usedColumns.ToArray());
var result = new ProjectionExpression(
origin.Type,
itemProjector,
origin.TupleParameterBindings,
origin.ResultType);
return(result);
}
return(origin);
}
/// <summary>
/// Отправка таблицы Отгрузка провайдерам
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ButtonTotalToProviders_Click(object sender, RibbonControlEventArgs e)
{
try
{
SelectProvider selectProvider = new SelectProvider();
selectProvider.ShowDialog();
if (selectProvider.DialogResult != DialogResult.OK)
{
return;
}
ShefflerWB.ExcelOptimizateOn();
if (selectProvider.Provider == "Отправить всем")
{
new Functions().SendEmailToProviderAdoutAdding();
}
else
{
new Functions().SendEmailToProviderAdoutAdding(selectProvider.Provider);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally
{
ShefflerWB.ExcelOptimizateOff();
}
}
public void ValidateSelectedColumnIndexes(SelectProvider provider)
{
if (owner.State.Predicates.Count == 0)
{
return;
}
collectorHelper.ValidateNewColumnIndexes(owner.State.Predicates, provider.Header.Columns,
Strings.ExColumnsUsedByPredicateContainingApplyParameterAreRemoved);
}
public void GetSqlTest()
{
var select = new SelectProvider <AttributeModel>(null, null)
.Distinct().Top(10).Fields("ID,IntProperty").Where("ID>20").OrderBy("ID").Desc();
var actual = select.GetSQL();
var expected = @"SELECT DISTINCT TOP10 ID,IntField AS IntProperty FROM TestModel WHERE ID>20 ORDER BY ID DESC";
Assert.AreEqual(expected, actual);
}
protected override Provider Visit(CompilableProvider cp)
{
var isPagingProvider = cp.Type.In(ProviderType.Take, ProviderType.Skip, ProviderType.Paging);
if (isPagingProvider && !State.IsSkipTakeChain)
{
var visitedProvider = (CompilableProvider)base.Visit(cp);
var requiresRowNumber = (State.Take != null && !takeSupported) || (State.Skip != null && !skipSupported);
// add rownumber column (if needed)
if (requiresRowNumber)
{
// Arrray to avoid access to modified closure
string[] columnName = { String.Format(Strings.RowNumberX, rowNumberCount++) };
while (visitedProvider.Header.Columns.Any(column => column.Name == columnName[0]))
{
columnName[0] = String.Format(Strings.RowNumberX, rowNumberCount++);
}
visitedProvider = new RowNumberProvider(visitedProvider, columnName[0]);
}
if (State.Take != null && State.Skip != null)
{
visitedProvider = new PagingProvider(visitedProvider, State.Skip, State.Take);
}
else if (State.Take != null)
{
visitedProvider = new TakeProvider(visitedProvider, State.Take);
}
else
{
visitedProvider = new SkipProvider(visitedProvider, State.Skip);
}
// add select removing RowNumber column
if (requiresRowNumber)
{
visitedProvider = new SelectProvider(
visitedProvider,
Enumerable.Range(0, visitedProvider.Header.Length - 1).ToArray());
}
return(visitedProvider);
}
if (!isPagingProvider && State.IsSkipTakeChain)
{
using (State.CreateScope())
return(base.Visit(cp));
}
return(base.Visit(cp));
}
/// <inheritdoc/>
protected override SqlProvider VisitSelect(SelectProvider provider)
{
var compiledSource = Compile(provider.Source);
SqlSelect query = ExtractSqlSelect(provider, compiledSource);
var originalColumns = query.Columns.ToList();
query.Columns.Clear();
query.Columns.AddRange(provider.ColumnIndexes.Select(i => originalColumns[i]));
return(CreateProvider(query, provider, compiledSource));
}
public void GetPropertyTest()
{
var test = new SelectProvider <AttributeModel>(null, null);
var actual = test.GetProperty("StringProperty");
if (actual == null)
{
Assert.Fail();
}
Assert.AreEqual("StringProperty", actual.Name);
}
protected override Pair <CompilableProvider, List <int> > OverrideRightApplySource(ApplyProvider applyProvider, CompilableProvider provider, List <int> requestedMapping)
{
var currentMapping = mappings[applyProvider.Right];
if (currentMapping.SequenceEqual(requestedMapping))
{
return(base.OverrideRightApplySource(applyProvider, provider, requestedMapping));
}
var selectProvider = new SelectProvider(provider, requestedMapping.ToArray());
return(new Pair <CompilableProvider, List <int> >(selectProvider, requestedMapping));
}
private void SaveSelectClass(DataSet dataset, string projectFolder, string namespaceName, string projectName)
{
var documents = SelectProvider.CreateDocuments(dataset, namespaceName, projectName);
foreach (var document in documents)
{
var filename = $"{document.Name}Query.vb";
var folder = $"{document.Name}Repository";
var path = $@"{projectFolder}\{folder}\{filename}";
document.Save(path);
}
}
protected override Provider VisitSelect(SelectProvider provider)
{
var source = VisitCompilable(provider.Source);
var newProvider = provider;
predicateCollector.ValidateSelectedColumnIndexes(provider);
calculateProviderCollector.ValidateSelectedColumnIndexes(provider);
if (source != provider.Source)
{
newProvider = new SelectProvider(source, provider.ColumnIndexes);
}
return(newProvider);
}
public void GetKeyWhereTest()
{
var type = typeof(AttributeModel);
var tableInfo = new DbTableInfo(type).SetFields(
new DbFieldInfo("IntProperty", "IntKey").SetPrimaryKey());
var test = new SelectProvider <AttributeModel>(tableInfo, new SqlCache());
var test2 = new SelectProvider <AttributeModel>(null, null);
var actual = test.GetKeyWhere();
var actual2 = test2.GetKeyWhere();
Assert.AreEqual(" WHERE IntKey=@IntProperty", actual);
Assert.AreEqual(" WHERE ID=@ID", actual2);
}
public void ValidateSelectedColumnIndexes(SelectProvider provider)
{
if (owner.State.CalculateProviders.Count > 0)
{
collectorHelper.ValidateNewColumnIndexes(owner.State.CalculateProviders,
provider.Header.Columns,
Strings.ExColumnsUsedByCalculatedColumnExpressionContainingApplyParameterAreRemoved);
}
if (owner.State.CalculateFilters.Count > 0)
{
collectorHelper.ValidateNewColumnIndexes(owner.State.CalculateFilters,
provider.Header.Columns, Strings.ExColumnsUsedByPredicateContainingApplyParameterAreRemoved);
}
}
public IReaderableCommand <TResult> Select <TResult>(Expression <Func <T, TResult> > predicate)
{
var provider = new SelectProvider();
provider.Visit(predicate);
provider.SelectFields.ForEach(t =>
{
_selectField.Append($"{t.Prefix}.{t.ColumnName} as {t.Parameter},");
prefix = t.Prefix;
});
_selectField.Remove(_selectField.Length - 1, 1);
return(new ReaderableCommand <TResult>(Connection, Build().ToString(), SqlParameter, Aop));
}
public void GetTableNameTest()
{
var type = typeof(AttributeModel);
var tableInfo = new DbTableInfo(type, "TestTable");
var test = new SelectProvider <AttributeModel>(tableInfo, new SqlCache());
var test2 = new SelectProvider <AttributeModel>(null, new SqlCache());
var test3 = new SelectProvider <TestModel>(null, new SqlCache());
var actual1 = test.GetTableName();
var actual2 = test2.GetTableName();
var actual3 = test3.GetTableName();
Assert.AreEqual("TestTable", actual1);
Assert.AreEqual("TestModel", actual2);
Assert.AreEqual("TestModel", actual3);
}
public void Where <TResult>(string whereExpression, Expression <Func <TResult> > predicate)
{
_whereCause.Append($" ({whereExpression}) and");
var provider = new SelectProvider();
provider.Visit(predicate);
//var dic = (IDictionary<string, object>)_dynamicModel;
var model = predicate.Compile().Invoke();
var types = model.GetType();
provider.SelectFields.ForEach(t =>
{
var values = types.GetProperty(t.Parameter)?.GetValue(model);
_sqlPamater[t.Parameter] = values;
});
}
/// <inheritdoc/>
protected override SqlProvider VisitSelect(SelectProvider provider)
{
var compiledSource = Compile(provider.Source);
var query = ExtractSqlSelect(provider, compiledSource);
var queryColumns = query.Columns;
var columnIndexes = provider.ColumnIndexes;
var newIndex = 0;
var newColumns = new SqlColumn[columnIndexes.Count];
foreach (var index in columnIndexes)
{
newColumns[newIndex++] = queryColumns[index];
}
queryColumns.Clear();
queryColumns.AddRange(newColumns);
return(CreateProvider(query, provider, compiledSource));
}
public void GetFieldNameTest()
{
var type = typeof(AttributeModel);
var tableInfo = new DbTableInfo(type).SetFields(
new DbFieldInfo("IntProperty", "IntKey"),
new DbFieldInfo("NotField").SetNotDbField());
var property = type.GetProperties().Where(p => p.Name == "IntProperty").FirstOrDefault();
if (property == null)
{
Assert.Fail();
}
var test1 = new SelectProvider <AttributeModel>(tableInfo, null);
var test2 = new SelectProvider <AttributeModel>(null, null);
var actual1 = test1.GetFieldName(property);
var actual2 = test2.GetFieldName(property);
Assert.AreEqual("IntKey", actual1);
Assert.AreEqual("IntField", actual2);
}
protected override Provider VisitSelect(SelectProvider provider)
{
var requiredColumns = mappings[provider];
var remappedColumns = requiredColumns.Select(c => provider.ColumnIndexes[c]).ToList();
mappings[provider.Source] = remappedColumns;
var source = VisitCompilable(provider.Source);
var sourceMap = mappings[provider.Source];
var columns = provider.ColumnIndexes
.Select((i, j) => new Pair <int>(sourceMap.IndexOf(i), j))
.Where(i => i.First >= 0)
.ToList();
mappings[provider] = columns.Select(c => c.Second).ToList();
var indexColumns = columns.Select(c => c.First).ToList();
if (source == provider.Source)
{
return(provider);
}
return(new SelectProvider(source, indexColumns.ToArray()));
}
protected override Provider VisitSelect(SelectProvider provider)
{
var result = provider;
var source = VisitCompilable(provider.Source);
if (source != provider.Source)
{
result = new SelectProvider(source, provider.ColumnIndexes);
}
if (sortOrder.Count > 0)
{
var selectOrdering = new DirectionCollection <int>();
var columnIndexes = result.ColumnIndexes;
foreach (var pair in sortOrder)
{
var columnIndex = columnIndexes.IndexOf(pair.Key);
if (columnIndex < 0)
{
if (selectOrdering.Count > 0)
{
selectOrdering.Clear();
}
break;
}
selectOrdering.Add(columnIndex, pair.Value);
}
sortOrder = selectOrdering;
}
if (sortOrder.Count > 0 &&
provider.Header.Order.Count == 0 &&
!consumerDescriptor.BreaksOrder &&
!consumerDescriptor.PreservesOrder)
{
throw new InvalidOperationException(Strings.ExSelectProviderRemovesColumnsUsedForOrdering);
}
return(result);
}
public void SelectRecordTemplate(string record)
{
SelectProvider.ClickRecordsDropdown(_driver);
CommonOBJs.ClickText(_driver, record);
DataStoreFactory.ScenarioDataStore.Add("record", record);
}
/// <summary> /// Compiles <see cref="SelectProvider"/>. /// </summary> /// <param name="provider">Select provider.</param> protected abstract TResult VisitSelect(SelectProvider provider);
public void EnterProvider(string provider)
{
SelectProvider.TypeProvider(_driver, provider);
SelectProvider.ClickFirstResult(_driver);
DataStoreFactory.ScenarioDataStore.Add("provider", provider);
}
public void CheckNoProviderCheckbox()
{
SelectProvider.CheckNoProvider(_driver);
}
public void ClickCancelOnSelectProvider()
{
SelectProvider.ClickCancel(_driver);
}
public void EnterExplanation(string text)
{
SelectProvider.TypeExplanation(_driver, text);
DataStoreFactory.ScenarioDataStore.Add("text", text);
}
public void SelectPathologyTemplate(string path)
{
SelectProvider.ClickPathologyDropdown(_driver);
CommonOBJs.ClickText(_driver, path);
DataStoreFactory.ScenarioDataStore.Add("path", path);
}
public void SelectImagingTemplate(string image)
{
SelectProvider.ClickImagingDropdown(_driver);
CommonOBJs.ClickText(_driver, image);
DataStoreFactory.ScenarioDataStore.Add("image", image);
}
