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));
}
