public TextReader SerializeText(object instance, DocumentMap map) { if (!map.ExpectLargeDocuments) { // Serializing directly to a string is faster for small documents var text = JsonConvert.SerializeObject(instance, SerializerSettings); if (text.Length > NevermoreDefaults.LargeDocumentCutoffSize) { map.ExpectLargeDocuments = true; } return(new StringReader(text)); } // The MemoryStream is not disposed/not in a using intentionally, since it will be sent to a DbParameter. // CommandExecutor disposes all parameters at the end of the execution. var memoryStream = MemoryStreamManager.GetStream("JsonNetSerializer:SerializeText:" + map.Type.Name); using (var writer = new StreamWriter(memoryStream, Encoding.UTF8, 2048, true)) { var serializer = JsonSerializer.Create(SerializerSettings); using var jsonTextWriter = new JsonTextWriter(writer); jsonTextWriter.ArrayPool = arrayPoolAdapter; serializer.Serialize(jsonTextWriter, instance); } memoryStream.Seek(0, SeekOrigin.Begin); return(new StreamReader(memoryStream, Encoding.UTF8)); }
private async Task ProcessProjectAsync( Project project, DocumentMap documentMap) { using (Logger.LogBlock(FunctionId.FindReference_ProcessProjectAsync, project.Name, _cancellationToken)) { // make sure we hold onto compilation while we search documents belong to this project var compilation = await project.GetCompilationAsync(_cancellationToken).ConfigureAwait(false); var documentTasks = new List<Task>(); foreach (var kvp in documentMap) { var document = kvp.Key; if (document.Project == project) { var documentQueue = kvp.Value; documentTasks.Add(Task.Run(() => ProcessDocumentQueueAsync( document, documentQueue), _cancellationToken)); } } await Task.WhenAll(documentTasks).ConfigureAwait(false); GC.KeepAlive(compilation); } }
// Builds a mapping of FileName -> (DocumentId, Requests[]) // This grouping is later used to process each document at a time. static DocumentMap BuildDiffDocumentMap(IEnumerable <DiffRequest> requests) { var documentIdMap = new DocumentMap(); foreach (var request in requests) { if (!(request.filename.EndsWith(".cs") || request.filename.EndsWith(".vb"))) { Console.WriteLine($"WARNING: {request.filename} is not a .cs or .vb file. Skipping"); continue; } if (documentIdMap.ContainsKey(request.filename)) { documentIdMap[request.filename].Add(request); } else { documentIdMap.Add(request.filename, new List <DiffRequest>() { request }); } } return(documentIdMap); }
public async Task BeforeDeleteAsync <TDocument>(object id, DocumentMap map, IWriteTransaction transaction) where TDocument : class { foreach (var hook in hooks) { await hook.BeforeDeleteAsync <TDocument>(id, map, transaction); } }
public DocumentReaderExpressionBuilder(DocumentMap map, ITypeHandlerRegistry typeHandlers) { type = map.Type; this.map = map; this.typeHandlers = typeHandlers; var contextType = typeof(DocumentReaderContext); dataReaderArgument = Expression.Parameter(typeof(DbDataReader), "reader"); contextArgument = Expression.Parameter(contextType, "context"); result = DeclareLocal(map.Type, "result"); deserializeAsLocal = DeclareLocal(typeof(Type), "deserializeAsType"); columnField = contextType.GetField(nameof(DocumentReaderContext.Column)); deserializeTextMethod = contextType.GetMethod(nameof(DocumentReaderContext.DeserializeText), BindingFlags)?.MakeGenericMethod(type); deserializeCompressedMethod = contextType.GetMethod(nameof(DocumentReaderContext.DeserializeCompressed), BindingFlags)?.MakeGenericMethod(type); resolveTypeMethod = contextType.GetMethod(nameof(DocumentReaderContext.ResolveType), BindingFlags); selectPreferredResultMethod = contextType.GetMethod(nameof(DocumentReaderContext.SelectPreferredResult), BindingFlags)?.MakeGenericMethod(type); propertyHandlerWriteMethod = typeof(IPropertyHandler).GetMethod(nameof(IPropertyHandler.Write), BindingFlags); if (columnField == null || deserializeTextMethod == null || deserializeCompressedMethod == null || resolveTypeMethod == null || selectPreferredResultMethod == null || propertyHandlerWriteMethod == null) { throw new InvalidOperationException("Could not find one or more required methods."); } }
public static void WriteTableSchema(DocumentMap mapping, string tableNameOverride, StringBuilder result) { var tableName = tableNameOverride ?? mapping.TableName; result.AppendLine("CREATE TABLE [TestSchema].[" + tableName + "] ("); result.Append($" [Id] {GetDatabaseType(mapping.IdColumn)} NOT NULL CONSTRAINT [PK_{tableName}_Id] PRIMARY KEY CLUSTERED, ").AppendLine(); foreach (var column in mapping.WritableIndexedColumns()) { result.AppendFormat(" [{0}] {1} {2}, ", column.ColumnName, GetDatabaseType(column).ToUpperInvariant(), IsNullable(column) ? "NULL" : "NOT NULL").AppendLine(); } result.AppendFormat(" [JSON] NVARCHAR(MAX) NOT NULL").AppendLine(); result.AppendLine(")"); foreach (var unique in mapping.UniqueConstraints) { result.AppendFormat("ALTER TABLE [TestSchema].[{0}] ADD CONSTRAINT [UQ_{1}] UNIQUE({2})", tableName, unique.ConstraintName, string.Join(", ", unique.Columns.Select(ix => "[" + ix + "]"))).AppendLine(); } foreach (var referencedDocumentMap in mapping.RelatedDocumentsMappings) { var refTblName = referencedDocumentMap.TableName; var refSchemaName = referencedDocumentMap.SchemaName; result.AppendLine($"IF NOT EXISTS (SELECT name from sys.tables WHERE name = '{refTblName}')"); result.AppendLine($" CREATE TABLE TestSchema.[{refTblName}] ("); result.AppendLine($" [{referencedDocumentMap.IdColumnName}] nvarchar(50) NOT NULL,"); result.AppendLine($" [{referencedDocumentMap.IdTableColumnName}] nvarchar(50) NOT NULL,"); result.AppendLine($" [{referencedDocumentMap.RelatedDocumentIdColumnName}] nvarchar(50) NOT NULL,"); result.AppendLine($" [{referencedDocumentMap.RelatedDocumentTableColumnName}] nvarchar(50) NOT NULL "); result.AppendLine(" )"); } }
private async Task ProcessProjectAsync( Project project, DocumentMap documentMap) { using (Logger.LogBlock(FunctionId.FindReference_ProcessProjectAsync, project.Name, _cancellationToken)) { if (project.SupportsCompilation) { // make sure we hold onto compilation while we search documents belong to this project var compilation = await project.GetCompilationAsync(_cancellationToken).ConfigureAwait(false); var documentTasks = new List <Task>(); foreach (var(document, documentQueue) in documentMap) { if (document.Project == project) { documentTasks.Add(Task.Factory.StartNew(() => ProcessDocumentQueueAsync(document, documentQueue), _cancellationToken, TaskCreationOptions.None, _scheduler).Unwrap()); } } await Task.WhenAll(documentTasks).ConfigureAwait(false); GC.KeepAlive(compilation); } } }
public async Task AfterUpdateAsync <TDocument>(TDocument document, DocumentMap map, IWriteTransaction transaction) where TDocument : class { foreach (var hook in hooks) { await hook.AfterUpdateAsync(document, map, transaction); } }
public PreparedCommand PrepareDelete(DocumentMap mapping, Where where, CommandParameterValues parameters, DeleteOptions options = null) { options ??= DeleteOptions.Default; var actualTableName = options.TableName ?? mapping.TableName; var actualSchemaName = options.SchemaName ?? configuration.GetSchemaNameOrDefault(mapping); if (!mapping.RelatedDocumentsMappings.Any()) { return(new PreparedCommand($"DELETE FROM [{actualSchemaName}].[{actualTableName}]{options.Hint??""} {where.GenerateSql()}", parameters, RetriableOperation.Delete, mapping, options.CommandTimeout)); } var statement = new StringBuilder(); statement.AppendLine("DECLARE @Ids as TABLE (Id nvarchar(400))"); statement.AppendLine(); statement.AppendLine("INSERT INTO @Ids"); statement.AppendLine($"SELECT [{mapping.IdColumn.ColumnName}]"); statement.AppendLine($"FROM [{actualSchemaName}].[{actualTableName}] WITH (ROWLOCK)"); statement.AppendLine(where.GenerateSql()); statement.AppendLine(); statement.AppendLine($"DELETE FROM [{actualSchemaName}].[{actualTableName}] WITH (ROWLOCK) WHERE [{mapping.IdColumn.ColumnName}] in (SELECT Id FROM @Ids)"); foreach (var relMap in mapping.RelatedDocumentsMappings.Select(m => (tableName: m.TableName, schema: configuration.GetSchemaNameOrDefault(m), idColumnName: m.IdColumnName)).Distinct()) { statement.AppendLine($"DELETE FROM [{relMap.schema}].[{relMap.tableName}] WITH (ROWLOCK) WHERE [{relMap.idColumnName}] in (SELECT Id FROM @Ids)"); } return(new PreparedCommand(statement.ToString(), parameters, RetriableOperation.Delete, mapping, options.CommandTimeout)); }
void AppendRelatedDocumentStatementsForInsert( StringBuilder sb, CommandParameterValues parameters, DocumentMap mapping, IReadOnlyList <object> documents) { var relatedDocumentData = GetRelatedDocumentTableData(mapping, documents); foreach (var data in relatedDocumentData.Where(g => g.Related.Length > 0)) { var relatedVariablePrefix = $"{data.TableName.ToLower()}_"; sb.AppendLine($"INSERT INTO [{data.SchemaName}].[{data.TableName}] ([{data.IdColumnName}], [{data.IdTableColumnName}], [{data.RelatedDocumentIdColumnName}], [{data.RelatedDocumentTableColumnName}]) VALUES"); var related = data.Related; for (var x = 0; x < related.Length; x++) { var parentIdVariable = related[x].parentIdVariable; var relatedDocumentId = related[x].relatedDocumentId; var relatedTableName = related[x].relatedTableName; var relatedVariableName = relatedVariablePrefix + x; parameters.Add(relatedVariableName, relatedDocumentId); if (x > 0) { sb.Append(","); } sb.AppendLine($"(@{parentIdVariable}, '{mapping.TableName}', @{relatedVariableName}, '{relatedTableName}')"); } } }
public void AfterDelete <TDocument>(string id, DocumentMap map, IWriteTransaction transaction) where TDocument : class { foreach (var hook in hooks) { hook.AfterDelete <TDocument>(id, map, transaction); } }
private static void HandleDocumentMap(DocumentMap documentMap, PDFLabel currentLabel, int currentLevel) { while (documentMap.MoveNext()) { DocumentMapNode current = documentMap.Current; PDFLabel pDFLabel = new PDFLabel(current.Id, current.Label); if (current.Level > currentLevel) { if (currentLabel.Children == null) { currentLabel.Children = new List <PDFLabel>(); } currentLabel.Children.Add(pDFLabel); pDFLabel.Parent = currentLabel; currentLevel++; } else if (current.Level == currentLevel) { currentLabel.Parent.Children.Add(pDFLabel); pDFLabel.Parent = currentLabel.Parent; } else { for (int num = currentLevel - current.Level; num >= 0; num--) { currentLabel = currentLabel.Parent; } currentLabel.Children.Add(pDFLabel); pDFLabel.Parent = currentLabel; currentLevel = current.Level; } currentLabel = pDFLabel; } }
public void BeforeInsert <TDocument>(TDocument document, DocumentMap map, IWriteTransaction transaction) where TDocument : class { foreach (var hook in hooks) { hook.BeforeInsert(document, map, transaction); } }
public void AfterUpdate <TDocument>(TDocument document, DocumentMap map, IWriteTransaction transaction) where TDocument : class { foreach (var hook in hooks) { hook.AfterUpdate(document, map, transaction); } }
public async Task AfterDeleteAsync <TDocument>(string id, DocumentMap map, IWriteTransaction transaction) where TDocument : class { foreach (var hook in hooks) { await hook.AfterDeleteAsync <TDocument>(id, map, transaction); } }
private void InitializeComponent() { this.DocMap = new FastColoredTextBoxNS.DocumentMap(); ((System.ComponentModel.ISupportInitialize)(this)).BeginInit(); this.SuspendLayout(); // // DocMap // this.DocMap.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(64)))), ((int)(((byte)(64)))), ((int)(((byte)(64))))); this.DocMap.ForeColor = System.Drawing.Color.Black; this.DocMap.Location = new System.Drawing.Point(259, 74); this.DocMap.Name = "DocMap"; this.DocMap.Scale = 0.25F; this.DocMap.ScrollbarVisible = false; this.DocMap.Size = new System.Drawing.Size(71, 137); this.DocMap.TabIndex = 6; this.DocMap.Target = this; this.DocMap.Text = "documentMap1"; // // luatextbox // this.AutoScrollMinSize = new System.Drawing.Size(27, 14); this.BackColor = System.Drawing.SystemColors.Control; this.Controls.Add(this.DocMap); this.LeftBracket = '('; this.LeftBracket2 = '{'; this.Name = "luatextbox"; this.RightBracket = ')'; this.RightBracket2 = '}'; this.ShowFoldingLines = true; this.Size = new System.Drawing.Size(330, 211); ((System.ComponentModel.ISupportInitialize)(this)).EndInit(); this.ResumeLayout(false); }
/// <summary> /// Initialises a new instance of the DocumentMapXmlRenderer. /// </summary> /// <param name="documentMap">The <paramref name="documentMap"/> to render.</param> /// <param name="includeSafeName">Indicates if the safename attribute should be rendered</param> public DocumentMapXmlRenderer( DocumentMap documentMap, bool includeSafeName) { _documentMap = documentMap; _includeSafeName = includeSafeName; }
void InstallSchema() { Console.WriteLine("Performing migration"); var migrator = new DatabaseMigrator(); migrator.Migrate(Store); var output = new StringBuilder(); SchemaGenerator.WriteTableSchema(new CustomerMap(), null, output); var mappings = new DocumentMap[] { new CustomerMap(), new ProductMap(), new LineItemMap() }; Mappings.Install(mappings); using (var transaction = Store.BeginTransaction(IsolationLevel.ReadCommitted)) { output.Clear(); foreach (var map in mappings) { SchemaGenerator.WriteTableSchema(map, null, output); } transaction.ExecuteScalar <int>(output.ToString()); transaction.Commit(); } }
public ProjectData(ProjectId projectId, ImmutableArray <MonoDevelopMetadataReference> metadataReferences, MonoDevelopWorkspace ws) { this.projectId = projectId; workspaceRef = new WeakReference <MonoDevelopWorkspace> (ws); DocumentData = new DocumentMap(projectId); this.metadataReferences = new List <MonoDevelopMetadataReference> (metadataReferences); }
public void GenerateMap_WhenAssemblyHasTypesWithoutNamespace_TypesAreContainedInNoneNamespaceContainer() { const string TypeName = "Issue45_TypeWithNoNamespace"; const string NoneNamespaceName = "NoneNamespaces"; List <DocumentedAssembly> assemblies = new List <DocumentedAssembly>(); DocumentedAssembly documentedAssembly = new DocumentedAssembly { FileName = DocumentationFile }; EntryCreator creator = new EntryCreator(); assemblies.Add(documentedAssembly); GroupedNamespaceDocumentMapper mapper = new GroupedNamespaceDocumentMapper(assemblies, false, creator); DocumentMap result = mapper.GenerateMap(); AssemblyDef assembly = documentedAssembly.LoadedAssembly; TypeDef type = assembly.FindType(string.Empty, TypeName); Entry entry = result.FindById(type.GetGloballyUniqueId()); Assert.AreSame(type, entry.Item); // the type has been mapped Assert.AreEqual(NoneNamespaceName, entry.Parent.Parent.SubKey); // is part of the nonenamespace container }
CommandParameterValues InstanceToParameters(object instance, DocumentMap mapping, string prefix = null) { var result = new CommandParameterValues { [$"{prefix}Id"] = mapping.IdColumn.ReaderWriter.Read(instance) }; var mType = mapping.InstanceTypeResolver.GetTypeFromInstance(instance); result[$"{prefix}JSON"] = JsonConvert.SerializeObject(instance, mType, jsonSerializerSettings); foreach (var c in mappings.Get(mType).IndexedColumns) { var value = c.ReaderWriter.Read(instance); if (value != null && value != DBNull.Value && value is string && c.MaxLength > 0) { var attemptedLength = ((string)value).Length; if (attemptedLength > c.MaxLength) { throw new StringTooLongException(string.Format("An attempt was made to store {0} characters in the {1}.{2} column, which only allows {3} characters.", attemptedLength, mapping.TableName, c.ColumnName, c.MaxLength)); } } else if (value != null && value != DBNull.Value && value is DateTime && value.Equals(DateTime.MinValue)) { value = SqlDateTime.MinValue.Value; } result[$"{prefix}{c.ColumnName}"] = value; } return(result); }
private async Task ProcessDocumentQueueAsync( Document document, DocumentMap.ValueSet documentQueue) { await _progress.OnFindInDocumentStartedAsync(document).ConfigureAwait(false); SemanticModel model = null; try { model = await document.GetSemanticModelAsync(_cancellationToken).ConfigureAwait(false); // start cache for this semantic model FindReferenceCache.Start(model); foreach (var symbolAndFinder in documentQueue) { var symbol = symbolAndFinder.symbolAndProjectId; var finder = symbolAndFinder.finder; await ProcessDocumentAsync(document, symbol, finder).ConfigureAwait(false); } } finally { FindReferenceCache.Stop(model); await _progress.OnFindInDocumentCompletedAsync(document).ConfigureAwait(false); } }
public void DeleteInternal(DocumentMap mapping, string id, int?commandTimeoutSeconds) { var statement = $"DELETE from dbo.[{mapping.TableName}] WHERE Id = @Id"; using (new TimedSection(Log, ms => $"Delete took {ms}ms in transaction '{name}': {statement}", 300)) using (var command = sqlCommandFactory.CreateCommand(connection, transaction, statement, new CommandParameterValues { { "Id", id } }, mapping, commandTimeoutSeconds)) { AddCommandTrace(command.CommandText); try { // We can retry deletes because deleting something that doesn't exist will silently do nothing command.ExecuteNonQueryWithRetry(GetRetryPolicy(RetriableOperation.Delete), "Delete " + mapping.TableName); } catch (SqlException ex) { throw WrapException(command, ex); } catch (Exception ex) { Log.DebugException($"Exception in relational transaction '{name}'", ex); throw; } } }
//private DockPanel _DockPanel; //private DockState _DockState; public EditorContainer(Editor editor, DockPanel dock, DockState dockState = DockState.Document) { Editor = editor; Editor.UndoRedoStateChanged += Editor_UndoRedoStateChanged; Editor.TextChangedDelayed += Editor_TextChangedDelayed; Splitter = new Splitter() { Dock = DockStyle.Right, BackColor = SystemColors.ControlDarkDark, Width = 4 }; DocumentMap = new DocumentMap() { Target = editor, Dock = DockStyle.Right, Width = DocumentMapInitialWidth, MinimumSize = new Size(DocumentMapMinimumWidth, 0), Scale = DocumentMapInitialWidth * DocumentMapScaleFactor, BackColor = EditorSyntax.Styles.Background, ForeColor = Color.FromArgb(0, 122, 204) }; DocumentMap.DoubleClick += DocumentMap_DoubleClick; DocumentMap.MouseWheel += DocumentMap_MouseWheel; Splitter.SplitterMoved += Splitter_SplitterMoved; Name = Editor.File.FileName; ToolTipText = Editor.File.Path; Controls.Add(Editor); Controls.Add(Splitter); Controls.Add(DocumentMap); UpdateText(true); FormClosing += EditorContainer_FormClosing; FormClosed += EditorContainer_FormClosed; System.Threading.Thread.Sleep(10); dock.Invoke(new Action(() => { Show(dock, dockState); })); }
private async Task ProcessProjectAsync( Project project, DocumentMap documentMap) { using (Logger.LogBlock(FunctionId.FindReference_ProcessProjectAsync, project.Name, _cancellationToken)) { if (project.SupportsCompilation) { // make sure we hold onto compilation while we search documents belong to this project var compilation = await project.GetCompilationAsync(_cancellationToken).ConfigureAwait(false); var documentTasks = new List <Task>(); foreach (var kvp in documentMap) { var document = kvp.Key; if (document.Project == project) { var documentQueue = kvp.Value; documentTasks.Add(Task.Run(() => ProcessDocumentQueueAsync( document, documentQueue), _cancellationToken)); } } await Task.WhenAll(documentTasks).ConfigureAwait(false); GC.KeepAlive(compilation); } } }
string AppendRelatedDocumentStatementsForUpdate( string statement, CommandParameterValues parameters, DocumentMap mapping, object document) { var relatedDocumentData = GetRelatedDocumentTableData(mapping, new[] { document }); if (relatedDocumentData.Count == 0) { return(statement); } var sb = new StringBuilder(); sb.AppendLine(statement); sb.AppendLine(); if (relatedDocumentData.Any(d => d.Related.Any())) { sb.AppendLine("DECLARE @references as TABLE (Reference nvarchar(400), ReferenceTable nvarchar(400))"); } foreach (var data in relatedDocumentData) { if (data.Related.Any()) { var relatedVariablePrefix = $"{data.TableName.ToLower()}_"; sb.AppendLine(); sb.AppendLine("DELETE FROM @references"); sb.AppendLine(); var valueBlocks = data.Related.Select((r, idx) => $"(@{relatedVariablePrefix}{idx}, '{r.relatedTableName}')"); sb.Append("INSERT INTO @references VALUES "); sb.AppendLine(string.Join(", ", valueBlocks)); sb.AppendLine(); sb.AppendLine($"DELETE FROM [{data.SchemaName}].[{data.TableName}] WHERE [{data.IdColumnName}] = @{IdVariableName}"); sb.AppendLine($" AND [{data.RelatedDocumentIdColumnName}] not in (SELECT Reference FROM @references)"); sb.AppendLine(); sb.AppendLine($"INSERT INTO [{data.SchemaName}].[{data.TableName}] ([{data.IdColumnName}], [{data.IdTableColumnName}], [{data.RelatedDocumentIdColumnName}], [{data.RelatedDocumentTableColumnName}])"); sb.AppendLine($"SELECT @{IdVariableName}, '{mapping.TableName}', Reference, ReferenceTable FROM @references t"); sb.AppendLine($"WHERE NOT EXISTS (SELECT null FROM [{data.SchemaName}].[{data.TableName}] r WHERE r.[{data.IdColumnName}] = @{IdVariableName} AND r.[{data.RelatedDocumentIdColumnName}] = t.Reference )"); for (var x = 0; x < data.Related.Length; x++) { parameters.Add(relatedVariablePrefix + x, data.Related[x].relatedDocumentId); } } else { sb.AppendLine($"DELETE FROM [{data.SchemaName}].[{data.TableName}] WHERE [{data.IdColumnName}] = @Id"); } } return(sb.ToString()); }
public virtual void ContributeTo(IDbCommand command, DocumentMap mapping = null) { command.CommandType = CommandType; foreach (var pair in this) { ContributeParameter(command, pair.Key, pair.Value, mapping); } }
static int Main(string[] args) { DocumentMap documentMap = BuildDiffDocumentMap(ParseDiffs(ConsoleLines())); Console.WriteLine($"INFO: {documentMap.Count} files to process"); ApplyChanges(documentMap); return(0); }
public void When_Referenced_It_Is_Added_To_Reference_Fields() { var orderMap = new DocumentMap<Order>(); orderMap.Reference(o => o.Customer); Assert.AreEqual(1, orderMap.GetReferencedFields().Count); Assert.IsTrue(orderMap.GetReferencedFields().Any(m => m.Name == "Customer" && m.Type == typeof(Customer))); }
public override void BulkDelete(DocumentContext context, DocumentTransaction transaction) { var formatting = context.Formatting == Format.Indented ? Formatting.Indented : Formatting.None; var json = new JSONSerializer(Logger); var map = new DocumentMap(context.Primary, context.Primary); json.DeleteRows(context.Storage, context.Documents.Select(d => d.Data).ToList(), map, formatting); }
public PreparedCommand(string statement, CommandParameterValues parameterValues, RetriableOperation operation = RetriableOperation.None, DocumentMap mapping = null, TimeSpan?commandTimeout = null, CommandBehavior commandBehavior = CommandBehavior.Default) { Mapping = mapping; Statement = statement; ParameterValues = parameterValues; Operation = operation; CommandTimeout = commandTimeout; CommandBehavior = commandBehavior; }
public void When_Set_Mapped_Fields_It_Is_Added_To_Primitive_Fields() { var customerMap = new DocumentMap<Customer>(); customerMap.Map(c => c.Name); customerMap.Map(c => c.Address); Assert.AreEqual(2, customerMap.GetMappedFields().Count); Assert.IsTrue(customerMap.GetMappedFields().Any(m => m.Name == "Name" && m.Type == typeof(string))); Assert.IsTrue(customerMap.GetMappedFields().Any(m => m.Name == "Address" && m.Type == typeof(string))); }
//Update ve Merge işlemleri için public void MergeRows(DocumentStorage storage, List <JObject> rows, DocumentMap map, Formatting formatting = Formatting.None) { try { using (FileStream fsTemp = new FileStream(storage.Tempory, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Write, BufferSize)) using (StreamWriter sw = new StreamWriter(fsTemp, Encoding.UTF8, BufferSize)) using (JsonTextWriter writer = new JsonTextWriter(sw)) { var match = 0; var count = rows.Count; writer.Formatting = formatting; writer.WriteStartArray(); using (FileStream fsTarget = new FileStream(storage.Target, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize)) using (StreamReader sr = new StreamReader(fsTarget, Encoding.UTF8, false, BufferSize)) using (JsonReader reader = new JsonTextReader(sr)) { while (reader.Read()) { if (reader.TokenType == JsonToken.StartObject) { JObject readRow = JObject.Load(reader); if (match < count) { var readId = readRow[map.Target].ToString(); foreach (JObject row in rows) { var id = row[map.Source].ToString(); if (readId == id) { readRow.Merge(row); match++; break; } } } readRow.WriteTo(writer); } } } writer.WriteEndArray(); writer.Flush(); } } catch (Exception ex) { Logger?.Fatal(ex); throw ex; } }
string AllocateId(DocumentMap mapping) { if (!string.IsNullOrEmpty(mapping.SingletonId)) { return(mapping.SingletonId); } return(AllocateId(mapping.TableName, mapping.IdPrefix)); }
public void GetPart() { var map = new DocumentMap<string>(); map.Add(5, "test"); var relativeRanges = map.GetRelativeRange(new Range(1, 7)); Assert.AreEqual(1, relativeRanges.Count); Assert.AreEqual("test", relativeRanges[0].Source); Assert.AreEqual(new Range(1,5), relativeRanges[0].Range); }
public void GetEmpty() { var map = new DocumentMap<string>(); map.Add(5, "test"); map.Add(0, "test3"); map.Add(2, "test2"); var relativeRanges = map.GetRelativeRange(new Range(1, 7)); Assert.AreEqual(3, relativeRanges.Count); Assert.AreEqual("test3", relativeRanges[1].Source); Assert.AreEqual(new Range(0,0), relativeRanges[1].Range); }
private async Task<ProjectToDocumentMap> CreateProjectToDocumentMapAsync(ProjectMap projectMap) { using (Logger.LogBlock(FunctionId.FindReference_CreateDocumentMapAsync, _cancellationToken)) { var finalMap = new ProjectToDocumentMap(); foreach (var kvp in projectMap) { var project = kvp.Key; var projectQueue = kvp.Value; var documentMap = new DocumentMap(); foreach (var symbolAndFinder in projectQueue) { _cancellationToken.ThrowIfCancellationRequested(); var symbolAndProjectId = symbolAndFinder.symbolAndProjectId; var symbol = symbolAndProjectId.Symbol; var finder = symbolAndFinder.finder; var documents = await finder.DetermineDocumentsToSearchAsync(symbol, project, _documents, _cancellationToken).ConfigureAwait(false); foreach (var document in documents.Distinct().WhereNotNull()) { if (_documents == null || _documents.Contains(document)) { documentMap.Add(document, symbolAndFinder); } } } Contract.ThrowIfTrue(documentMap.Any(kvp1 => kvp1.Value.Count != kvp1.Value.ToSet().Count)); if (documentMap.Count > 0) { finalMap.Add(project, documentMap); } } return finalMap; } }
public void When_Given_A_NonPrimitive_Id_Type_Throws_Exception() { var orderMap = new DocumentMap<Order>(); orderMap.Id(c => c.Customer); }
public void When_Set_IdField_It_Is_Set_As_Primary_Key() { var customerMap= new DocumentMap<Customer>(); customerMap.Id(c => c.Id); Assert.AreEqual("Id",customerMap.IdWrapper.Name); }
public void EmptyIsEmptyAndNotNull() { var map = new DocumentMap<string>(); Assert.AreEqual(0, map.GetRelativeRange(new Range(0, 7)).Count); }
public void InvalidDoesNotCrash() { var map = new DocumentMap<string>(); Assert.AreEqual(0, map.GetRelativeRange(new Range(-5, 0)).Count); }