private static string GetProjectItemUniqueName(string baseName, IVsTemplate template, IItemContainer parent) { Guard.NotNull(() => baseName, baseName); Guard.NotNull(() => template, template); Guard.NotNull(() => parent, parent); var directoryBase = System.IO.Path.GetDirectoryName(parent.PhysicalPath); var files = Directory.EnumerateFiles(directoryBase); var contentProjectItem = template.TemplateContent.Items.OfType <VSTemplateTemplateContentProjectItem>().FirstOrDefault(); if (contentProjectItem == null) { return(baseName); } var outputExtension = System.IO.Path.GetExtension(contentProjectItem.TargetFileName); var uniqueName = UniqueNameGenerator.EnsureUnique( baseName, newName => !files.Any(file => System.IO.Path.GetFileName(file).Equals( string.Format(CultureInfo.InvariantCulture, @"{0}{1}", System.IO.Path.GetFileNameWithoutExtension(newName), outputExtension), StringComparison.OrdinalIgnoreCase))); return(string.Format( CultureInfo.InvariantCulture, @"{0}{1}", System.IO.Path.GetFileNameWithoutExtension(uniqueName), System.IO.Path.GetExtension(baseName))); }
private static IDbSelectable CreateNewSelectableForWrappingSelect( IDbSelect dbSelect, IDbSelectable selectable, DbReference dbRef, Expression m, IDbObjectFactory dbFactory, UniqueNameGenerator nameGenerator) { if (dbRef == null) { return(selectable); } var oCol = selectable as IDbColumn; if (oCol != null) { return(dbFactory.BuildColumn(dbRef, oCol.GetAliasOrName(), oCol.ValType)); } var oRefCol = selectable as IDbRefColumn; if (oRefCol != null) { return(dbFactory.BuildRefColumn(dbRef, oRefCol.Alias, oRefCol)); } if (selectable is IDbFunc oDbFunc) { if (string.IsNullOrEmpty(oDbFunc.Alias)) { oDbFunc.Alias = nameGenerator.GenerateAlias(dbSelect, oDbFunc.Name, true); } return(dbFactory.BuildColumn(dbRef, oDbFunc.Alias, oDbFunc.ReturnType)); } return(dbFactory.BuildColumn(dbRef, selectable.Alias, typeof(string))); }
public override void Translate( MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator) { var dbSelect = state.ResultStack.Peek() as IDbSelect; if (dbSelect != null) { dbSelect.Selection.IsDistinct = true; } var caller = m.GetCaller(); var entityInfo = caller.NodeType == ExpressionType.MemberAccess ? this._infoProvider.FindEntityInfo(caller.Type) : null; // if the caller of the Distinct function is a Entity // We need to add its primary keys into the query so that the result // of distinct is correct. Otherwise, it will only distinct on join keys if (entityInfo != null) { foreach (var pk in entityInfo.Keys) { var pkColumn = _dbFactory.BuildColumn(dbSelect.GetReturnEntityRef(), pk.DbName, pk.ValType); dbSelect.Selection.Add(pkColumn); } } }
public override void Translate( MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator) { // there may not be a preidcate in any method call IDbObject condition = null; if (m.GetArguments().Any()) { condition = state.ResultStack.Pop(); } var childSelect = (IDbSelect)state.ResultStack.Pop(); var dbSelect = (IDbSelect)state.ResultStack.Peek(); childSelect.Where = condition.ToBinary(_dbFactory); var dbJoin = dbSelect.Joins.Single(j => ReferenceEquals(j.To.Referee, childSelect)); IDbBinary whereClause = null; // ReSharper disable once LoopCanBeConvertedToQuery foreach (var joinKey in dbJoin.Condition.GetOperands().OfType <IDbColumn>().Where(c => ReferenceEquals(c.Ref, dbJoin.To))) { var pkColumn = _dbFactory.BuildColumn(dbJoin.To, joinKey.Name, joinKey.ValType.DotNetType, joinKey.Alias); var binary = _dbFactory.BuildBinary(pkColumn, DbOperator.IsNot, _dbFactory.BuildConstant(null)); whereClause = whereClause.UpdateBinary(binary, _dbFactory); } state.ResultStack.Push(whereClause); }
protected void CreateAggregation( MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator, IDbSelect childSelect, IDbFunc dbFunc) { var dbSelect = (IDbSelect)state.ResultStack.Peek(); if (childSelect == null) { state.ResultStack.Push(dbFunc); return; } var alias = nameGenerator.GenerateAlias(dbSelect, dbFunc.Name, true); dbFunc.Alias = alias; childSelect.Selection.Add(dbFunc); var cRef = dbSelect.Joins.Single(j => ReferenceEquals(j.To.Referee, childSelect)).To; var column = _dbFactory.BuildColumn(cRef, alias, m.Method.ReturnType); var dbDefaultVal = _dbFactory.BuildConstant(Activator.CreateInstance(m.Method.ReturnType)); var dbIsNullFunc = _dbFactory.BuildNullCheckFunc(column, dbDefaultVal); state.ResultStack.Push(dbIsNullFunc); }
public override void Translate( MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator) { var arguments = state.ResultStack.Pop(); var dbSelect = (IDbSelect)state.ResultStack.Pop(); var selections = SqlTranslationHelper.ProcessSelection(arguments, _dbFactory); foreach (var selectable in selections) { SqlTranslationHelper.UpdateJoinType(selectable.Ref); dbSelect.Selection.Add(selectable); } var newSelectRef = _dbFactory.BuildRef(dbSelect); var newSelect = _dbFactory.BuildSelect(newSelectRef); newSelectRef.Alias = nameGenerator.GenerateAlias(dbSelect, TranslationConstants.SubSelectPrefix, true); selections = selections.Concat(dbSelect.Selection.Where(s => s.IsJoinKey)).ToArray(); foreach (var selectable in selections) { var newSelectable = CreateNewSelectableForWrappingSelect(selectable, newSelectRef, _dbFactory); newSelect.Selection.Add(newSelectable); } state.ResultStack.Push(newSelect); }
public static string GetUniqueInstanceName(this IGuidanceManager guidanceManager, string baseName) { Guard.NotNull(() => guidanceManager, guidanceManager); Guard.NotNull(() => baseName, baseName); return(UniqueNameGenerator.EnsureUnique(baseName, newName => !guidanceManager.InstantiatedGuidanceExtensions.Any(ge => ge.InstanceName.Equals(newName, StringComparison.OrdinalIgnoreCase)))); }
public void GenerateFrom_Should_Not_Throw_Exception() { var category = (Category)_domainFactory.CreateCategory("IoC/DI"); #pragma warning disable 168 var uniqueName = UniqueNameGenerator.GenerateFrom(_database.CategoryDataSource, category.Name); #pragma warning restore 168 }
private static string GetUniqueName(ModelElement element, string baseName, IDictionary <string, ModelElement> siblingNames) { Guard.NotNull(() => element, element); Guard.NotNull(() => baseName, baseName); return(UniqueNameGenerator.EnsureUnique(baseName, newName => !siblingNames.ContainsKey(newName), true)); }
protected override string GetSymbolTargetName(AstSymbol symbol) { if (symbol.IsValidFrame) { return(UniqueNameGenerator.GetUniqueName(symbol.Name)); } throw new InvalidOperationException(); }
public override void Translate( MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator) { var dbConstants = (IDbConstant)state.ResultStack.Pop(); var dbExpression = (IDbSelectable)state.ResultStack.Pop(); var dbBinary = _dbFactory.BuildFunc("MyFunc", false, dbExpression, dbConstants); state.ResultStack.Push(dbBinary); }
protected override SyntaxToken CreateMethodName() { // change this to more smarter one. var semanticModel = this.SemanticDocument.SemanticModel; var nameGenerator = new UniqueNameGenerator(semanticModel); var scope = this.CSharpSelectionResult.GetContainingScope(); return(SyntaxFactory.Identifier(nameGenerator.CreateUniqueMethodName(scope, "NewMethod"))); }
static void Main(string[] args) { AgentCommandLineOptions options = CommandLineParser.ParseArgs <AgentCommandLineOptions>(args, new AgentCommandLineOptions()); GameMasterSettings settings = Configuration.FromFile <GameMasterSettings>(options.Conf); GameMasterClient client = new GameMasterClient(new Connection(options.Address, options.Port), settings, new Logger(UniqueNameGenerator.GetUniqueName(settings.GameDefinition.GameName)), new Game(), new Ranking()); client.Connect(); client.Disconnect(); }
public void Generate_Should_Return_Correct_UniqueName_When_DataSource_Is_Empty() { var database = new Mock <IDatabase>(); database.SetupGet(d => d.CategoryDataSource).Returns(new List <Category>().AsQueryable()); string uniqueName = UniqueNameGenerator.GenerateFrom(database.Object.CategoryDataSource, "C"); Assert.Equal("C", uniqueName); }
public SagaBuilderState(Type currentEvent, string currentState, ISagaModel model, IServiceProvider serviceProvider, UniqueNameGenerator uniqueNameGenerator, ISagaStep parentStep) { CurrentEvent = currentEvent; CurrentState = currentState; Model = model; ServiceProvider = serviceProvider; UniqueNameGenerator = uniqueNameGenerator; ParentStep = parentStep; }
private static string GetAbbreviationForWellKnownModules(IDocumentAnalysis analysis, string fullyQualifiedName) { if (WellKnownAbbreviationMap.TryGetValue(fullyQualifiedName, out var abbreviation)) { // for now, use module wide unique name for abbreviation. even though technically we could use // context based unique name since variable declared in lower scope will hide it and there is no conflict return(UniqueNameGenerator.Generate(analysis, abbreviation)); } return(null); }
protected override SyntaxToken CreateMethodName() { var methodName = "NewMethod"; var containingScope = this.CSharpSelectionResult.GetContainingScope(); methodName = GetMethodNameBasedOnExpression(methodName, containingScope); var semanticModel = this.SemanticDocument.SemanticModel; var nameGenerator = new UniqueNameGenerator(semanticModel); return(SyntaxFactory.Identifier(nameGenerator.CreateUniqueMethodName(containingScope, methodName))); }
CompletionItem CreateNewMethodCreationItem(SyntaxNode parent, SemanticModel semanticModel, ITypeSymbol delegateType, int position, string optDelegateName, IMethodSymbol delegateMethod, CancellationToken cancellationToken) { var sb = new StringBuilder(); string varName = optDelegateName ?? "Handle" + delegateType.Name; var curType = semanticModel.GetEnclosingSymbol <INamedTypeSymbol> (position, cancellationToken); var uniqueName = new UniqueNameGenerator(semanticModel).CreateUniqueMethodName(parent, varName); var pDict = ImmutableDictionary <string, string> .Empty; pDict = pDict.Add("RightSideMarkup", "<span size='small'>" + GettextCatalog.GetString("Creates new method") + "</span>"); var indent = "\t"; sb = new StringBuilder(); var enclosingSymbol = semanticModel.GetEnclosingSymbol(position, default(CancellationToken)); if (enclosingSymbol != null && enclosingSymbol.IsStatic) { sb.Append("static "); } sb.Append("void "); int pos2 = sb.Length; sb.Append(uniqueName); sb.Append(' '); sb.Append("("); for (int k = 0; k < delegateMethod.Parameters.Length; k++) { if (k > 0) { sb.Append(", "); } sb.Append(CSharpAmbience.SafeMinimalDisplayString(delegateMethod.Parameters [k], semanticModel, position, MonoDevelop.Ide.TypeSystem.Ambience.LabelFormat)); } sb.Append(")"); sb.Append(eolMarker); sb.Append(indent); sb.Append("{"); sb.Append(eolMarker); sb.Append(indent); sb.Append(oneIndentMarker); //int cursorPos = pos + sb.Length; sb.Append(indent); sb.Append("}"); sb.Append(eolMarker); pDict = pDict.Add("Position", position.ToString()); pDict = pDict.Add("NewMethod", sb.ToString()); pDict = pDict.Add("MethodName", varName); return(CompletionItem.Create(uniqueName, properties: pDict, tags: newMethodTags, rules: NewMethodRules)); }
private string GetProjectUniqueName(string baseName) { Guard.NotNull(() => baseName, baseName); var directoryBase = System.IO.Path.GetDirectoryName(this.solution.PhysicalPath); IEnumerable <string> subDirectoriesNames = Directory.EnumerateDirectories(directoryBase).Select(dir => System.IO.Path.GetFileName(dir)); var uniqueName = UniqueNameGenerator.EnsureUnique( baseName, newName => !subDirectoriesNames.Any(dir => dir.Equals(newName, StringComparison.OrdinalIgnoreCase))); return(uniqueName); }
/// <summary> Translate to SQL </summary> public override void Translate( MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator) { var dbExpression = GetAggregationTarget(m, state); IDbSelect childSelect = null; if (!m.GetCaller().Type.IsGrouping()) { childSelect = state.ResultStack.Pop() as IDbSelect; } // if the aggregation does not have expression, it means // the caller of the aggregation method must be a Select method call // In this case, the actual expression that we need to aggregate on, // will be inside the child select statement if (dbExpression == null && childSelect != null) { // to get the actual expression, we need to first unwrap the child select // because the translation of Select call always wrap the actual select childSelect = (IDbSelect)childSelect.From.Referee; dbExpression = childSelect.Selection.Last( s => string.IsNullOrEmpty(s.Alias) || !s.Alias.EndsWith(TranslationConstants.JoinKeySuffix)); childSelect.Selection.Remove(dbExpression); childSelect.GroupBys.Remove(dbExpression); } if (dbExpression == null) { throw new NotSupportedException("Can not aggregate."); } if (!(dbExpression is IDistinctable)) { throw new NotSupportedException("Expression must be Distinctable"); } var distinctable = (IDistinctable)dbExpression; distinctable.IsDistinct = true; var dbFunc = _dbFactory.BuildFunc("count", true, m.Method.ReturnType, dbExpression); CreateAggregation(m, state, nameGenerator, childSelect, dbFunc); }
public override void Translate( MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator) { var predicate = BuildCondition(m, state); IDbSelect childSelect = null; if (!m.GetCaller().Type.IsGrouping()) { childSelect = state.ResultStack.Pop() as IDbSelect; } var dbCountFunc = _dbFactory.BuildFunc(m.Method.Name.ToLower(), true, m.Method.ReturnType, predicate); CreateAggregation(m, state, nameGenerator, childSelect, dbCountFunc); }
public override void Translate( MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator) { // group by can be a column, a expression, or a list of columns / expressions var arguments = state.ResultStack.Pop(); var dbSelect = (IDbSelect)state.ResultStack.Pop(); var groupBys = dbSelect.GroupBys; groupBys.IsSingleKey = !(arguments is IDbList <DbKeyValue>); var selections = SqlTranslationHelper.ProcessSelection(arguments, _dbFactory); foreach (var selectable in selections) { SqlTranslationHelper.UpdateJoinType(selectable.Ref); var refCol = selectable as IDbRefColumn; // if we group on a ref column, we are actaully group by on the primary key // of the entity that ref column referring to. In the refering entity is actually // another ref column, then we will need to get the primay key recursive from RefTo if (refCol?.RefTo != null) { foreach (var pk in refCol.GetPrimaryKeys()) { refCol.RefTo.AddToReferedSelect(_dbFactory, pk.Name, pk.ValType); } } dbSelect.GroupBys.Add(selectable); } // if the group by is a single expression like groupby(x => x.Children.Count()) // it will be translated into a expression and will not have alias // in this case, we will need to give it an alias which will be used later if (groupBys.IsSingleKey) { var column = groupBys.Single(); if (column.Alias == null) { column.Alias = "Key"; } } state.ResultStack.Push(dbSelect); }
public static async Task StartAsync(Brain brain, string name, IDeviceBuilder[] devices, IPAddress ipAddress, int port, CancellationToken cancellationToken) { if (Server._host != null) { throw new InvalidOperationException("Host is already running - it must be stopped to start a new host."); } if (brain == null) { throw new ArgumentNullException(nameof(brain)); } if (string.IsNullOrEmpty(name)) { throw new ArgumentException("Non-blank name is required.", nameof(name)); } if (devices == null || devices.Length == 0 || Array.IndexOf(devices, default) != -1) { throw new ArgumentException("Devices collection can not be null/empty or contain null.", nameof(devices)); } if (port < 0 || port > ushort.MaxValue) { throw new ArgumentException("Invalid port.", nameof(port)); } string adapterName = $"src-{UniqueNameGenerator.Generate(name)}"; IHost host = Server.CreateHostBuilder(brain, adapterName, devices, ipAddress, port).Build(); await host.StartAsync(cancellationToken).ConfigureAwait(false); Server._host = host; ILogger <Brain> logger = host.Services.GetRequiredService <ILogger <Brain> >(); string baseUrl = $"http://{ipAddress}:{port}"; for (int i = 0; i < Constants.MaxConnectionRetries; i++) { try { await brain.PostAsync("registerSdkDeviceAdapter", new { Name = adapterName, BaseUrl = baseUrl }, cancellationToken).ConfigureAwait(false); logger.LogInformation("SDK Adapter registered on brain @ http://{host}:{port}", brain.HostName, brain.Port); return; } catch { logger.LogWarning("Failed to register with brain {times} time(s).", i + 1); } } throw new ApplicationException("Failed to connect to brain."); }
public void Generate_Should_Return_Correct_UniqueName_When_Second_Name_Starts_With_First_Entity_Name() { var categoryList = new List <Category>(); var database = new Mock <IDatabase>(); database.SetupGet(d => d.CategoryDataSource).Returns(categoryList.AsQueryable()); var category1 = (Category)_factory.CreateCategory("IoC-DI"); category1.UniqueName = UniqueNameGenerator.GenerateFrom(database.Object.CategoryDataSource, category1.Name); categoryList.Add(category1); Thread.Sleep(500); string uniqueName = UniqueNameGenerator.GenerateFrom(database.Object.CategoryDataSource, "IoC"); Assert.Equal("IoC", uniqueName); }
public void Generate_Should_Return_Correct_UniqueName_When_DataSource_Contains_One_Item() { var categoryList = new List <Category>(); var database = new Mock <IDatabase>(); database.SetupGet(d => d.CategoryDataSource).Returns(categoryList.AsQueryable()); var category = (Category)_factory.CreateCategory("C"); category.UniqueName = UniqueNameGenerator.GenerateFrom(database.Object.CategoryDataSource, category.Name); categoryList.Add(category); Thread.Sleep(500); string uniqueName = UniqueNameGenerator.GenerateFrom(database.Object.CategoryDataSource, "C++"); Assert.Equal("C-2", uniqueName); }
protected void CreateAggregation( MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator, IDbSelect childSelect, IDbFunc dbFunc) { var dbSelect = (IDbSelect)state.ResultStack.Peek(); if (childSelect == null) { state.ResultStack.Push(dbFunc); return; } var alias = nameGenerator.GenerateAlias(dbSelect, dbFunc.Name, true); dbFunc.Alias = alias; childSelect.Selection.Add(dbFunc); /** * Aggregation can happen after a method that generate new select. * In this case, join from the main select to the child select will not be * updated yet at this stage, so we need to correct the join to on the * correct child select statment. * For example: * var query = db.Blogs * .Where(b => b.BlogId > 0) * .Select(b => new * { * b.BlogId, * Cnt = b.Posts.Select(p => p.Title).Distinct().Count() * }); * `b.Posts.Select(p => p.Title).Distinct()` will create a new child select and * it will not be the one that the main select is currently targeting, so we * need to correct the join target. */ ReLinkToChildSelect(dbSelect, childSelect); var cRef = dbSelect.Joins.Single(j => ReferenceEquals(j.To.Referee, childSelect)).To; var column = _dbFactory.BuildColumn(cRef, alias, m.Method.ReturnType); var dbDefaultVal = _dbFactory.BuildConstant(Activator.CreateInstance(m.Method.ReturnType)); var dbIsNullFunc = _dbFactory.BuildNullCheckFunc(m.Method.ReturnType, column, dbDefaultVal); state.ResultStack.Push(dbIsNullFunc); }
/// <summary> /// Creates and opens a new blank solution /// </summary> internal static void CreateBlankSolution(this EnvDTE.DTE dte, IRegistryReader reader) { Guard.NotNull(() => dte, dte); //Close existing solution if (dte.Solution.IsOpen) { dte.Solution.Close(true); } // Determine next available solution directory var defaultSaveLocation = GetDefaultProjectSaveLocation(reader); if (string.IsNullOrEmpty(defaultSaveLocation)) { throw new InvalidOperationException(Resources.DteExtensions_CreateNewSolution_FailedDirSearch); } var existingSolutionFolders = Directory.GetDirectories(defaultSaveLocation).Select(dir => new DirectoryInfo(dir).Name); var nextSolutionDir = UniqueNameGenerator.EnsureUnique(NewSolutionNamePrefix, existingSolutionFolders, true); // Create solution directory var solutionDir = Path.Combine(defaultSaveLocation, nextSolutionDir); if (!Directory.Exists(solutionDir)) { Directory.CreateDirectory(solutionDir); } // Save and Open new solution var solutionFullPath = Path.Combine(solutionDir, nextSolutionDir); try { dte.Solution.Create(solutionDir, nextSolutionDir); dte.Solution.SaveAs(solutionFullPath); } catch (COMException) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.DteExtensions_CreateNewSolution_FailedCreate, solutionDir)); } }
public override void Translate( MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator) { var joinType = (IDbConstant)state.ResultStack.Pop(); var selection = state.ResultStack.Pop(); var joinCondition = (IDbBinary)state.ResultStack.Pop(); var toSelect = (IDbSelect)state.ResultStack.Pop(); var fromSelect = (IDbSelect)state.ResultStack.Pop(); var toSelectRef = _dbFactory.BuildRef(toSelect, nameGenerator.GenerateAlias(fromSelect, "sq", true)); // todo: review how join condition is translated // create result selection for final select UpdateSelection(fromSelect, selection, toSelectRef); // create join to inner select var joinKeys = joinCondition.GetOperands().OfType <IDbColumn>().Where(c => c.Ref.OwnerSelect == toSelect); foreach (var joinKey in joinKeys) { toSelect.Selection.Remove(joinKey); var alias = nameGenerator.GenerateAlias(toSelect, joinKey.Name + "_jk", true); var innerCol = _dbFactory.BuildColumn(joinKey); innerCol.Alias = alias; toSelect.Selection.Add(innerCol); joinKey.Ref = toSelectRef; joinKey.Name = alias; joinKey.Alias = string.Empty; } var dbJoin = _dbFactory.BuildJoin(toSelectRef, fromSelect, joinCondition, (DbJoinType)joinType.Val); fromSelect.Joins.Add(dbJoin); var finalSelectRef = _dbFactory.BuildRef(fromSelect, nameGenerator.GenerateAlias(null, "sq", true)); var finalSelect = _dbFactory.BuildSelect(finalSelectRef); state.ResultStack.Push(finalSelect); }
public static string CalculateNextUniqueChildItemName <T>(this IItemContainer parent, string childNameSeed) where T : IItemContainer { Guard.NotNull(() => parent, parent); Guard.NotNull(() => childNameSeed, childNameSeed); if ((typeof(T).IsAssignableFrom(typeof(ISolution))) || ((parent is IProject || parent is IItem || parent is IFolder) && typeof(T).IsAssignableFrom(typeof(ISolutionFolder))) || ((parent is IFolder || parent is IItem) && typeof(T).IsAssignableFrom(typeof(IProject))) || ((parent is ISolution || parent is ISolutionFolder || parent is IItem) && typeof(T).IsAssignableFrom(typeof(IFolder)))) { throw new InvalidOperationException(); } var extension = Path.GetExtension(childNameSeed); var seed = Path.GetFileNameWithoutExtension(childNameSeed); return(String.Format(CultureInfo.CurrentCulture, @"{0}{1}", UniqueNameGenerator.EnsureUnique(seed, newName => parent.Items.Where(item => String.IsNullOrEmpty(extension) ? item.Name.Equals(newName, StringComparison.OrdinalIgnoreCase) : item.Name.Equals(Path.ChangeExtension(newName, extension), StringComparison.OrdinalIgnoreCase)).FirstOrDefault() == null), extension)); }
public override void Translate( MethodCallExpression m, TranslationState state, UniqueNameGenerator nameGenerator) { var vals = new List <object>(); while (state.ResultStack.Peek() is IDbConstant) { var dbConstants = (IDbConstant)state.ResultStack.Pop(); if (dbConstants.Val is IEnumerable val) { vals = val.Cast <object>().ToList(); break; } vals.Insert(0, dbConstants.Val); } var dbExpression = (IDbSelectable)state.ResultStack.Pop(); var dbBinary = vals.Count == 0 ? _dbFactory.BuildBinary(_dbFactory.BuildConstant(0), DbOperator.Equal, _dbFactory.BuildConstant(1)) : _dbFactory.BuildBinary(dbExpression, DbOperator.In, _dbFactory.BuildConstant(vals, true)); state.ResultStack.Push(dbBinary); }
/// <summary> /// Generate names for the provided <see cref="Schema"/> /// </summary> public static void GenerateAllNames(Schema schema) { IDatabaseNameGenerator nameGenerator = new DefaultDatabaseNameGenerator(schema.Store); UniqueNameGenerator uniqueChecker = new UniqueNameGenerator(); LinkedElementCollection<Table> tables = schema.TableCollection; // Generate table names uniqueChecker.GenerateUniqueElementNames( tables, delegate(object element, int phase) { return nameGenerator.GenerateTableName((Table)element, phase); }, delegate(object element, string elementName) { ((Table)element).Name = elementName; }); foreach (Table table in tables) { //column names uniqueChecker.GenerateUniqueElementNames( table.ColumnCollection, delegate(object element, int phase) { return nameGenerator.GenerateColumnName((Column)element, phase); }, delegate(object element, string elementName) { ((Column)element).Name = elementName; }); } // Constraint names, unique across the schema uniqueChecker.GenerateUniqueElementNames( IterateConstraints(schema), delegate(object element, int phase) { return nameGenerator.GenerateConstraintName((Constraint)element, phase); }, delegate(object element, string elementName) { ((Constraint)element).Name = elementName; }); }