public void AfterBackupRestoreCanQueryIndex_CreatedBeforeRestore() { db.Documents.Put("ayende", null, RavenJObject.Parse("{'email':'*****@*****.**'}"), RavenJObject.Parse("{'Raven-Entity-Name':'Users'}"), null); db.SpinBackgroundWorkers(); QueryResult queryResult; do { queryResult = db.Queries.Query("Raven/DocumentsByEntityName", new IndexQuery { Query = "Tag:[[Users]]", PageSize = 10 }, CancellationToken.None); } while (queryResult.IsStale); Assert.Equal(1, queryResult.Results.Count); db.Maintenance.StartBackup(BackupDir, false, new DatabaseDocument()); WaitForBackup(db, true); db.Dispose(); IOExtensions.DeleteDirectory(DataDir); MaintenanceActions.Restore(new RavenConfiguration(), new DatabaseRestoreRequest { BackupLocation = BackupDir, DatabaseLocation = DataDir, Defrag = true }, s => { }); db = new DocumentDatabase(new RavenConfiguration { DataDirectory = DataDir }); queryResult = db.Queries.Query("Raven/DocumentsByEntityName", new IndexQuery { Query = "Tag:[[Users]]", PageSize = 10 }, CancellationToken.None); Assert.Equal(1, queryResult.Results.Count); }
public static void Restore(RavenConfiguration configuration, DatabaseRestoreRequest restoreRequest, Action <string> output) { var databaseDocumentPath = FindDatabaseDocument(restoreRequest.BackupLocation); if (File.Exists(databaseDocumentPath) == false) { throw new InvalidOperationException("Cannot restore when the Database.Document file is missing in the backup folder: " + restoreRequest.BackupLocation); } var databaseDocumentText = File.ReadAllText(databaseDocumentPath); var databaseDocument = RavenJObject.Parse(databaseDocumentText).JsonDeserialization <DatabaseDocument>(); string storage; if (databaseDocument.Settings.TryGetValue("Raven/StorageTypeName", out storage) == false) { if (File.Exists(Path.Combine(restoreRequest.BackupLocation, BackupMethods.Filename))) { storage = InMemoryRavenConfiguration.VoronTypeName; } else if (Directory.Exists(Path.Combine(restoreRequest.BackupLocation, "new"))) { storage = InMemoryRavenConfiguration.EsentTypeName; } else { storage = InMemoryRavenConfiguration.EsentTypeName; } } if (!string.IsNullOrWhiteSpace(restoreRequest.DatabaseLocation)) { configuration.DataDirectory = restoreRequest.DatabaseLocation; } using (var transactionalStorage = configuration.CreateTransactionalStorage(storage, () => { }, () => { })) { transactionalStorage.Restore(restoreRequest, output); } }
public void CanGetReducedValues() { var values = new[] { "{blog_id: 3, comments: [{},{},{}]}", "{blog_id: 5, comments: [{},{},{},{}]}", "{blog_id: 6, comments: [{},{},{},{},{},{}]}", "{blog_id: 7, comments: [{}]}", "{blog_id: 3, comments: [{},{},{}]}", "{blog_id: 3, comments: [{},{},{},{},{}]}", "{blog_id: 2, comments: [{},{},{},{},{},{},{},{}]}", "{blog_id: 4, comments: [{},{},{}]}", "{blog_id: 5, comments: [{},{}]}", "{blog_id: 3, comments: [{},{},{}]}", "{blog_id: 5, comments: [{}]}", }; for (int i = 0; i < values.Length; i++) { db.Put("docs/" + i, null, RavenJObject.Parse(values[i]), new RavenJObject(), null); } QueryResult q = null; for (var i = 0; i < 5; i++) { do { q = db.Query("CommentsCountPerBlog", new IndexQuery { Query = "blog_id:3", Start = 0, PageSize = 10 }); Thread.Sleep(100); } while (q.IsStale); } q.Results[0].Remove("@metadata"); Assert.Equal(@"{""blog_id"":3,""comments_length"":14}", q.Results[0].ToString(Formatting.None)); }
public void CanReplicateDocumentWithOAuth() { var store1 = CreateStore(); var store2 = CreateStore(); foreach (var server in servers) { var writer = new StringWriter(); store1.Conventions.CreateSerializer().Serialize(writer, new AuthenticationUser { Name = "Ayende", Id = "Raven/Users/Ayende", AllowedDatabases = new[] { "*" } }.SetPassword("abc")); server.Database.Put("Raven/Users/Ayende", null, RavenJObject.Parse(writer.GetStringBuilder().ToString()), new RavenJObject(), null); } TellFirstInstanceToReplicateToSecondInstance(); using (var session = store1.OpenSession()) { session.Store(new Item()); session.SaveChanges(); } JsonDocument item = null; for (int i = 0; i < RetriesCount; i++) { item = store2.DatabaseCommands.Get("items/1"); if (item != null) { break; } Thread.Sleep(100); } Assert.NotNull(item); }
public IEnumerable <AttachmentInformation> GetAttachmentsByReverseUpdateOrder(int start) { Api.JetSetCurrentIndex(session, Files, "by_etag"); Api.MoveAfterLast(session, Files); for (int i = 0; i < start; i++) { if (Api.TryMovePrevious(session, Files) == false) { yield break; } } while (Api.TryMovePrevious(session, Files)) { yield return(new AttachmentInformation { Size = Api.RetrieveColumnSize(session, Files, tableColumnsCache.FilesColumns["data"]).Value, Etag = Api.RetrieveColumn(session, Files, tableColumnsCache.FilesColumns["etag"]).TransfromToGuidWithProperSorting(), Key = Api.RetrieveColumnAsString(session, Files, tableColumnsCache.FilesColumns["name"], Encoding.Unicode), Metadata = RavenJObject.Parse(Api.RetrieveColumnAsString(session, Files, tableColumnsCache.FilesColumns["metadata"], Encoding.Unicode)) }); } }
public void RemoveValueInNestedElement() { var patchedDoc = new JsonPatcher(doc).Apply( new[] { new PatchRequest { Type = PatchCommandType.Modify, Name = "user", PrevVal = RavenJObject.Parse(@"{ ""name"": ""ayende"", ""id"": 13}"), Nested = new[] { new PatchRequest { Type = PatchCommandType.Unset, Name = "name" }, } }, }); Assert.Equal(@"{""title"":""A Blog Post"",""body"":""html markup"",""comments"":[{""author"":""ayende"",""text"":""good post 1""},{""author"":""ayende"",""text"":""good post 2""}],""user"":{""id"":13}}", patchedDoc.ToString(Formatting.None)); }
private async Task <PutResult> SaveEntryAsync(string tenant, string entityName, ApplicationUser ownerUser, JObject jobject, string id) { UserIdentityHelper.SetUserIdentity(jobject, ownerUser); var dataEntry = JsonConvert.SerializeObject(jobject); var commands = _documentStore.AsyncDatabaseCommands.ForDatabase(tenant); // NOTE: The PutAsync database command allows us to set the `Raven-Entity-Name` metadata which tells RavenDB to put this entity in it's own entity collection. // Using the `session.Store` or `asyncSession.StoreAsync` methods will cause RavenDB to reflect on the parameter object causing all entites to be stored in // a single entity collection of `JObject` which is not what we want. var result = await commands.PutAsync( id, null, RavenJObject.Parse(dataEntry), new RavenJObject { { "Raven-Entity-Name", entityName }, }); return(result); }
public void CanReplicateValuesFromIndexToDataTable() { db.PutIndex("test", new IndexDefinition { Map = "from doc in docs from prj in doc.Projects select new{Project = prj}", Stores = { { "Project", FieldStorage.Yes } } }); db.Put("t", null, RavenJObject.Parse("{'Projects': ['RavenDB', 'NHibernate']}"), new RavenJObject(), null); QueryResult queryResult; do { queryResult = db.Query("test", new IndexQuery { Start = 0, PageSize = 2, Query = "Project:RavenDB" }); } while (queryResult.IsStale); var indexToDataTable = db.IndexUpdateTriggers.OfType <IndexToDataTable>().Single(); Assert.Equal(2, indexToDataTable.DataTable.Rows.Count); }
public void SetValueInNestedElement_WithConcurrency_Ok() { var patchedDoc = new JsonPatcher(doc).Apply( new[] { new PatchRequest { Type = PatchCommandType.Modify, Name = "user", PrevVal = RavenJObject.Parse(@"{ ""name"": ""ayende"", ""id"": 13}"), Nested = new[] { new PatchRequest { Type = PatchCommandType.Set, Name = "name", Value = new RavenJValue("rahien") }, } }, }); Assert.Equal(RavenJToken.Parse(@"{""title"":""A Blog Post"",""body"":""html markup"",""comments"":[{""author"":""ayende"",""text"":""good post 1""},{""author"":""ayende"",""text"":""good post 2""}],""user"":{""name"":""rahien"",""id"":13}}"), patchedDoc, RavenJTokenEqualityComparer.Default); }
public void ShouldThrowWhenTryingToUseTheSameIncrementalBackupLocationForDifferentDatabases(string storageName) { using (var store = NewRemoteDocumentStore(runInMemory: false, requestedStorage: storageName, databaseName: "RavenDB_2824_one")) { store.DatabaseCommands.Put("animals/1", null, RavenJObject.Parse("{'Name':'Daisy'}"), new RavenJObject()); store.DatabaseCommands.GlobalAdmin.StartBackup(BackupDir, null, true, store.DefaultDatabase).WaitForCompletion(); store.DatabaseCommands.Put("animals/2", null, RavenJObject.Parse("{'Name':'Banny'}"), new RavenJObject()); store.DatabaseCommands.GlobalAdmin.StartBackup(BackupDir, null, true, store.DefaultDatabase).WaitForCompletion(); } using (var store = NewRemoteDocumentStore(runInMemory: false, requestedStorage: storageName, databaseName: "RavenDB_2824_two")) { store.DatabaseCommands.Put("animals/1", null, RavenJObject.Parse("{'Name':'Daisy'}"), new RavenJObject()); var ex = Assert.Throws <InvalidOperationException>(() => store.DatabaseCommands.GlobalAdmin.StartBackup(BackupDir, null, true, "RavenDB_2824_two").WaitForCompletion()); Assert.Contains("Can't perform an incremental backup to a given folder because it already contains incremental backup data of different database. Existing incremental data origins from 'RavenDB_2824_one' database.", ex.Message); } }
public void AfterFailedBackupRestoreCanDetectError() { db.Put("ayende", null, RavenJObject.Parse("{'email':'*****@*****.**'}"), RavenJObject.Parse("{'Raven-Entity-Name':'Users'}"), null); db.SpinBackgroundWorkers(); QueryResult queryResult; do { queryResult = db.Query("Raven/DocumentsByEntityName", new IndexQuery { Query = "Tag:[[Users]]", PageSize = 10 }); } while (queryResult.IsStale); Assert.Equal(1, queryResult.Results.Count); File.WriteAllText("raven.db.test.backup.txt", "Sabotage!"); db.StartBackup("raven.db.test.backup.txt", false, new DatabaseDocument()); WaitForBackup(db, false); Assert.True(GetStateOfLastStatusMessage().Severity == BackupStatus.BackupMessageSeverity.Error); }
public void CanPerformSpatialSearchWithNulls() { var indexDefinition = new IndexDefinition { Map = "from e in docs.Events select new { Tag = \"Event\", _ = SpatialIndex.Generate(e.Latitude, e.Longitude) }", Indexes = { { "Tag", FieldIndexing.NotAnalyzed } } }; db.PutIndex("eventsByLatLng", indexDefinition); db.Put("Events/1", null, RavenJObject.Parse(@"{""Venue"": ""Jimmy's Old Town Tavern"", ""Latitude"": null, ""Longitude"": null }"), RavenJObject.Parse("{'Raven-Entity-Name': 'Events'}"), null); const double radius = 6.0; QueryResult queryResult; do { queryResult = db.Query("eventsByLatLng", new SpatialIndexQuery() { Query = "Tag:[[Event]]", Latitude = 0, Longitude = 0, Radius = radius, SortedFields = new[] { new SortedField("__distance"), } }); if (queryResult.IsStale) { Thread.Sleep(100); } } while (queryResult.IsStale); Assert.Equal(1, queryResult.Results.Count); }
public void CanUpdateReduceValue_WhenChangingReduceKey() { var values = new[] { "{blog_id: 3, comments: [{},{},{}]}", "{blog_id: 5, comments: [{},{},{},{}]}", "{blog_id: 6, comments: [{},{},{},{},{},{}]}", "{blog_id: 7, comments: [{}]}", "{blog_id: 3, comments: [{},{},{}]}", "{blog_id: 3, comments: [{},{},{},{},{}]}", "{blog_id: 2, comments: [{},{},{},{},{},{},{},{}]}", "{blog_id: 4, comments: [{},{},{}]}", "{blog_id: 5, comments: [{},{}]}", "{blog_id: 3, comments: [{},{},{}]}", "{blog_id: 5, comments: [{}]}", }; using (var store = GetDocumentStore()) { Fill(store); for (int i = 0; i < values.Length; i++) { store.DatabaseCommands.Put("blogs/" + i, null, RavenJObject.Parse(values[i]), new RavenJObject { { "Raven-Entity-Name", "Blogs" } }); } GetUnstableQueryResult(store, "blog_id:3"); store.DatabaseCommands.Put("blogs/0", null, RavenJObject.Parse("{blog_id: 7, comments: [{}]}"), new RavenJObject { { "Raven-Entity-Name", "Blogs" } }); var q = GetUnstableQueryResult(store, "blog_id:3"); Assert.Equal(@"{""blog_id"":3,""comments_length"":11}", q.Results[0].ToString(Formatting.None)); } }
public void HandleResponses(GetResponse[] responses, ShardStrategy shardStrategy) { var list = new List <MultiLoadResult>( from response in responses let result = RavenJObject.Parse(response.Result) select new MultiLoadResult { Includes = result.Value <RavenJArray>("Includes").Cast <RavenJObject>().ToList(), Results = result.Value <RavenJArray>("Results").Cast <RavenJObject>().ToList() }); var capacity = list.Max(x => x.Results.Count); var finalResult = new MultiLoadResult { Includes = new List <RavenJObject>(), Results = new List <RavenJObject>(Enumerable.Range(0, capacity).Select(x => (RavenJObject)null)) }; foreach (var multiLoadResult in list) { finalResult.Includes.AddRange(multiLoadResult.Includes); for (int i = 0; i < multiLoadResult.Results.Count; i++) { if (finalResult.Results[i] == null) { finalResult.Results[i] = multiLoadResult.Results[i]; } } } RequiresRetry = loadOperation.SetResult(finalResult); if (RequiresRetry == false) { Result = loadOperation.Complete <T>(); } }
public void Can_Read_Values_Using_Deep_Nesting() { db.PutIndex(@"DocsByProject", new IndexDefinition { Map = @" from doc in docs from prj in doc.projects select new{project_name = prj.name} " }); var document = RavenJObject.Parse( "{'name':'ayende','email':'*****@*****.**','projects':[{'name':'raven'}], '@metadata': { '@id': 1}}"); db.Put("1", Guid.Empty, document, new RavenJObject(), null); QueryResult docs; do { docs = db.Query("DocsByProject", new IndexQuery { Query = "project_name:raven", Start = 0, PageSize = 10 }); if (docs.IsStale) { Thread.Sleep(100); } } while (docs.IsStale); Assert.Equal(1, docs.Results.Count); var jProperty = docs.Results[0]["name"]; Assert.Equal("ayende", jProperty.Value <string>()); }
public void AfterBackupRestoreCanQueryIndex_CreatedBeforeRestore() { DeleteIfExists("raven.db.test.backup"); // for full backups, we can't have anything in the target dir db.Put("ayende", null, RavenJObject.Parse("{'email':'*****@*****.**'}"), RavenJObject.Parse("{'Raven-Entity-Name':'Users'}"), null); db.SpinBackgroundWorkers(); QueryResult queryResult; do { queryResult = db.Query("Raven/DocumentsByEntityName", new IndexQuery { Query = "Tag:[[Users]]", PageSize = 10 }); } while (queryResult.IsStale); Assert.Equal(1, queryResult.Results.Count); db.StartBackup("raven.db.test.backup", false); WaitForBackup(true); db.Dispose(); DeleteIfExists("raven.db.test.esent"); DocumentDatabase.Restore(new RavenConfiguration(), "raven.db.test.backup", "raven.db.test.esent"); db = new DocumentDatabase(new RavenConfiguration { DataDirectory = "raven.db.test.esent" }); queryResult = db.Query("Raven/DocumentsByEntityName", new IndexQuery { Query = "Tag:[[Users]]", PageSize = 10 }); Assert.Equal(1, queryResult.Results.Count); }
public void HandleResponse(GetResponse response) { if (response.Status == 404) { Result = null; RequiresRetry = false; return; } var headers = new NameValueCollection(); foreach (var header in response.Headers) { headers[header.Key] = header.Value; } var jsonDocument = SerializationHelper.DeserializeJsonDocument(key, RavenJObject.Parse(response.Result), headers, (HttpStatusCode)response.Status); RequiresRetry = loadOperation.SetResult(jsonDocument); if (RequiresRetry == false) { Result = loadOperation.Complete <T>(); } }
public void AfterBackupRestoreCanReadDocument() { DeleteIfExists("raven.db.test.backup"); // for full backups, we can't have anything in the target dir db.Put("ayende", null, RavenJObject.Parse("{'email':'*****@*****.**'}"), new RavenJObject(), null); db.StartBackup("raven.db.test.backup", false); WaitForBackup(true); db.Dispose(); DeleteIfExists("raven.db.test.esent"); DocumentDatabase.Restore(new RavenConfiguration(), "raven.db.test.backup", "raven.db.test.esent"); db = new DocumentDatabase(new RavenConfiguration { DataDirectory = "raven.db.test.esent" }); var jObject = db.Get("ayende", null).ToJson(); Assert.Equal("*****@*****.**", jObject.Value <string>("email")); }
private static MultiLoadResult CompleteMultiGet(Task <string> task) { try { var result = RavenJObject.Parse(task.Result); return(new MultiLoadResult { Includes = result.Value <RavenJArray>("Includes").Cast <RavenJObject>().ToList(), Results = result.Value <RavenJArray>("Results").Cast <RavenJObject>().ToList() }); } catch (WebException e) { var httpWebResponse = e.Response as HttpWebResponse; if (httpWebResponse == null || httpWebResponse.StatusCode != HttpStatusCode.Conflict) { throw; } throw ThrowConcurrencyException(e); } }
public void Can_get_stats_for_indexing() { db.Put("1", Guid.Empty, RavenJObject.Parse( @"{ type: 'page', some: 'val', other: 'var', content: 'this is the content', title: 'hello world', size: 1, '@metadata': {'@id': 1} }" ), new RavenJObject(), null); QueryResult docs; do { docs = db.Query("pagesByTitle2", new IndexQuery { Query = "f:val", Start = 0, PageSize = 10 }); if (docs.IsStale) { Thread.Sleep(100); } } while (docs.IsStale); var indexStats = db.Statistics.Indexes.First(x => x.Name == "pagesByTitle2"); Assert.Equal("pagesByTitle2", indexStats.Name); Assert.Equal(1, indexStats.IndexingAttempts); Assert.Equal(1, indexStats.IndexingSuccesses); }
public static Task <NameAndCount[]> GetTermsCount(this IAsyncDatabaseCommands cmds, string indexName, string field, string fromValue, int pageSize) { string[] terms = null; return(cmds.GetTermsAsync(indexName, field, fromValue, pageSize) .ContinueWith(task => { terms = task.Result; var termRequests = terms.Select(term => new IndexQuery { Query = field + ":" + RavenQuery.Escape(term), PageSize = 0, }.GetIndexQueryUrl("", indexName, "indexes")) .Select(url => { var uriParts = url.Split(new[] { '?' }, StringSplitOptions.RemoveEmptyEntries); return new GetRequest { Url = uriParts[0], Query = uriParts[1] }; }) .ToArray(); if (termRequests.Length == 0) { return Task.Factory.StartNew(() => new NameAndCount[0]); } return cmds.MultiGetAsync(termRequests) .ContinueWith(termsResultsTask => termsResultsTask.Result.Select((t, i) => new NameAndCount { Count = RavenJObject.Parse(t.Result).Value <int>("TotalResults"), Name = terms[i] }).ToArray()); }) .Unwrap()); }
private static RavenJObject CreateJsonDocumentFromLuceneDocument(Document document) { var field = document.GetField(Constants.ReduceValueFieldName); if (field != null) { return(RavenJObject.Parse(field.StringValue)); } var ravenJObject = new RavenJObject(); foreach (var fieldable in document.GetFields()) { var stringValue = GetStringValue(fieldable); RavenJToken value; if (ravenJObject.TryGetValue(fieldable.Name, out value) == false) { ravenJObject[fieldable.Name] = stringValue; } else { var ravenJArray = value as RavenJArray; if (ravenJArray != null) { ravenJArray.Add(stringValue); } else { ravenJArray = new RavenJArray { value, stringValue }; ravenJObject[fieldable.Name] = ravenJArray; } } } return(ravenJObject); }
public void Can_read_values_from_indexes_of_documents_already_in_db_when_multiple_docs_exists() { db.Put(null, Guid.Empty, RavenJObject.Parse( "{type: 'page', some: 'val', other: 'var', content: 'this is the content', title: 'hello world', size: 5}"), new RavenJObject(), null); db.Put(null, Guid.Empty, RavenJObject.Parse( "{type: 'page', some: 'val', other: 'var', content: 'this is the content', title: 'hello world', size: 5}"), new RavenJObject(), null); db.PutIndex("pagesByTitle", new IndexDefinition { Map = @" from doc in docs where doc.type == ""page"" select new { doc.other }; " }); QueryResult docs; do { docs = db.Query("pagesByTitle", new IndexQuery { Query = "other:var", Start = 0, PageSize = 10 }); if (docs.IsStale) { Thread.Sleep(100); } } while (docs.IsStale); Assert.Equal(2, docs.Results.Count); }
public void FunctionalityTest() { var str = GenerateSimpleEntityForFunctionalityTest(); using (var blittableContext = JsonOperationContext.ShortTermSingleUse()) using (var employee = blittableContext.Read(new MemoryStream(Encoding.UTF8.GetBytes(str)), "doc1")) { dynamic dynamicRavenJObject = new DynamicJsonObject(RavenJObject.Parse(str)); dynamic dynamicBlittableJObject = new DynamicBlittableJson(employee); Assert.Equal(dynamicRavenJObject.Age, dynamicBlittableJObject.Age); Assert.Equal(dynamicRavenJObject.Name, dynamicBlittableJObject.Name); Assert.Equal(dynamicRavenJObject.Dogs.Count, dynamicBlittableJObject.Dogs.Count); for (var i = 0; i < dynamicBlittableJObject.Dogs.Length; i++) { Assert.Equal(dynamicRavenJObject.Dogs[i], dynamicBlittableJObject.Dogs[i]); } Assert.Equal(dynamicRavenJObject.Office.Name, dynamicRavenJObject.Office.Name); Assert.Equal(dynamicRavenJObject.Office.Street, dynamicRavenJObject.Office.Street); Assert.Equal(dynamicRavenJObject.Office.City, dynamicRavenJObject.Office.City); var ms = new MemoryStream(); blittableContext.Write(ms, employee); Assert.Equal(str, Encoding.UTF8.GetString(ms.ToArray())); } }
private static RavenJToken GetValue(string val) { try { if (val.StartsWith("{")) { return(RavenJObject.Parse(val)); } if (val.StartsWith("[")) { return(RavenJArray.Parse(val)); } DateTime dateTime; if (DateTime.TryParseExact(val, Default.OnlyDateTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dateTime)) { if (val.EndsWith("Z")) { return(DateTime.SpecifyKind(dateTime, DateTimeKind.Utc)); } return(new RavenJValue(dateTime)); } DateTimeOffset dateTimeOffset; if (DateTimeOffset.TryParseExact(val, Default.DateTimeFormatsToRead, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dateTimeOffset)) { return(new RavenJValue(dateTimeOffset)); } return(new RavenJValue(Uri.UnescapeDataString(val))); } catch (Exception exc) { throw new JsonReaderException(string.Concat("Unable to get value: ", val), exc); } }
public IEnumerable <AttachmentInformation> GetAttachmentsAfter(Guid etag, int take) { Api.JetSetCurrentIndex(session, Files, "by_etag"); Api.MakeKey(session, Files, etag.TransformToValueForEsentSorting(), MakeKeyGrbit.NewKey); if (Api.TrySeek(session, Files, SeekGrbit.SeekGT) == false) { return(Enumerable.Empty <AttachmentInformation>()); } var optimizer = new OptimizedIndexReader(Session, Files, take); do { optimizer.Add(); } while (Api.TryMoveNext(session, Files) && optimizer.Count < take); return(optimizer.Select(() => new AttachmentInformation { Size = Api.RetrieveColumnSize(session, Files, tableColumnsCache.FilesColumns["data"]) ?? 0, Etag = Api.RetrieveColumn(session, Files, tableColumnsCache.FilesColumns["etag"]).TransfromToGuidWithProperSorting(), Key = Api.RetrieveColumnAsString(session, Files, tableColumnsCache.FilesColumns["name"], Encoding.Unicode), Metadata = RavenJObject.Parse(Api.RetrieveColumnAsString(session, Files, tableColumnsCache.FilesColumns["metadata"], Encoding.Unicode)) })); }
public static List <object> ExtractError(Stream stream, HttpWebResponse httpWebResponse, IEnumerable <object> details) { var objects = new List <object>(details); if (stream.CanRead) { var error = new StreamReader(stream).ReadToEnd(); try { var item = RavenJObject.Parse(error); objects.Insert(0, "Server Error:"); objects.Insert(1, "-----------------------------------------"); objects.Insert(2, item.Value <string>("Url")); objects.Insert(3, item.Value <string>("Error")); objects.Insert(4, "-----------------------------------------"); objects.Insert(5, Environment.NewLine); objects.Insert(6, Environment.NewLine); } catch (Exception) { objects.Insert(0, "Server sent:"); objects.Insert(1, error); objects.Insert(2, Environment.NewLine); objects.Insert(3, Environment.NewLine); } } if (httpWebResponse.StatusCode == HttpStatusCode.Unauthorized) { objects.Insert(0, "Could not get authorization for this command."); objects.Insert(1, "If you should have access to this operation contact your admin and check the Raven/AnonymousAccess or the Windows Authentication settings in RavenDB "); } return(objects); }
private static RavenJToken GetValue(string val) { try { if (val.StartsWith("{")) { return(RavenJObject.Parse(val)); } if (val.StartsWith("[")) { return(RavenJArray.Parse(val)); } DateTime result; if (DateTime.TryParseExact(val, new[] { "r", "o" }, CultureInfo.InvariantCulture, DateTimeStyles.None, out result)) { return(new RavenJValue(result)); } return(new RavenJValue(val)); } catch (Exception exc) { throw new JsonReaderException(string.Concat("Unable to get value: ", val), exc); } }
public Attachment GetAttachment(string key) { Api.JetSetCurrentIndex(session, Files, "by_name"); Api.MakeKey(session, Files, key, Encoding.Unicode, MakeKeyGrbit.NewKey); if (Api.TrySeek(session, Files, SeekGrbit.SeekEQ) == false) { return(null); } var metadata = Api.RetrieveColumnAsString(session, Files, tableColumnsCache.FilesColumns["metadata"], Encoding.Unicode); return(new Attachment { Data = () => { StorageActionsAccessor storageActionsAccessor = transactionalStorage.GetCurrentBatch(); var documentStorageActions = ((DocumentStorageActions)storageActionsAccessor.Attachments); return documentStorageActions.GetAttachmentStream(key); }, Size = (int)GetAttachmentStream(key).Length, Etag = Api.RetrieveColumn(session, Files, tableColumnsCache.FilesColumns["etag"]).TransfromToGuidWithProperSorting(), Metadata = RavenJObject.Parse(metadata) }); }
private static void CopyToServer() { var store = GetStore(); store.Initialize(true); var serverStore = new DocumentStore { Url = "http://it-webadb01.it.ntnu.no:8180", DefaultDatabase = _dbName //MaxNumberOfCachedRequests = 9999 }; serverStore.Initialize(true); using var session = store.OpenSession(); var query = session.Query <object>(PrimaryIndex); using var enumerator = session.Advanced.Stream(query); var i = 0; using var bulkServer = serverStore.BulkInsert(null, null); while (enumerator.MoveNext()) { var name = enumerator.Current.Key.StartsWith("Natur") ? "Naturtypes" : "Variasjons"; Log2Console($"{i++:#0000}\t{name}\t{enumerator.Current.Key}", true); ////bulkServer.Store(enumerator.Current.Document, enumerator.Current.Key); bulkServer.Store( RavenJObject.FromObject(enumerator.Current.Document), RavenJObject.Parse($"{{'Raven-Entity-Name': '{name}'}}"), enumerator.Current.Key); } }