public override Expression CompileBulkImporter(EnumStorage enumStorage, Expression writer, ParameterExpression document, ParameterExpression alias, ParameterExpression serializer) { var method = writeMethod.MakeGenericMethod(typeof(string)); var dbType = Expression.Constant(DbType); return Expression.Call(writer, method, alias, dbType); }
public EnumIsOneOfWhereFragment(object values, EnumStorage enumStorage, string locator) { var array = values.As<Array>(); if (enumStorage == EnumStorage.AsInteger) { var numbers = new int[array.Length]; for (int i = 0; i < array.Length; i++) { numbers[i] = array.GetValue(i).As<int>(); } _values = numbers; _dbType = NpgsqlDbType.Integer | NpgsqlDbType.Array; } else { var strings = new string[array.Length]; for (int i = 0; i < array.Length; i++) { strings[i] = array.GetValue(i).ToString(); } _values = strings; _dbType = NpgsqlDbType.Varchar | NpgsqlDbType.Array; } _locator = locator; }
public override Expression CompileUpdateExpression(EnumStorage enumStorage, ParameterExpression call, ParameterExpression doc, ParameterExpression updateBatch, ParameterExpression mapping, ParameterExpression currentVersion, ParameterExpression newVersion) { var argName = Expression.Constant(Arg); var serializer = Expression.Call(updateBatch, _serializer); var json = Expression.Call(serializer, _tojson, doc); return Expression.Call(call, _paramMethod, argName, json, Expression.Constant(NpgsqlDbType.Jsonb)); }
public override Expression CompileUpdateExpression(EnumStorage enumStorage, ParameterExpression call, ParameterExpression doc, ParameterExpression updateBatch, ParameterExpression mapping, ParameterExpression currentVersion, ParameterExpression newVersion) { var getType = Expression.Call(doc, _getType); var getName = Expression.Call(getType, _fullName); var argName = Expression.Constant(Arg); var dbType = Expression.Constant(DbType); return Expression.Call(call, _paramMethod, argName, getName, dbType); }
public override Expression CompileUpdateExpression(EnumStorage enumStorage, ParameterExpression call, ParameterExpression doc, ParameterExpression updateBatch, ParameterExpression mapping, ParameterExpression currentVersion, ParameterExpression newVersion) { var argName = Expression.Constant(Arg); var dbType = Expression.Constant(NpgsqlDbType.Varchar); var type = Expression.Call(doc, _getType); var alias = Expression.Call(mapping, _getAlias, type); return Expression.Call(call, _paramMethod, argName, alias, dbType); }
public virtual Expression CompileUpdateExpression(EnumStorage enumStorage, ParameterExpression call, ParameterExpression doc, ParameterExpression updateBatch, ParameterExpression mapping, ParameterExpression currentVersion, ParameterExpression newVersion) { var argName = Expression.Constant(Arg); var memberType = Members.Last().GetMemberType(); var body = LambdaBuilder.ToExpression(enumStorage, Members, doc); if (!memberType.GetTypeInfo().IsClass) { body = Expression.Convert(body, typeof(object)); } return Expression.Call(call, _paramMethod, argName, body, Expression.Constant(DbType)); }
public void can_build_getter_for_enum_expression(EnumStorage enumStorage) { Expression <Func <Target, Colors> > expression = t => t.Color; var visitor = new FindMembers(); visitor.Visit(expression); var members = visitor.Members.ToArray(); var getter = LambdaBuilder.Getter <Target, Colors>(enumStorage, members); var target = new Target { Inner = new Target { Color = Colors.Blue } }; getter(target).ShouldBe(target.Color); }
public static DuplicatedField For <T>(EnumStorage enumStorage, Expression <Func <T, object> > expression, bool useTimestampWithoutTimeZoneForDateTime = true, string pgType = null) { var accessor = ReflectionHelper.GetAccessor(expression); // Hokey, but it's just for testing for now. if (accessor is PropertyChain) { throw new NotSupportedException("Not yet supporting deep properties yet. Soon."); } var duplicate = new DuplicatedField(enumStorage, new MemberInfo[] { accessor.InnerProperty }, useTimestampWithoutTimeZoneForDateTime); if (pgType.IsNotEmpty()) { duplicate.PgType = pgType; } return(duplicate); }
public JsonLocatorField(string dataLocator, StoreOptions options, EnumStorage enumStyle, Casing casing, MemberInfo member) : base(enumStyle, member) { var memberType = member.GetMemberType(); var memberName = member.Name.FormatCase(casing); var isStringEnum = memberType.IsEnum && enumStyle == EnumStorage.AsString; if (memberType == typeof(string) || isStringEnum) { SqlLocator = $"{dataLocator} ->> '{memberName}'"; } else if (TypeMappings.TimespanTypes.Contains(memberType)) { SqlLocator = $"{options.DatabaseSchemaName}.mt_immutable_timestamp({dataLocator} ->> '{memberName}')"; SelectionLocator = $"CAST({dataLocator} ->> '{memberName}' as {PgType})"; } else if (TypeMappings.TimespanZTypes.Contains(memberType)) { SqlLocator = $"{options.DatabaseSchemaName}.mt_immutable_timestamptz({dataLocator} ->> '{memberName}')"; SelectionLocator = $"CAST({dataLocator} ->> '{memberName}' as {PgType})"; } else if (memberType.IsArray) { SqlLocator = $"CAST({dataLocator} ->> '{memberName}' as jsonb)"; } else { SqlLocator = $"CAST({dataLocator} ->> '{memberName}' as {PgType})"; } if (isStringEnum) { _parseObject = expression => { var raw = expression.Value(); return(Enum.GetName(MemberType, raw)); }; } if (SelectionLocator.IsEmpty()) { SelectionLocator = SqlLocator; } }
public virtual Expression CompileBulkImporter(EnumStorage enumStorage, Expression writer, ParameterExpression document, ParameterExpression alias, ParameterExpression serializer) { var memberType = Members.Last().GetMemberType(); var value = LambdaBuilder.ToExpression(enumStorage, Members, document); if (memberType.IsEnum) { memberType = typeof(string); value = LambdaBuilder.ToExpression(EnumStorage.AsString, Members, document); } var method = writeMethod.MakeGenericMethod(memberType); var dbType = Expression.Constant(DbType); return(Expression.Call(writer, method, value, dbType)); }
public virtual Expression CompileBulkImporter(EnumStorage enumStorage, Expression writer, ParameterExpression document, ParameterExpression alias, ParameterExpression serializer) { var memberType = Members.Last().GetMemberType(); var value = LambdaBuilder.ToExpression(enumStorage, Members, document); if (memberType.GetTypeInfo().IsEnum) { memberType = typeof(string); value = LambdaBuilder.ToExpression(EnumStorage.AsString, Members, document); } var method = writeMethod.MakeGenericMethod(memberType); var dbType = Expression.Constant(DbType); return Expression.Call(writer, method, value, dbType); }
public DuplicatedField(EnumStorage enumStorage, MemberInfo[] memberPath) : base(enumStorage, memberPath) { ColumnName = MemberName.ToTableAlias(); if (MemberType.IsEnum) { if (enumStorage == EnumStorage.AsString) { DbType = NpgsqlDbType.Varchar; PgType = "varchar"; _parseObject = expression => { var raw = expression.Value(); return(Enum.GetName(MemberType, raw)); }; } else { DbType = NpgsqlDbType.Integer; PgType = "integer"; } } else if (MemberType.IsDateTime()) { PgType = "timestamp without time zone"; DbType = NpgsqlDbType.Timestamp; } else if (MemberType.IsDateTime()) { PgType = "timestamp without time zone"; DbType = NpgsqlDbType.Timestamp; } else if (MemberType == typeof(DateTimeOffset) || MemberType == typeof(DateTimeOffset?)) { PgType = "timestamp with time zone"; DbType = NpgsqlDbType.TimestampTz; } else { DbType = TypeMappings.ToDbType(MemberType); } }
public DuplicatedField(EnumStorage enumStorage, IField innerField, bool useTimestampWithoutTimeZoneForDateTime = true, bool notNull = false) : base(enumStorage, innerField.Members) { InnerField = innerField; NotNull = notNull; ColumnName = MemberName.ToTableAlias(); this.useTimestampWithoutTimeZoneForDateTime = useTimestampWithoutTimeZoneForDateTime; if (FieldType.IsEnum) { if (enumStorage == EnumStorage.AsString) { DbType = NpgsqlDbType.Varchar; PgType = "varchar"; _parseObject = expression => { var raw = expression.Value(); return(Enum.GetName(FieldType, raw)); }; } else { DbType = NpgsqlDbType.Integer; PgType = "integer"; } } else if (FieldType.IsDateTime()) { PgType = this.useTimestampWithoutTimeZoneForDateTime ? "timestamp without time zone" : "timestamp with time zone"; DbType = this.useTimestampWithoutTimeZoneForDateTime ? NpgsqlDbType.Timestamp : NpgsqlDbType.TimestampTz; } else if (FieldType == typeof(DateTimeOffset) || FieldType == typeof(DateTimeOffset?)) { PgType = "timestamp with time zone"; DbType = NpgsqlDbType.TimestampTz; } else { DbType = TypeMappings.ToDbType(FieldType); } }
public override Expression CompileBulkImporter(EnumStorage enumStorage, Expression writer, ParameterExpression document, ParameterExpression alias, ParameterExpression serializer, ParameterExpression textWriter, bool useCharBufferPooling) { if (useCharBufferPooling) { var method = writeMethod.MakeGenericMethod(typeof(ArraySegment <char>)); var dbType = Expression.Constant(DbType); return(Expression.Block( Expression.Call(serializer, _tojsonWithWriter, document, textWriter), Expression.Call(writer, method, Expression.Call(textWriter, _toSegment), dbType) )); } else { var json = Expression.Call(serializer, _tojson, document); var method = writeMethod.MakeGenericMethod(typeof(string)); var dbType = Expression.Constant(DbType); return(Expression.Call(writer, method, json, dbType)); } }
public DuplicatedField(EnumStorage enumStorage, MemberInfo[] memberPath) : base(memberPath) { _enumStorage = enumStorage; _dbType = TypeMappings.ToDbType(MemberType); ColumnName = MemberName.ToTableAlias(); if (MemberType.IsEnum) { _parseObject = expression => { var raw = expression.Value(); return(Enum.GetName(MemberType, raw)); }; _dbType = NpgsqlDbType.Varchar; PgType = "varchar"; } }
public JsonLocatorField(StoreOptions options, EnumStorage enumStyle, MemberInfo member) : base(member) { var memberType = member.GetMemberType(); var isStringEnum = memberType.GetTypeInfo().IsEnum&& enumStyle == EnumStorage.AsString; if (memberType == typeof(string) || isStringEnum) { SqlLocator = $"d.data ->> '{member.Name}'"; } else if (memberType == typeof(DateTime) || memberType == typeof(DateTime?)) { SqlLocator = $"{options.DatabaseSchemaName}.mt_immutable_timestamp(d.data ->> '{member.Name}')"; SelectionLocator = $"CAST(d.data ->> '{member.Name}' as {PgType})"; } else if (memberType == typeof(DateTimeOffset) || memberType == typeof(DateTimeOffset?)) { SqlLocator = $"{options.DatabaseSchemaName}.mt_immutable_timestamp(d.data ->> '{member.Name}')"; SelectionLocator = $"CAST(d.data ->> '{member.Name}' as {PgType})"; } else { SqlLocator = $"CAST(d.data ->> '{member.Name}' as {PgType})"; } if (isStringEnum) { _parseObject = expression => { var raw = expression.Value(); return(Enum.GetName(MemberType, raw)); }; } if (SelectionLocator.IsEmpty()) { SelectionLocator = SqlLocator; } }
public void get_sum_of_integers_with_where_with_nullable_enum(EnumStorage enumStorage) { StoreOptions(o => o.UseDefaultSerialization(enumStorage)); theSession.Store(new Target { NullableColor = Colors.Blue, Number = 1 }); theSession.Store(new Target { NullableColor = Colors.Red, Number = 2 }); theSession.Store(new Target { NullableColor = Colors.Green, Number = 3 }); theSession.Store(new Target { NullableColor = null, Number = 4 }); theSession.SaveChanges(); theSession.Query <Target>() .Where(x => x.NullableColor != null) .Sum(x => x.Number) .ShouldBe(6); }
public static Expression ToExpression(EnumStorage enumStorage, MemberInfo[] members, ParameterExpression target) { Expression body = target; foreach (var member in members) { if (member is PropertyInfo) { var propertyInfo = member.As <PropertyInfo>(); var getMethod = propertyInfo.GetGetMethod(); body = Expression.Call(body, getMethod); } else { var field = member.As <FieldInfo>(); body = Expression.Field(body, field); } } var memberType = members.Last().GetMemberType(); if (memberType.GetTypeInfo().IsEnum) { if (enumStorage == EnumStorage.AsString) { body = Expression.Call(_getEnumStringValue, Expression.Constant(memberType), Expression.Convert(body, typeof(object))); } else { body = Expression.Call(_getEnumIntValue, Expression.Convert(body, typeof(object))); } } return(body); }
public JsonLocatorField(string dataLocator, EnumStorage enumStyle, Casing casing, MemberInfo[] members) : base(enumStyle, members) { var locator = dataLocator; for (int i = 0; i < members.Length - 1; i++) { locator += $" -> '{members[i].Name.FormatCase(casing)}'"; } locator += $" ->> '{members.Last().Name.FormatCase(casing)}'"; SqlLocator = MemberType == typeof(string) ? locator : locator.ApplyCastToLocator(enumStyle, MemberType); var isStringEnum = MemberType.IsEnum && enumStyle == EnumStorage.AsString; if (isStringEnum) { _parseObject = expression => { var raw = expression.Value(); return(Enum.GetName(MemberType, raw)); }; } }
public override Expression CompileUpdateExpression(EnumStorage enumStorage, ParameterExpression call, ParameterExpression doc, ParameterExpression updateBatch, ParameterExpression mapping, ParameterExpression currentVersion, ParameterExpression newVersion, ParameterExpression tenantId, bool useCharBufferPooling) { var argName = Expression.Constant(Arg); var serializer = Expression.Call(updateBatch, _serializer); var jsonb = Expression.Constant(NpgsqlDbType.Jsonb); if (useCharBufferPooling == false) { var json = Expression.Call(serializer, _tojson, doc); return(Expression.Call(call, _paramMethod, argName, json, jsonb)); } else { var writer = Expression.Variable(typeof(CharArrayTextWriter), "writer"); var segment = Expression.Variable(typeof(ArraySegment <char>), "segment"); return(Expression.Block(new[] { writer, segment }, Expression.Assign(writer, Expression.Call(updateBatch, _getWriter)), Expression.Call(serializer, _tojsonWithWriter, doc, writer), Expression.Assign(segment, Expression.Call(writer, _writerToSegment)), Expression.Call(call, _paramWithJsonBody, argName, segment) )); } }
private static IList <IDbParameterSetter> findSetters(IQueryableDocument mapping, Type queryType, Expression expression, EnumStorage enumStorage) { var visitor = new CompiledQueryMemberExpressionVisitor(mapping, queryType, enumStorage); visitor.Visit(expression); var parameterSetters = visitor.ParameterSetters; return(parameterSetters); }
public CompiledQueryMemberExpressionVisitor(IQueryableDocument mapping, Type queryType, EnumStorage enumStorage) { _mapping = mapping; _queryType = queryType; _enumStorage = enumStorage; }
public override Expression CompileUpdateExpression(EnumStorage enumStorage, ParameterExpression call, ParameterExpression doc, ParameterExpression updateBatch, ParameterExpression mapping, ParameterExpression currentVersion, ParameterExpression newVersion, ParameterExpression tenantId, bool useCharBufferPooling) { var dbType = Expression.Constant(DbType); return(Expression.Call(call, _paramMethod, Expression.Constant(Arg), Expression.Convert(newVersion, typeof(object)), dbType)); }
public override Expression CompileUpdateExpression(EnumStorage enumStorage, ParameterExpression call, ParameterExpression doc, ParameterExpression updateBatch, ParameterExpression mapping, ParameterExpression currentVersion, ParameterExpression newVersion) { var argName = Expression.Constant(Arg); return Expression.Call(call, _paramMethod, argName, Expression.Convert(currentVersion, typeof(object)), Expression.Constant(DbType)); }
protected Field(EnumStorage enumStorage, MemberInfo member, bool notNull = false) : this(enumStorage, new[] { member }, notNull) { }
public JsonLocatorField(string dataLocator, EnumStorage enumStyle, Casing casing, MemberInfo[] members) : this(dataLocator, null, enumStyle, casing, members, null) { }
private static object GetMemberValue(MemberInfo member, object expressionValue, EnumStorage enumStorage) { var value = expressionValue; var memberType = member.GetMemberType(); if (memberType.IsEnum && enumStorage == EnumStorage.AsString) { value = Enum.GetName(memberType, value); } return(value); }
public override Expression CompileBulkImporter(EnumStorage enumStorage, Expression writer, ParameterExpression document, ParameterExpression alias, ParameterExpression serializer) { throw new NotSupportedException("This should not be used for CurrentVersionArgument"); }
public static Expression ToExpression(EnumStorage enumStorage, MemberInfo[] members, ParameterExpression target) {
public abstract string GetDatabaseType(Type memberType, EnumStorage enumStyle);
/// <summary> /// Use the default serialization (ilmerged Newtonsoft.Json) with Enum values /// stored as either integers or strings /// </summary> /// <param name="enumStyle"></param> public void UseDefaultSerialization(EnumStorage enumStyle) { Serializer(new JsonNetSerializer { EnumStorage = enumStyle }); }
public static JsonLocatorField For <T>(EnumStorage enumStyle, Casing casing, Expression <Func <T, object> > expression) { var property = ReflectionHelper.GetProperty(expression); return(new JsonLocatorField("d.data", new StoreOptions(), enumStyle, casing, property)); }
public override Expression CompileUpdateExpression(EnumStorage enumStorage, ParameterExpression call, ParameterExpression doc, ParameterExpression updateBatch, ParameterExpression mapping, ParameterExpression currentVersion, ParameterExpression newVersion) { var argName = Expression.Constant(Arg); return(Expression.Call(call, _paramMethod, argName, Expression.Convert(currentVersion, typeof(object)), Expression.Constant(DbType))); }
/// <summary> /// Use the default serialization (ilmerged Newtonsoft.Json) with Enum values /// stored as either integers or strings /// </summary> /// <param name="enumStyle"></param> /// <param name="casing">Casing style to be used in serialization</param> /// <param name="collectionStorage">Allow to set collection storage as raw arrays (without explicit types)</param> public void UseDefaultSerialization(EnumStorage enumStyle = EnumStorage.AsInteger, Casing casing = Casing.Default, CollectionStorage collectionStorage = CollectionStorage.Default) { Serializer(new JsonNetSerializer { EnumStorage = enumStyle, Casing = casing, CollectionStorage = collectionStorage }); }
public void duplicated_field_enum_storage_should_be_taken_from_store_options_enum_storage_by_default(EnumStorage enumStorage, NpgsqlDbType expectedNpgsqlDbType) { var storeOptions = new StoreOptions(); storeOptions.UseDefaultSerialization(enumStorage); var mapping = new DocumentMapping <Target>(storeOptions); var duplicatedField = mapping.DuplicateField(nameof(Target.Color)); duplicatedField.DbType.ShouldBe(expectedNpgsqlDbType); }
public void duplicated_field_enum_storage_should_be_taken_from_store_options_duplicated_field_enum_storage_when_it_was_changed(EnumStorage enumStorage, NpgsqlDbType expectedNpgsqlDbType) { var storeOptions = new StoreOptions(); storeOptions.DuplicatedFieldEnumStorage = enumStorage; var mapping = new DocumentMapping <Target>(storeOptions); var duplicatedField = mapping.DuplicateField(nameof(Target.Color)); duplicatedField.DbType.ShouldBe(expectedNpgsqlDbType); }
public JsonLocatorField(string dataLocator, StoreOptions options, EnumStorage enumStyle, Casing casing, MemberInfo member) : this(dataLocator, options, enumStyle, casing, new[] { member }, null) { }
public override Expression CompileBulkImporter(EnumStorage enumStorage, Expression writer, ParameterExpression document, ParameterExpression alias, ParameterExpression serializer) { return null; }
protected Field(EnumStorage enumStorage, MemberInfo member) : this(enumStorage, new[] { member }) { }
public static string ApplyCastToLocator(this string locator, EnumStorage enumStyle, Type memberType) { if (memberType.GetTypeInfo().IsEnum) { return enumStyle == EnumStorage.AsInteger ? "({0})::int".ToFormat(locator) : locator; } if (!PgTypes.ContainsKey(memberType)) throw new ArgumentOutOfRangeException(nameof(memberType), "There is not a known Postgresql cast for member type " + memberType.FullName); return "CAST({0} as {1})".ToFormat(locator, PgTypes[memberType]); }