public void AddReduce(string reduceKeyHash, object reduceObject) { if (_reduceDocuments.TryGetValue(reduceKeyHash, out var outputs) == false) { outputs = new List <BlittableJsonReaderObject>(1); _reduceDocuments.Add(reduceKeyHash, outputs); } var djv = new DynamicJsonValue(); if (_index.OutputReduceToCollectionPropertyAccessor == null) { _index.OutputReduceToCollectionPropertyAccessor = PropertyAccessor.Create(reduceObject.GetType(), reduceObject); } foreach (var property in _index.OutputReduceToCollectionPropertyAccessor.PropertiesInOrder) { var value = property.Value.GetValue(reduceObject); djv[property.Key] = TypeConverter.ToBlittableSupportedType(value); } djv[Constants.Documents.Metadata.Key] = new DynamicJsonValue { [Constants.Documents.Metadata.Collection] = _outputReduceToCollection }; var doc = _indexContext.ReadObject(djv, "output-of-reduce-doc", BlittableJsonDocumentBuilder.UsageMode.ToDisk); outputs.Add(doc); }
public void AddReduce(string reduceKeyHash, object reduceObject) { var key = _outputReduceToCollection + "/" + reduceKeyHash; var djv = new DynamicJsonValue(); if (_index.OutputReduceToCollectionPropertyAccessor == null) { _index.OutputReduceToCollectionPropertyAccessor = PropertyAccessor.Create(reduceObject.GetType()); } foreach (var property in _index.OutputReduceToCollectionPropertyAccessor.PropertiesInOrder) { var value = property.Value.GetValue(reduceObject); djv[property.Key] = TypeConverter.ToBlittableSupportedType(value); } djv[Constants.Documents.Metadata.Key] = new DynamicJsonValue { [Constants.Documents.Metadata.Collection] = _outputReduceToCollection }; _reduceDocuments.Add(new OutputReduceDocument { Key = key, Document = _jsonContext.ReadObject(djv, key, BlittableJsonDocumentBuilder.UsageMode.ToDisk) }); }
public static PropertyAccessor GetPropertyAccessorForMapReduceOutput(object value, HashSet <CompiledIndexField> groupByFields) { var type = value.GetType(); if (value is Dictionary <string, object> ) // don't use cache when using dictionaries { return(PropertyAccessor.Create(type, value)); } return(PropertyAccessorCache.GetOrAdd(type, x => PropertyAccessor.CreateMapReduceOutputAccessor(type, value, groupByFields))); }
public static PropertyAccessor GetPropertyAccessor(object value) { var type = value.GetType(); if (value is Dictionary <string, object> ) // don't use cache when using dictionaries { return(PropertyAccessor.Create(type, value)); } return(PropertyAccessorCache.GetOrAdd(type, x => PropertyAccessor.Create(type, value))); }
public static void PopulateFromDataReader <T>(this T obj, IDataReader reader, bool tryRead) where T : class, new() { if (obj == null) { throw new InvalidOperationException( "Cannot call PopulateFromDataReader<T> on a null object - initialise it before populating."); } if (!tryRead || reader.Read()) { for (int i = 0; i < reader.FieldCount; i++) { string name = reader.GetName(i); KeyValuePair <Type, string> key = new KeyValuePair <Type, string>(typeof(T), name); object value = reader[i].IsDbNull() ? null : reader[i]; PropertyInfo propertyInfo = propertyCache[key]; if (propertyInfo != null) { try { PropertyAccessor.Create(propertyInfo).Set(obj, value); } catch (Exception ex) { throw new InvalidOperationException( string.Format("Failed to populate property {0} of type {1} with value of type {2}", name, propertyInfo.PropertyType, value != null ? value.GetType().Name : "null"), ex); } } else { try { FieldInfo fieldInfo = fieldCache[key]; if (fieldInfo != null) { fieldInfo.SetValue(obj, value); } } catch (ArgumentException ex) { throw new InvalidOperationException( string.Format("Failed to populate property or field {0} with value of type {1}", name, value != null ? value.GetType().Name : "null"), ex); } } } } }
public InvokeTypeInfo( TypeAnalysis typeAnalysis) : base( typeAnalysis.name, typeAnalysis.level, typeAnalysis.opcode, typeAnalysis.keywords, typeAnalysis.tags) { if (typeAnalysis.properties.Length != 0) { this.properties = typeAnalysis.properties; this.accessors = new PropertyAccessor <ContainerType> [this.properties.Length]; for (int i = 0; i < this.accessors.Length; i++) { this.accessors[i] = PropertyAccessor <ContainerType> .Create(this.properties[i]); } } }
protected override AggregationResult AggregateOn(List <BlittableJsonReaderObject> aggregationBatch, TransactionOperationContext indexContext, CancellationToken token) { _blittableToDynamicWrapper.InitializeForEnumeration(aggregationBatch); var resultObjects = new List <object>(); foreach (var output in _reducingFunc(_blittableToDynamicWrapper)) { token.ThrowIfCancellationRequested(); if (_propertyAccessor == null) { _propertyAccessor = PropertyAccessor.Create(output.GetType(), output); } resultObjects.Add(output); } return(new AggregatedAnonymousObjects(resultObjects, _propertyAccessor, indexContext)); }
protected override AggregationResult AggregateOn(List <BlittableJsonReaderObject> aggregationBatch, TransactionOperationContext indexContext, IndexingStatsScope stats, CancellationToken token) { _blittableToDynamicWrapper.InitializeForEnumeration(aggregationBatch); var resultObjects = new List <object>(); var indexingFunctionType = _indexType.IsJavaScript() ? IndexingOperation.Map.Jint : IndexingOperation.Map.Linq; var funcStats = stats?.For(indexingFunctionType, start: false); foreach (var output in new TimeCountingEnumerable(_reducingFunc(_blittableToDynamicWrapper), funcStats)) { token.ThrowIfCancellationRequested(); if (_propertyAccessor == null) { _propertyAccessor = PropertyAccessor.Create(output.GetType()); } resultObjects.Add(output); } return(new AggregatedAnonymousObjects(resultObjects, _propertyAccessor, indexContext)); }
public bool MoveNext() { if (_enumerator.MoveNext() == false) { return(false); } var document = _enumerator.Current; using (_createBlittableResult.Start()) { var accessor = _parent._propertyAccessor ?? (_parent._propertyAccessor = PropertyAccessor.Create(document.GetType())); var mapResult = new DynamicJsonValue(); _reduceKeyProcessor.Reset(); foreach (var field in accessor.PropertiesInOrder) { var value = field.Value.GetValue(document); var blittableValue = TypeConverter.ToBlittableSupportedType(value); mapResult[field.Key] = blittableValue; if (_groupByFields.Contains(field.Key)) { _reduceKeyProcessor.Process(_parent._indexContext.Allocator, blittableValue); } } var reduceHashKey = _reduceKeyProcessor.Hash; Current.Data = _parent._indexContext.ReadObject(mapResult, "map-result"); Current.ReduceKeyHash = reduceHashKey; } return(true); }
internal static DataTable ToDataTable <U>(IEnumerable <U> collection) { string collectionTypeName; Type tableType = typeof(U); if (collection == null) { throw new QueryTalkException("ToDataTable<T>", QueryTalkExceptionType.CollectionNullOrEmpty, String.Format("data class = {0}", tableType), Text.Method.ToDataTable); } collectionTypeName = collection.GetType().Name; if (collection is Wall.IResult) { collectionTypeName = Text.Class.ResultSet; } if (collectionTypeName == Text.Class.ResultSet) { var resultSet = (ResultSet <U>)collection; if (resultSet.DataTable != null) { return(resultSet.DataTable); } // check dynamic - not convertable if (tableType == typeof(System.Object)) { if (collection.Count() == 0) { throw new QueryTalkException("ResultSet.getTableType", QueryTalkExceptionType.EmptyResultset, "table type = dynamic", Text.Method.ToDataTable); } // infer type from the item using (var enumerator = collection.GetEnumerator()) { enumerator.MoveNext(); tableType = enumerator.Current.GetType(); } } } DataTable dataTable = new DataTable(); dataTable.Locale = System.Globalization.CultureInfo.InvariantCulture; // always build new getters (not using cache) var getters = new List <IPropertyAccessor>(); var props = tableType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) .Where(prop => prop.GetGetMethod() != null) .ToArray(); PropertyInfo[] properties; if (tableType.IsDbRow()) { var node = DbMapping.GetNodeMap(tableType); var propsByDatabaseOrder = new List <PropertyInfo>(); foreach (var column in node.SortedColumnsByDatabaseOrder) { var prop = props.Where(a => a.Name.EqualsCS(column.ClrName)).Select(a => a).FirstOrDefault(); if (prop != null) { propsByDatabaseOrder.Add(prop); } } properties = propsByDatabaseOrder.ToArray(); } else { properties = props; } if (properties.Length == 0) { throw new QueryTalkException("ResultSet.ToDataTable", QueryTalkExceptionType.InvalidDataClass, String.Format("data class = {0}", tableType), Text.Method.ToDataTable); } int numberOfPropertiesUsed = 0; foreach (PropertyInfo property in properties) { Type clrType; QueryTalkException exception; var clrTypeMatch = Mapping.CheckClrCompliance(property.PropertyType, out clrType, out exception); if (clrTypeMatch == Mapping.ClrTypeMatch.NodeMatch) { continue; } if (clrTypeMatch != Mapping.ClrTypeMatch.ClrMatch) { ThrowNotClrCompliantException(exception, property.PropertyType); } dataTable.Columns.Add(property.Name, clrType); getters.Add(PropertyAccessor.Create(tableType, property)); ++numberOfPropertiesUsed; } foreach (U item in collection) { DataRow row = dataTable.NewRow(); for (int i = 0; i < numberOfPropertiesUsed; i++) { row[i] = getters[i].GetValue(item) ?? DBNull.Value; } dataTable.Rows.Add(row); } return(dataTable); }