public virtual bool MatchFilters(RavenJToken item) { foreach (var filter in Filters) { bool anyRecords = false; bool matchedFilter = false; foreach (var tuple in item.SelectTokenWithRavenSyntaxReturningFlatStructure(filter.Path)) { if (tuple == null || tuple.Item1 == null) continue; anyRecords = true; var val = tuple.Item1.Type == JTokenType.String ? tuple.Item1.Value<string>() : tuple.Item1.ToString(Formatting.None); matchedFilter |= filter.Values.Any(value => String.Equals(val, value, StringComparison.OrdinalIgnoreCase)) == filter.ShouldMatch; } if (filter.ShouldMatch == false && anyRecords == false) // RDBQA-7 return true; if (matchedFilter == false) return false; } return true; }
private static IEnumerable<ReadState> ReadRavenJToken(RavenJToken token) { if (token is RavenJValue) { yield return new ReadState(GetJsonTokenType(token), ((RavenJValue)token).Value); } else if (token is RavenJArray) { yield return new ReadState(JsonToken.StartArray); if (((RavenJArray)token).Length > 0) // to prevent object creation if inner array is null { foreach (var item in ((RavenJArray)token)) foreach (var i in ReadRavenJToken(item)) yield return i; } yield return new ReadState(JsonToken.EndArray); } else if (token is RavenJObject) { yield return new ReadState(JsonToken.StartObject); foreach (var prop in ((RavenJObject)token)) { yield return new ReadState(JsonToken.PropertyName, prop.Key); foreach (var item in ReadRavenJToken(prop.Value)) yield return item; } yield return new ReadState(JsonToken.EndObject); } }
private static JsonToken GetJsonTokenType(RavenJToken token) { switch (token.Type) { case JTokenType.Integer: return JsonToken.Integer; case JTokenType.Float: return JsonToken.Float; case JTokenType.String: return JsonToken.String; case JTokenType.Boolean: return JsonToken.Boolean; case JTokenType.Null: return JsonToken.Null; case JTokenType.Undefined: return JsonToken.Undefined; case JTokenType.Date: return JsonToken.Date; case JTokenType.Raw: return JsonToken.Raw; case JTokenType.Bytes: return JsonToken.Bytes; default: throw MiscellaneousUtils.CreateArgumentOutOfRangeException("Type", token.Type, "Unexpected JTokenType."); } }
// This is called only from inside persistenceStore.Write public void Add(RavenJToken key) { IComparable actualKey = transform(key); Index = Index.AddOrUpdate(actualKey, new EmptyAVLTree<RavenJToken, RavenJToken>(RavenJTokenComparer.Instance, token => token.CloneToken(), token => token.CloneToken()).Add(key, key), (comparable, tree) => tree.Add(key, key)); }
private static void WriteValue(RavenJToken token, StringWriter sw, int margin, int indent) { switch (token.Type) { case JTokenType.Array: WriteJsonArray((RavenJArray)token, sw, margin, indent); break; case JTokenType.Object: WriteJsonObject((RavenJObject)token, sw, margin, indent); break; case JTokenType.Null: sw.Write("null"); break; case JTokenType.String: sw.Write('"'); sw.Write(token.ToString() .NormalizeWhitespace() .ShortViewOfString(margin - 2) ); sw.Write('"'); break; default: sw.Write(token.ToString().ShortViewOfString(margin)); break; } }
private void ExecuteInternal(RavenJToken token, string prefix) { if (token == null) return; // nothing to do switch (token.Type) { case JTokenType.Array: foreach (var item in (RavenJArray)token) { ExecuteInternal(item, prefix); } break; case JTokenType.String: LoadId(token.Value<string>(), prefix); break; case JTokenType.Integer: LoadId(token.Value<int>().ToString(CultureInfo.InvariantCulture), prefix); break; default: // here we ignore everything else // if it ain't a string or array, it is invalid // as an id break; } }
private void ExecuteInternal(RavenJToken token) { if (token == null) return; // nothing to do switch (token.Type) { case JTokenType.Array: foreach (var item in (RavenJArray)token) { ExecuteInternal(item); } break; case JTokenType.String: var value = token.Value<string>(); if (LoadedIds.Add(value) == false) return; var includedDoc = Database.Get(value, TransactionInformation); if (includedDoc != null) Add(includedDoc.Etag,includedDoc.ToJson()); break; default: // here we ignore everything else // if it ain't a string or array, it is invalid // as an id break; } }
private IEnumerable<IEnumerable<AbstractField>> HandleToken(RavenJToken value, string path) { switch (value.Type) { case JTokenType.Array: foreach (var item in ((RavenJArray) value).SelectMany(val => HandleToken(val, path))) { yield return item; } break; case JTokenType.Object: foreach (var inner in ((RavenJObject)value)) { var nestedObj = inner.Value as RavenJObject; if(nestedObj!=null) { foreach (var item in HandleObject(nestedObj, path + "_" + inner.Key)) { yield return item; } } else { foreach (var item in HandleToken(inner.Value, path +"_" + inner.Key)) { yield return item; } } } break; default: yield return CreateField(path, value); break; } }
/// <summary> /// Initializes a new instance of the <see cref="RavenJTokenReader"/> class. /// </summary> /// <param name="token">The token to read from.</param> public RavenJTokenReader(RavenJToken token) { if (token == null) throw new ArgumentNullException("token"); _root = token; }
private static void ExecuteInternal(RavenJToken token, string prefix, Func<string, string, bool> loadId) { if (token == null) return; // nothing to do switch (token.Type) { case JTokenType.Array: foreach (var item in (RavenJArray)token) { ExecuteInternal(item, prefix, loadId); } break; case JTokenType.String: var value = token.Value<string>(); if (loadId(value, null) == false) loadId(value, prefix); break; case JTokenType.Integer: try { loadId(token.Value<long>().ToString(CultureInfo.InvariantCulture), prefix); } catch (OverflowException) { loadId(token.Value<ulong>().ToString(CultureInfo.InvariantCulture), prefix); } break; // here we ignore everything else // if it ain't a string or array, it is invalid // as an id } }
private RavenJToken GetTheNewResultOrWireTheDefault(RavenJToken result) { var selectToken = result.SelectToken(Name); if (selectToken != null) return selectToken; return ((RavenJObject)result)[Name] = new RavenJObject(); }
private static void Visit(RavenJToken token) { switch (token.Type) { case JTokenType.Object: foreach (var item in (RavenJObject)token) Visit(item.Value); break; case JTokenType.Array: foreach (var items in (RavenJArray)token) Visit(items); break; case JTokenType.Constructor: case JTokenType.Property: case JTokenType.Comment: case JTokenType.None: case JTokenType.Integer: case JTokenType.Float: case JTokenType.String: case JTokenType.Boolean: case JTokenType.Null: case JTokenType.Undefined: case JTokenType.Date: case JTokenType.Raw: case JTokenType.Bytes: break; default: throw new ArgumentOutOfRangeException(token.Type.ToString()); } }
private static void WriteValue(RavenJToken token, CountingWriter sw, int width, int numberOfLines) { switch (token.Type) { case JTokenType.Array: WriteJsonArray((RavenJArray)token, sw, width, numberOfLines); break; case JTokenType.Object: WriteJsonObject((RavenJObject)token, sw, width, numberOfLines); break; case JTokenType.Null: sw.Write("null"); break; case JTokenType.String: sw.Write("\""); sw.Write(token.ToString() .NormalizeWhitespace() .TrimmedViewOfString(width - sw.CharactersOnCurrentLine -1) ); sw.Write("\""); break; default: sw.Write(token.ToString().TrimmedViewOfString(width - sw.CharactersOnCurrentLine - 1)); break; } }
private void AddParent(RavenJToken token) { if (_token == null) { _token = token; _tokenStack.Push(_token); return; } switch (CurrentToken.Type) { case JTokenType.Object: if (string.IsNullOrEmpty(_tempPropName)) throw new JsonWriterException("Unexpected object token"); ((RavenJObject)CurrentToken)[_tempPropName] = token; _tempPropName = null; break; case JTokenType.Array: if (!string.IsNullOrEmpty(_tempPropName)) throw new JsonWriterException("Unexpected property token"); ((RavenJArray)CurrentToken).Add(token); break; default: throw new JsonWriterException("Unexpected token: " + CurrentToken.Type); } _tokenStack.Push(token); }
private static string StripQuotesIfNeeded(RavenJToken value) { var str = value.ToString(Formatting.None); if (str.StartsWith("\"") && str.EndsWith("\"")) return str.Substring(1, str.Length - 2); return str; }
public virtual void Add(WriteBatch writeBatch, Slice key, RavenJToken value, ushort? expectedVersion = null) { var stream = new BufferPoolMemoryStream(BufferPool); value.WriteTo(stream); stream.Position = 0; writeBatch.Add(key, stream, TableName, expectedVersion); }
private void RenameProperty(PatchRequest patchCmd, string propName, RavenJToken property) { EnsurePreviousValueMatchCurrentValue(patchCmd, property); if (property == null) return; document[patchCmd.Value.Value<string>()] = property; document.Remove(propName); }
public JsonContent(RavenJToken data = null) { Data = data; if (data != null) { Headers.ContentType = string.IsNullOrEmpty(Jsonp) ? new MediaTypeHeaderValue("application/json") {CharSet = "utf-8"} : new MediaTypeHeaderValue("application/javascript") {CharSet = "utf-8"}; } }
private static object GetPropertyValue(RavenJToken property) { switch (property.Type) { case JTokenType.Array: case JTokenType.Object: return property.ToString(Formatting.None); default: return property.Value<object>(); } }
public static UniqueConstraint GetConstraint(RavenJToken property) { switch (property.Type) { case JTokenType.String: // backward compatability return new UniqueConstraint { PropName = property.Value<string>() }; case JTokenType.Object: return new UniqueConstraint { PropName = property.Value<string>("Name"), CaseInsensitive = property.Value<bool>("CaseInsensitive") }; default: throw new ArgumentOutOfRangeException(property.Type.ToString()); } }
public static bool TryGetUniqueValues(RavenJToken prop, out string[] uniqueValues) { if (prop == null || prop.Type == JTokenType.Null) { uniqueValues = null; return false; } var array = prop as RavenJArray; uniqueValues = array != null ? array.Select(p => p.Value<string>()).ToArray() : new[] { prop.Value<string>() }; return true; }
private object GetValue(RavenJToken token) { if (token is RavenJObject) return new RavenJObjectDataItem((RavenJObject)token); if (token is RavenJArray) { var jArray = (RavenJArray)token; var result = new object[jArray.Length]; for (var index = 0; index < jArray.Length; ++index) result[index] = GetValue(jArray[index]); return result; } return token.Value<object>(); }
public virtual bool MatchFilters(RavenJToken item) { foreach (var filter in Filters) { var copy = filter; foreach (var tuple in item.SelectTokenWithRavenSyntaxReturningFlatStructure(copy.Key)) { if (tuple == null || tuple.Item1 == null) continue; var val = tuple.Item1.Type == JTokenType.String ? tuple.Item1.Value<string>() : tuple.Item1.ToString(Formatting.None); if (String.Equals(val, filter.Value, StringComparison.InvariantCultureIgnoreCase) == false) return false; } } return true; }
public static RavenJToken Clone(RavenJToken token) { switch (token.Type) { case JTokenType.Object: case JTokenType.Array: case JTokenType.Integer: case JTokenType.Float: case JTokenType.String: case JTokenType.Boolean: case JTokenType.Date: case JTokenType.Null: case JTokenType.Bytes: return token.CloneToken(); default: throw new ArgumentOutOfRangeException(); } }
private void Visit(RavenJToken token) { switch (token.Type) { case JTokenType.Object: var obj = (RavenJObject)token; Action after = () => { }; foreach (var item in obj) { Visit(item.Value); if (fieldsToFilter.Contains(item.Key)) { var itemCopy = item; after += () => obj[itemCopy.Key] = "...private..."; } } after(); break; case JTokenType.Array: foreach (var items in ((RavenJArray)token)) { Visit(items); } break; case JTokenType.Constructor: case JTokenType.Property: case JTokenType.Comment: case JTokenType.None: case JTokenType.Integer: case JTokenType.Float: case JTokenType.String: case JTokenType.Boolean: case JTokenType.Null: case JTokenType.Undefined: case JTokenType.Date: case JTokenType.Raw: case JTokenType.Bytes: break; default: throw new ArgumentOutOfRangeException(token.Type.ToString()); } }
/// <summary> /// gets rough size of RavenJToken - in bytes /// </summary> public static long GetRoughSize(RavenJToken token) { long sum; switch (token.Type) { case JTokenType.None: return 0; case JTokenType.Object: sum = 2;// {} foreach (var prop in (RavenJObject)token) { sum += prop.Key.Length + 1; // name: sum += GetRoughSize(prop.Value); } return sum; case JTokenType.Array: // the 1 is for , return 2 + ((RavenJArray)token).Sum(prop => 1 + GetRoughSize(prop)); case JTokenType.Constructor: case JTokenType.Property: case JTokenType.Comment: case JTokenType.Raw: return 0; case JTokenType.Boolean: return token.Value<bool>() ? 4 : 5; case JTokenType.Null: return 4; case JTokenType.Undefined: return 9; case JTokenType.Date: return 21; case JTokenType.Bytes: case JTokenType.Integer: case JTokenType.Float: case JTokenType.String: case JTokenType.Guid: case JTokenType.TimeSpan: case JTokenType.Uri: return token.Value<string>().Length; default: throw new ArgumentOutOfRangeException(); } }
// This is called only from inside persistenceStore.Write public void Remove(RavenJToken key) { IComparable actualKey = transform(key); var result = Index.Search(actualKey); if (result.IsEmpty) { return; } bool removed; RavenJToken _; var removedResult = result.Value.TryRemove(key, out removed, out _); if (removedResult.IsEmpty) { IBinarySearchTree<RavenJToken, RavenJToken> ignored; Index = Index.TryRemove(actualKey, out removed, out ignored); } else { Index = Index.AddOrUpdate(actualKey, removedResult, (comparable, tree) => removedResult); } }
public void ForEach(RavenJToken result, RavenJToken item, Action<PathPart, RavenJToken, RavenJToken> action) { if (string.IsNullOrEmpty(FinalName) == false) { action(this, item, result); return; } RavenJToken newResult = GetTheNewResultOrWireTheDefault(result); if (item == null) { foreach (var pathPart in Items) pathPart.Value.ForEach(newResult, null, action); return; } if (item is RavenJArray == false) { foreach (var pathPart in Items) pathPart.Value.ForEach(newResult, item.SelectToken(pathPart.Key), action); } else { var jArray = newResult as RavenJArray; if (jArray == null) { jArray = new RavenJArray(); ((RavenJObject)result)[Name] = jArray; } foreach (var subItem in item.Values<RavenJToken>()) { newResult = new RavenJObject(); jArray.Add(newResult); foreach (var pathPart in Items) { pathPart.Value.ForEach(newResult, subItem.SelectToken(pathPart.Key), action); } } } }
public static RavenJToken MinimizeToken(RavenJToken obj, int depth = 0) { switch (obj.Type) { case JTokenType.Array: var array = new RavenJArray(); foreach (var item in ((RavenJArray)obj)) { array.Add(MinimizeToken(item, depth + 1)); } return array; case JTokenType.Object: var ravenJObject = ((RavenJObject)obj); if (ravenJObject.ContainsKey(Constants.Metadata) == false) { // this might be a wrapper object, let check for first level arrays if (depth == 0) { var newRootObj = new RavenJObject(); foreach (var prop in ravenJObject) { newRootObj[prop.Key] = prop.Value.Type == JTokenType.Array ? MinimizeToken(prop.Value, depth + 1) : prop.Value; } return newRootObj; } return obj; } var newObj = new RavenJObject(); newObj[Constants.Metadata] = ravenJObject[Constants.Metadata]; return newObj; default: return obj; } }
private static void ExecuteInternal(RavenJToken token, string prefix, Func<string, string, bool> loadId) { if (token == null) return; // nothing to do switch (token.Type) { case JTokenType.Array: foreach (var item in (RavenJArray)token) { ExecuteInternal(item, prefix, loadId); } break; case JTokenType.String: var value = token.Value<string>(); // we need to check on both of them, with id & without id // because people will do products/1 and detaisl/products/1 and want to be able // to include on that loadId(value, prefix); if (prefix != null) loadId(value, null); break; case JTokenType.Integer: try { loadId(token.Value<long>().ToString(CultureInfo.InvariantCulture), prefix); } catch (OverflowException) { loadId(token.Value<ulong>().ToString(CultureInfo.InvariantCulture), prefix); } break; // here we ignore everything else // if it ain't a string or array, it is invalid // as an id } }
private static IndexStats GetIndexStats(RavenJToken indexingStats, RavenJToken reduceStats, RavenJToken lastIndexedEtags, int priority, int touches) { return(new IndexStats { TouchCount = touches, IndexingAttempts = indexingStats.Value <int>("attempts"), IndexingErrors = indexingStats.Value <int>("failures"), IndexingSuccesses = indexingStats.Value <int>("successes"), ReduceIndexingAttempts = reduceStats.Value <int?>("reduce_attempts"), ReduceIndexingErrors = reduceStats.Value <int?>("reduce_failures"), ReduceIndexingSuccesses = reduceStats.Value <int?>("reduce_successes"), Id = indexingStats.Value <int>("index"), Priority = (IndexingPriority)priority, LastIndexedEtag = Etag.Parse(lastIndexedEtags.Value <byte[]>("lastEtag")), LastIndexedTimestamp = lastIndexedEtags.Value <DateTime>("lastTimestamp"), CreatedTimestamp = indexingStats.Value <DateTime>("createdTimestamp"), LastIndexingTime = indexingStats.Value <DateTime>("lastIndexingTime"), LastReducedEtag = reduceStats.Value <byte[]>("lastReducedEtag") != null ? Etag.Parse(reduceStats.Value <byte[]>("lastReducedEtag")) : null, LastReducedTimestamp = reduceStats.Value <DateTime?>("lastReducedTimestamp") }); }
public bool Remove(RavenJToken key) { return(Remove(key, txId.Value)); }
protected override void PutIndex(string indexName, RavenJToken index) { _database.PutIndex(indexName, index.Value <RavenJObject>("definition").JsonDeserialization <IndexDefinition>()); }
public Task <RavenJToken> ReadResponseJsonAsync() { return(ReadResponseStringAsync() .ContinueWith(task => RavenJToken.Parse(task.Result))); }
public ReadResult Read(RavenJToken key) { return(Read(key, txId.Value)); }
public object TransformToValue(RavenJToken jToken) { switch (jToken.Type) { case JTokenType.Object: var jObject = (RavenJObject)jToken; if (jObject.ContainsKey("$values")) { var values = jObject.Value <RavenJArray>("$values"); return(new DynamicList(this, values.Select(TransformToValue).ToArray())); } if (jObject.ContainsKey("$ref")) { var refId = jObject.Value <string>("$ref"); var ravenJObject = FindReference(refId); if (ravenJObject != null) { return(new DynamicJsonObject(this, ravenJObject)); } } return(new DynamicJsonObject(this, jObject)); case JTokenType.Array: var ar = (RavenJArray)jToken; return(new DynamicList(this, ar.Select(TransformToValue).ToArray())); case JTokenType.Date: var ravenJValue = ((RavenJValue)jToken); return(ravenJValue.Value); case JTokenType.Null: return(new DynamicNullObject { IsExplicitNull = true }); default: var value = jToken.Value <object>(); if (value is long) { var l = (long)value; if (l > int.MinValue && int.MaxValue > l) { return((int)l); } } if (value is Guid) { return(value.ToString()); } var s = value as string; if (s != null) { //optimizations, don't try to call TryParse if empty if (s.Length == 0) { return(s); } //optimizations, don't try to call TryParse if first char isn't a digit if (char.IsDigit(s[0]) == false) { return(s); } DateTime dateTime; if (DateTime.TryParseExact(s, Default.OnlyDateTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dateTime)) { if (s.EndsWith("Z")) { return(DateTime.SpecifyKind(dateTime, DateTimeKind.Utc)); } return(dateTime); } DateTimeOffset dateTimeOffset; if (DateTimeOffset.TryParseExact(s, Default.DateTimeFormatsToRead, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dateTimeOffset)) { return(dateTimeOffset); } } return(value ?? new DynamicNullObject { IsExplicitNull = true }); } }
public override void OnPut(string key, RavenJObject jsonReplicationDocument, RavenJObject metadata, TransactionInformation transactionInformation) { if (key.StartsWith("Raven/", StringComparison.OrdinalIgnoreCase) && // we don't deal with system documents key.StartsWith("Raven/Hilo/", StringComparison.OrdinalIgnoreCase) == false) // except for hilos { return; } using (Database.DisableAllTriggersForCurrentThread()) { var documentMetadata = GetDocumentMetadata(key); if (documentMetadata == null) { var history = new RavenJArray() { new RavenJObject { { Constants.RavenReplicationVersion, metadata[Constants.RavenReplicationVersion] }, { Constants.RavenReplicationSource, metadata[Constants.RavenReplicationSource] } } }; } else { var history = new RavenJArray(ReplicationData.GetOrCreateHistory(documentMetadata)); if (documentMetadata.ContainsKey(Constants.RavenReplicationMergedHistory) == false) { if (documentMetadata.ContainsKey(Constants.RavenReplicationVersion) && documentMetadata.ContainsKey(Constants.RavenReplicationSource)) { history.Add(new RavenJObject { { Constants.RavenReplicationVersion, documentMetadata[Constants.RavenReplicationVersion] }, { Constants.RavenReplicationSource, documentMetadata[Constants.RavenReplicationSource] } }); } else { history.Add(new RavenJObject { { Constants.RavenReplicationVersion, 0 }, { Constants.RavenReplicationSource, RavenJToken.FromObject(Database.TransactionalStorage.Id) } }); } var sources = new HashSet <RavenJToken>(RavenJTokenEqualityComparer.Default); int pos = history.Length - 1; for (; pos >= 0; pos--) { var source = ((RavenJObject)history[pos])[Constants.RavenReplicationSource]; if (sources.Contains(source)) { history.RemoveAt(pos); continue; } sources.Add(source); } metadata[Constants.RavenReplicationMergedHistory] = true; metadata[Constants.RavenReplicationHistory] = history; } //If we have the flag we must have Constants.RavenReplicationVersion and Constants.RavenReplicationSource too //Here we assume that the replication history is in the form of a "sorted dictionary" so we just need to remove //the entry with the current source id and insert the new version at the end of the history. else { int i = history.Length - 1; for (; i >= 0; i--) { var currentEntry = history[i]; if (RavenJTokenEqualityComparer.Default.Equals(((RavenJObject)currentEntry) [Constants.RavenReplicationSource], documentMetadata[Constants.RavenReplicationSource])) { break; } } if (i != -1) { history.RemoveAt(i); } history.Add(new RavenJObject { { Constants.RavenReplicationVersion, documentMetadata[Constants.RavenReplicationVersion] }, { Constants.RavenReplicationSource, documentMetadata[Constants.RavenReplicationSource] } }); metadata[Constants.RavenReplicationHistory] = history; } } metadata[Constants.RavenReplicationVersion] = RavenJToken.FromObject(ReplicationHiLo.NextId(Database)); metadata[Constants.RavenReplicationSource] = RavenJToken.FromObject(Database.TransactionalStorage.Id); } }
private RavenJObject ApplySingleScript(RavenJObject doc, ScriptedPatchRequest patch) { JintEngine ctx; try { ctx = scriptsCache.CheckoutScript(patch); } catch (NotSupportedException) { throw; } catch (JintException) { throw; } catch (Exception e) { throw new InvalidOperationException("Could not parse: " + Environment.NewLine + patch.Script, e); } loadDocumentStatic = loadDocument; try { foreach (var kvp in patch.Values) { if (kvp.Value is RavenJToken) { ctx.SetParameter(kvp.Key, ToJsInstance(ctx.Global, (RavenJToken)kvp.Value)); } else { var rjt = RavenJToken.FromObject(kvp.Value); var jsInstance = ToJsInstance(ctx.Global, rjt); ctx.SetParameter(kvp.Key, jsInstance); } } var jsObject = ToJsObject(ctx.Global, doc); ctx.CallFunction("ExecutePatchScript", jsObject); foreach (var kvp in patch.Values) { ctx.RemoveParameter(kvp.Key); } OutputLog(ctx); scriptsCache.CheckinScript(patch, ctx); return(ToRavenJObject(jsObject)); } catch (Exception errorEx) { OutputLog(ctx); var errorMsg = "Unable to execute JavaScript: " + Environment.NewLine + patch.Script; var error = errorEx as JsException; if (error != null) { errorMsg += Environment.NewLine + "Error: " + Environment.NewLine + string.Join(Environment.NewLine, error.Value); } if (Debug.Count != 0) { errorMsg += Environment.NewLine + "Debug information: " + Environment.NewLine + string.Join(Environment.NewLine, Debug); } throw new InvalidOperationException(errorMsg, errorEx); } finally { loadDocumentStatic = null; } }
private static void RemoveProperty(PatchRequest patchCmd, string propName, RavenJToken token, RavenJToken parent) { EnsurePreviousValueMatchCurrentValue(patchCmd, token); var o = parent as RavenJObject; if (o != null) { o.Remove(propName); } }
private void SetProperty(PatchRequest patchCmd, string propName, RavenJToken property) { EnsurePreviousValueMatchCurrentValue(patchCmd, property); document[propName] = patchCmd.Value; }
private RavenJToken ReadJsonInternal(Func <WebResponse> getResponse) { WebResponse response; try { response = getResponse(); sp.Stop(); } catch (WebException e) { sp.Stop(); var result = HandleErrors(e); if (result == null) { throw; } return(result); } catch (AggregateException e) { sp.Stop(); var we = e.ExtractSingleInnerException() as WebException; if (we == null) { throw; } var result = HandleErrors(we); if (result == null) { throw; } return(result); } ResponseHeaders = new NameValueCollection(response.Headers); ResponseStatusCode = ((HttpWebResponse)response).StatusCode; HandleReplicationStatusChanges(ResponseHeaders, primaryUrl, operationUrl); using (response) using (var responseStream = response.GetResponseStreamWithHttpDecompression()) { var data = RavenJToken.TryLoad(responseStream); if (Method == "GET" && ShouldCacheRequest) { factory.CacheResponse(Url, data, ResponseHeaders); } factory.InvokeLogRequest(owner, () => new RequestResultArgs { DurationMilliseconds = CalculateDuration(), Method = webRequest.Method, HttpResult = (int)ResponseStatusCode, Status = RequestStatus.SentToServer, Result = (data ?? "").ToString(), Url = webRequest.RequestUri.PathAndQuery, PostedData = postedData }); return(data); } }
public static void WriteJson(this IHttpContext context, object obj) { WriteJson(context, RavenJToken.FromObject(obj)); }
public async Task <HttpResponseMessage> DocReplicatePost() { const int BatchSize = 512; var src = GetQueryStringValue("from"); if (string.IsNullOrEmpty(src)) { return(GetEmptyMessage(HttpStatusCode.BadRequest)); } while (src.EndsWith("/")) { src = src.Substring(0, src.Length - 1); // remove last /, because that has special meaning for Raven } if (string.IsNullOrEmpty(src)) { return(GetEmptyMessage(HttpStatusCode.BadRequest)); } var array = await ReadJsonArrayAsync(); if (ReplicationTask != null) { ReplicationTask.HandleHeartbeat(src); } using (Database.DisableAllTriggersForCurrentThread()) { string lastEtag = Etag.Empty.ToString(); var docIndex = 0; while (docIndex < array.Length) { using (Database.DocumentLock.Lock()) { Database.TransactionalStorage.Batch(actions => { for (var j = 0; j < BatchSize && docIndex < array.Length; j++, docIndex++) { var document = (RavenJObject)array[docIndex]; var metadata = document.Value <RavenJObject>("@metadata"); if (metadata[Constants.RavenReplicationSource] == null) { // not sure why, old document from when the user didn't have replication // that we suddenly decided to replicate, choose the source for that metadata[Constants.RavenReplicationSource] = RavenJToken.FromObject(src); } lastEtag = metadata.Value <string>("@etag"); var id = metadata.Value <string>("@id"); document.Remove("@metadata"); ReplicateDocument(actions, id, metadata, document, src); } SaveReplicationSource(src, lastEtag); }); } } } return(GetEmptyMessage()); }
public async Task <HttpResponseMessage> AttachmentReplicatePost() { var src = GetQueryStringValue("from"); if (string.IsNullOrEmpty(src)) { return(GetEmptyMessage(HttpStatusCode.BadRequest)); } while (src.EndsWith("/")) { src = src.Substring(0, src.Length - 1); // remove last /, because that has special meaning for Raven } if (string.IsNullOrEmpty(src)) { return(GetEmptyMessage(HttpStatusCode.BadRequest)); } var array = await ReadBsonArrayAsync(); using (Database.DisableAllTriggersForCurrentThread()) { Database.TransactionalStorage.Batch(actions => { Etag lastEtag = Etag.Empty; foreach (RavenJObject attachment in array) { var metadata = attachment.Value <RavenJObject>("@metadata"); if (metadata[Constants.RavenReplicationSource] == null) { // not sure why, old attachment from when the user didn't have replication // that we suddenly decided to replicate, choose the source for that metadata[Constants.RavenReplicationSource] = RavenJToken.FromObject(src); } lastEtag = Etag.Parse(attachment.Value <byte[]>("@etag")); var id = attachment.Value <string>("@id"); ReplicateAttachment(actions, id, metadata, attachment.Value <byte[]>("data"), src); } var replicationDocKey = Constants.RavenReplicationSourcesBasePath + "/" + src; var replicationDocument = Database.Documents.Get(replicationDocKey, null); Etag lastDocId = null; if (replicationDocument != null) { lastDocId = replicationDocument.DataAsJson.JsonDeserialization <SourceReplicationInformation>(). LastDocumentEtag; } Guid serverInstanceId; if (Guid.TryParse(GetQueryStringValue("dbid"), out serverInstanceId) == false) { serverInstanceId = Database.TransactionalStorage.Id; } Database.Documents.Put(replicationDocKey, null, RavenJObject.FromObject(new SourceReplicationInformation { Source = src, LastDocumentEtag = lastDocId, LastAttachmentEtag = lastEtag, ServerInstanceId = serverInstanceId }), new RavenJObject(), null); }); } return(GetEmptyMessage()); }
public void Write(RavenJToken ravenJToken) { postedToken = ravenJToken; WriteToken(WebRequest); }
public static void SetParamValue(DbParameter colParam, RavenJToken val, List <Func <DbParameter, String, Boolean> > stringParsers) { if (val == null) { colParam.Value = DBNull.Value; } else { switch (val.Type) { case JTokenType.None: case JTokenType.Uri: case JTokenType.Raw: case JTokenType.Array: colParam.Value = val.Value <string>(); return; case JTokenType.Object: var objectValue = val as RavenJObject; if (objectValue != null && objectValue.Keys.Count >= 2 && objectValue.ContainsKey("Type") && objectValue.ContainsKey("Value")) { var dbType = objectValue["Type"].Value <string>(); var fieldValue = objectValue["Value"].Value <string>(); colParam.DbType = (DbType)Enum.Parse(typeof(DbType), dbType, false); colParam.Value = fieldValue; if (objectValue.ContainsKey("Size")) { var size = objectValue["Size"].Value <int>(); colParam.Size = size; } return; } if (objectValue != null && objectValue.Keys.Count >= 4 && objectValue.ContainsKey("EnumType") && objectValue.ContainsKey("EnumValue") && objectValue.ContainsKey("EnumProperty") && (objectValue.ContainsKey("Value") || objectValue.ContainsKey("Values"))) { var enumType = Type.GetType(objectValue["EnumType"].Value <string>(), false); if (enumType == null) { throw new InvalidOperationException(string.Format("Couldn't find type '{0}'.", objectValue["EnumType"])); } var enumStringvalue = objectValue["EnumValue"].Value <string>(); object enumValue; if (enumStringvalue.Contains("|")) { var splitvalue = enumStringvalue.Split('|').Select(e => (int)Enum.Parse(enumType, e.Trim())); enumValue = splitvalue.Aggregate((a, b) => a | b); } else { enumValue = Enum.Parse(enumType, enumStringvalue); } var property = colParam.GetType().GetProperty(objectValue["EnumProperty"].Value <string>()); if (property == null) { throw new InvalidOperationException(string.Format("Missing property '{0}' on type '{1}' of parameter.", objectValue["EnumProperty"], colParam.GetType().FullName)); } if (objectValue.ContainsKey("Value")) { colParam.Value = objectValue["Value"].Value <object>(); } else if (objectValue.ContainsKey("Values")) { colParam.Value = objectValue["Values"].Values <object>().ToArray(); } property.SetValue(colParam, enumValue); if (objectValue.ContainsKey("Size")) { var size = objectValue["Size"].Value <int>(); colParam.Size = size; } return; } else { colParam.Value = val.Value <string>(); return; } case JTokenType.String: var value = val.Value <string>(); if (value.Length > 0 && stringParsers != null) { foreach (var parser in stringParsers) { if (parser(colParam, value)) { return; } } } colParam.Value = value; return; case JTokenType.Integer: case JTokenType.Date: case JTokenType.Bytes: case JTokenType.Guid: case JTokenType.Boolean: case JTokenType.TimeSpan: case JTokenType.Float: colParam.Value = val.Value <object>(); return; case JTokenType.Null: case JTokenType.Undefined: colParam.Value = DBNull.Value; return; default: throw new InvalidOperationException("Cannot understand how to save " + val.Type + " for " + colParam.ParameterName); } } }
public override void Respond(IHttpContext context) { var src = context.Request.QueryString["from"]; if (string.IsNullOrEmpty(src)) { context.SetStatusToBadRequest(); return; } while (src.EndsWith("/")) { src = src.Substring(0, src.Length - 1); // remove last /, because that has special meaning for Raven } if (string.IsNullOrEmpty(src)) { context.SetStatusToBadRequest(); return; } var array = context.ReadJsonArray(); if (ReplicationTask != null) { ReplicationTask.HandleHeartbeat(src); } using (Database.DisableAllTriggersForCurrentThread()) { Database.TransactionalStorage.Batch(actions => { string lastEtag = Guid.Empty.ToString(); foreach (RavenJObject document in array) { var metadata = document.Value <RavenJObject>("@metadata"); if (metadata[Constants.RavenReplicationSource] == null) { // not sure why, old document from when the user didn't have replication // that we suddenly decided to replicate, choose the source for that metadata[Constants.RavenReplicationSource] = RavenJToken.FromObject(src); } lastEtag = metadata.Value <string>("@etag"); var id = metadata.Value <string>("@id"); document.Remove("@metadata"); ReplicateDocument(actions, id, metadata, document, src); } var replicationDocKey = Constants.RavenReplicationSourcesBasePath + "/" + src; var replicationDocument = Database.Get(replicationDocKey, null); var lastAttachmentId = Guid.Empty; if (replicationDocument != null) { lastAttachmentId = replicationDocument.DataAsJson.JsonDeserialization <SourceReplicationInformation>(). LastAttachmentEtag; } Guid serverInstanceId; if (Guid.TryParse(context.Request.QueryString["dbid"], out serverInstanceId) == false) { serverInstanceId = Database.TransactionalStorage.Id; } Database.Put(replicationDocKey, null, RavenJObject.FromObject(new SourceReplicationInformation { Source = src, LastDocumentEtag = new Guid(lastEtag), LastAttachmentEtag = lastAttachmentId, ServerInstanceId = serverInstanceId }), new RavenJObject(), null); }); } }
/// <summary> /// This method generate the fields for indexing documents in lucene from the values. /// Given a name and a value, it has the following behavior: /// * If the value is enumerable, index all the items in the enumerable under the same field name /// * If the value is null, create a single field with the supplied name with the unanalyzed value 'NULL_VALUE' /// * If the value is string or was set to not analyzed, create a single field with the supplied name /// * If the value is date, create a single field with millisecond precision with the supplied name /// * If the value is numeric (int, long, double, decimal, or float) will create two fields: /// 1. with the supplied name, containing the numeric value as an unanalyzed string - useful for direct queries /// 2. with the name: name +'_Range', containing the numeric value in a form that allows range queries /// </summary> public IEnumerable <AbstractField> CreateFields(string name, object value, Field.Store defaultStorage, bool nestedArray = false, Field.TermVector defaultTermVector = Field.TermVector.NO) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException("Field must be not null, not empty and cannot contain whitespace", "name"); } if (char.IsLetter(name[0]) == false && name[0] != '_') { name = "_" + name; } var fieldIndexingOptions = indexDefinition.GetIndex(name, null); var storage = indexDefinition.GetStorage(name, defaultStorage); var termVector = indexDefinition.GetTermVector(name, defaultTermVector); if (value == null) { yield return(CreateFieldWithCaching(name, Constants.NullValue, storage, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); yield break; } if (Equals(value, string.Empty)) { yield return(CreateFieldWithCaching(name, Constants.EmptyString, storage, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); yield break; } if (value is DynamicNullObject) { if (((DynamicNullObject)value).IsExplicitNull) { var sortOptions = indexDefinition.GetSortOption(name); if (sortOptions != null && sortOptions.Value != SortOptions.None) { yield break; // we don't emit null for sorting } yield return(CreateFieldWithCaching(name, Constants.NullValue, storage, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); } yield break; } var boostedValue = value as BoostedValue; if (boostedValue != null) { foreach (var field in CreateFields(name, boostedValue.Value, storage, false, termVector)) { field.Boost = boostedValue.Boost; field.OmitNorms = false; yield return(field); } yield break; } var abstractField = value as AbstractField; if (abstractField != null) { yield return(abstractField); yield break; } var bytes = value as byte[]; if (bytes != null) { yield return(CreateBinaryFieldWithCaching(name, bytes, storage, fieldIndexingOptions, termVector)); yield break; } var itemsToIndex = value as IEnumerable; if (itemsToIndex != null && ShouldTreatAsEnumerable(itemsToIndex)) { var sentArrayField = false; int count = 1; foreach (var itemToIndex in itemsToIndex) { if (nestedArray == false && !Equals(storage, Field.Store.NO) && sentArrayField == false) { sentArrayField = true; yield return(new Field(name + "_IsArray", "true", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); } if (CanCreateFieldsForNestedArray(itemToIndex, fieldIndexingOptions)) { multipleItemsSameFieldCount.Add(count++); foreach (var field in CreateFields(name, itemToIndex, storage, nestedArray: true)) { yield return(field); } multipleItemsSameFieldCount.RemoveAt(multipleItemsSameFieldCount.Count - 1); } } yield break; } if (Equals(fieldIndexingOptions, Field.Index.NOT_ANALYZED) || Equals(fieldIndexingOptions, Field.Index.NOT_ANALYZED_NO_NORMS)) // explicitly not analyzed { // date time, time span and date time offset have the same structure fo analyzed and not analyzed. if (!(value is DateTime) && !(value is DateTimeOffset) && !(value is TimeSpan)) { yield return(CreateFieldWithCaching(name, value.ToString(), storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); yield break; } } if (value is string) { var index = indexDefinition.GetIndex(name, Field.Index.ANALYZED); yield return(CreateFieldWithCaching(name, value.ToString(), storage, index, termVector)); yield break; } if (value is TimeSpan) { var val = (TimeSpan)value; yield return(CreateFieldWithCaching(name, val.ToString("c", CultureInfo.InvariantCulture), storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is DateTime) { var val = (DateTime)value; var dateAsString = val.ToString(Default.DateTimeFormatsToWrite); if (val.Kind == DateTimeKind.Utc) { dateAsString += "Z"; } yield return(CreateFieldWithCaching(name, dateAsString, storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is DateTimeOffset) { var val = (DateTimeOffset)value; string dtoStr; if (Equals(fieldIndexingOptions, Field.Index.NOT_ANALYZED) || Equals(fieldIndexingOptions, Field.Index.NOT_ANALYZED_NO_NORMS)) { dtoStr = val.ToString(Default.DateTimeOffsetFormatsToWrite); } else { dtoStr = val.UtcDateTime.ToString(Default.DateTimeFormatsToWrite) + "Z"; } yield return(CreateFieldWithCaching(name, dtoStr, storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is bool) { yield return(new Field(name, ((bool)value) ? "true" : "false", storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is decimal) { var d = (decimal)value; var s = d.ToString(CultureInfo.InvariantCulture); if (s.Contains('.')) { s = s.TrimEnd('0'); if (s.EndsWith(".")) { s = s.Substring(0, s.Length - 1); } } yield return(CreateFieldWithCaching(name, s, storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is IConvertible) // we need this to store numbers in invariant format, so JSON could read them { var convert = ((IConvertible)value); yield return(CreateFieldWithCaching(name, convert.ToString(CultureInfo.InvariantCulture), storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is IDynamicJsonObject) { var inner = ((IDynamicJsonObject)value).Inner; yield return(CreateFieldWithCaching(name + "_ConvertToJson", "true", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); yield return(CreateFieldWithCaching(name, inner.ToString(Formatting.None), storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else { yield return(CreateFieldWithCaching(name + "_ConvertToJson", "true", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); yield return(CreateFieldWithCaching(name, RavenJToken.FromObject(value).ToString(Formatting.None), storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } foreach (var numericField in CreateNumericFieldWithCaching(name, value, storage, termVector)) { yield return(numericField); } }
private static void EnsurePreviousValueMatchCurrentValue(PatchRequest patchCmd, RavenJToken property) { var prevVal = patchCmd.PrevVal; if (prevVal == null) { return; } switch (prevVal.Type) { case JTokenType.Undefined: if (property != null) { throw new ConcurrencyException(); } break; default: if (property == null) { throw new ConcurrencyException(); } if (RavenJToken.DeepEquals(property, prevVal) == false) { throw new ConcurrencyException(); } break; } }
public Task <HttpResponseMessage> ExecuteRawResponseAsync(RavenJToken token) { return(ExecuteRawResponseInternalAsync(new JsonContent(token))); }
/// <summary> /// Serves as a hash function for a particular type. /// </summary> /// <returns> /// A hash code for the current <see cref="T:System.Object"/>. /// </returns> /// <filterpriority>2</filterpriority> public override int GetHashCode() { return(RavenJToken.GetDeepHashCode(inner)); }
private IEnumerable <AbstractField> CreateRegularFields(string name, object value, Field.Store defaultStorage, bool nestedArray = false, Field.TermVector defaultTermVector = Field.TermVector.NO, Field.Index?analyzed = null) { var fieldIndexingOptions = analyzed ?? indexDefinition.GetIndex(name, null); var storage = indexDefinition.GetStorage(name, defaultStorage); var termVector = indexDefinition.GetTermVector(name, defaultTermVector); if (fieldIndexingOptions == Field.Index.NO && storage == Field.Store.NO && termVector == Field.TermVector.NO) { yield break; } if (fieldIndexingOptions == Field.Index.NO && storage == Field.Store.NO) { fieldIndexingOptions = Field.Index.ANALYZED; // we have some sort of term vector, forcing index to be analyzed, then. } if (value == null) { yield return(CreateFieldWithCaching(name, Constants.NullValue, storage, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); yield break; } CheckIfSortOptionsAndInputTypeMatch(name, value); var attachmentFoIndexing = value as AttachmentForIndexing; if (attachmentFoIndexing != null) { if (database == null) { throw new InvalidOperationException( "Cannot use attachment for indexing if the database parameter is null. This is probably a RavenDB bug"); } var attachment = database.Attachments.GetStatic(attachmentFoIndexing.Key); if (attachment == null) { yield break; } var fieldWithCaching = CreateFieldWithCaching(name, string.Empty, Field.Store.NO, fieldIndexingOptions, termVector); if (database.TransactionalStorage.IsAlreadyInBatch) { var streamReader = new StreamReader(attachment.Data()); fieldWithCaching.SetValue(streamReader); } else { // we are not in batch operation so we have to create it be able to read attachment's data database.TransactionalStorage.Batch(accessor => { var streamReader = new StreamReader(attachment.Data()); // we have to read it into memory because we after exiting the batch an attachment's data stream will be closed fieldWithCaching.SetValue(streamReader.ReadToEnd()); }); } yield return(fieldWithCaching); yield break; } if (Equals(value, string.Empty)) { yield return(CreateFieldWithCaching(name, Constants.EmptyString, storage, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); yield break; } var dynamicNullObject = value as DynamicNullObject; if (ReferenceEquals(dynamicNullObject, null) == false) { if (dynamicNullObject.IsExplicitNull) { var sortOptions = indexDefinition.GetSortOption(name, query: null); if (sortOptions == null || sortOptions.Value == SortOptions.String || sortOptions.Value == SortOptions.None || sortOptions.Value == SortOptions.StringVal || sortOptions.Value == SortOptions.Custom) { yield return(CreateFieldWithCaching(name, Constants.NullValue, storage, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); } foreach (var field in CreateNumericFieldWithCaching(name, GetNullValueForSorting(sortOptions), storage, termVector)) { yield return(field); } } yield break; } var boostedValue = value as BoostedValue; if (boostedValue != null) { foreach (var field in CreateFields(name, boostedValue.Value, storage, false, termVector)) { field.Boost = boostedValue.Boost; field.OmitNorms = false; yield return(field); } yield break; } var abstractField = value as AbstractField; if (abstractField != null) { yield return(abstractField); yield break; } var bytes = value as byte[]; if (bytes != null) { yield return(CreateBinaryFieldWithCaching(name, bytes, storage, fieldIndexingOptions, termVector)); yield break; } var itemsToIndex = value as IEnumerable; if (itemsToIndex != null && ShouldTreatAsEnumerable(itemsToIndex)) { int count = 1; if (nestedArray == false) { yield return(new Field(name + "_IsArray", "true", storage, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); } foreach (var itemToIndex in itemsToIndex) { if (!CanCreateFieldsForNestedArray(itemToIndex, fieldIndexingOptions)) { continue; } multipleItemsSameFieldCount.Add(count++); foreach (var field in CreateFields(name, itemToIndex, storage, nestedArray: true, defaultTermVector: defaultTermVector, analyzed: analyzed)) { yield return(field); } multipleItemsSameFieldCount.RemoveAt(multipleItemsSameFieldCount.Count - 1); } yield break; } if (Equals(fieldIndexingOptions, Field.Index.NOT_ANALYZED) || Equals(fieldIndexingOptions, Field.Index.NOT_ANALYZED_NO_NORMS))// explicitly not analyzed { // date time, time span and date time offset have the same structure fo analyzed and not analyzed. if (!(value is DateTime) && !(value is DateTimeOffset) && !(value is TimeSpan)) { yield return(CreateFieldWithCaching(name, value.ToString(), storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); yield break; } } if (value is string) { var index = indexDefinition.GetIndex(name, Field.Index.ANALYZED); yield return(CreateFieldWithCaching(name, value.ToString(), storage, index, termVector)); yield break; } if (value is TimeSpan) { var val = (TimeSpan)value; yield return(CreateFieldWithCaching(name, val.ToString("c", CultureInfo.InvariantCulture), storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is DateTime) { var val = (DateTime)value; var dateAsString = val.GetDefaultRavenFormat(); if (val.Kind == DateTimeKind.Utc) { dateAsString += "Z"; } yield return(CreateFieldWithCaching(name, dateAsString, storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is DateTimeOffset) { var val = (DateTimeOffset)value; string dtoStr; if (Equals(fieldIndexingOptions, Field.Index.NOT_ANALYZED) || Equals(fieldIndexingOptions, Field.Index.NOT_ANALYZED_NO_NORMS)) { dtoStr = val.ToString(Default.DateTimeOffsetFormatsToWrite, CultureInfo.InvariantCulture); } else { dtoStr = val.UtcDateTime.GetDefaultRavenFormat(true); } yield return(CreateFieldWithCaching(name, dtoStr, storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is bool) { yield return(new Field(name, ((bool)value) ? "true" : "false", storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is double) { var d = (double)value; yield return(CreateFieldWithCaching(name, d.ToString("r", CultureInfo.InvariantCulture), storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is decimal) { var d = (decimal)value; var s = d.ToString(CultureInfo.InvariantCulture); if (s.Contains('.')) { s = s.TrimEnd('0'); if (s.EndsWith(".")) { s = s.Substring(0, s.Length - 1); } } yield return(CreateFieldWithCaching(name, s, storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is Enum) { yield return(CreateFieldWithCaching(name, value.ToString(), storage, indexDefinition.GetIndex(name, Field.Index.ANALYZED_NO_NORMS), termVector)); } else if (value is IConvertible) // we need this to store numbers in invariant format, so JSON could read them { var convert = ((IConvertible)value); yield return(CreateFieldWithCaching(name, convert.ToString(CultureInfo.InvariantCulture), storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else if (value is IDynamicJsonObject) { var inner = ((IDynamicJsonObject)value).Inner; yield return(CreateFieldWithCaching(name + "_ConvertToJson", "true", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); yield return(CreateFieldWithCaching(name, inner.ToString(Formatting.None), storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } else { var jsonVal = RavenJToken.FromObject(value).ToString(Formatting.None); if (jsonVal.StartsWith("{") || jsonVal.StartsWith("[")) { yield return(CreateFieldWithCaching(name + "_ConvertToJson", "true", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); } else if (jsonVal.StartsWith("\"") && jsonVal.EndsWith("\"") && jsonVal.Length > 1) { jsonVal = jsonVal.Substring(1, jsonVal.Length - 2); } yield return(CreateFieldWithCaching(name, jsonVal, storage, indexDefinition.GetIndex(name, Field.Index.NOT_ANALYZED_NO_NORMS), termVector)); } foreach (var numericField in CreateNumericFieldWithCaching(name, value, storage, termVector)) { yield return(numericField); } }
public Operation(long id, RavenJToken state) { this.id = id; this.state = state; this.done = true; }
public void AddQueryInput(string name, RavenJToken value) { AddTransformerParameter(name, value); }
public JsonContent JsonContent(RavenJToken data = null) { return(new JsonContent(data) .WithRequest(InnerRequest)); }
public void AddTransformerParameter(string name, RavenJToken value) { transformerParamaters[name] = value; }
public bool UpdateKey(RavenJToken key) { return(UpdateKey(key, txId.Value)); }
public void WriteBson(RavenJToken ravenJToken) { writeBson = true; postedToken = ravenJToken; WriteToken(WebRequest); }
public bool Put(RavenJToken key, byte[] value) { return(Put(key, value, txId.Value)); }
public override int GetHashCode(RavenJToken obj) { var localObj = obj.Type == JTokenType.Object ? modifier(obj) : obj; return(base.GetHashCode(localObj)); }