public static byte[] EncodeDefaultValue(ColumnSchema columnSchema, object value) { var type = columnSchema.Type; return(type switch { KuduType.Int8 => EncodeInt8((sbyte)value), KuduType.Int16 => EncodeInt16((short)value), KuduType.Int32 => EncodeInt32((int)value), KuduType.Int64 => EncodeInt64((long)value), KuduType.String => EncodeString((string)value), KuduType.Varchar => EncodeString((string)value), KuduType.Bool => EncodeBool((bool)value), KuduType.Float => EncodeFloat((float)value), KuduType.Double => EncodeDouble((double)value), KuduType.Binary => (byte[])value, KuduType.UnixtimeMicros => EncodeDateTime((DateTime)value), KuduType.Date => EncodeDate((DateTime)value), KuduType.Decimal32 => EncodeDecimal32( (decimal)value, columnSchema.TypeAttributes !.Precision.GetValueOrDefault(), columnSchema.TypeAttributes.Scale.GetValueOrDefault()), KuduType.Decimal64 => EncodeDecimal64( (decimal)value, columnSchema.TypeAttributes !.Precision.GetValueOrDefault(), columnSchema.TypeAttributes.Scale.GetValueOrDefault()), KuduType.Decimal128 => EncodeDecimal128( (decimal)value, columnSchema.TypeAttributes !.Precision.GetValueOrDefault(), columnSchema.TypeAttributes.Scale.GetValueOrDefault()), _ => throw new Exception($"Unknown data type {type}"), });
protected override int?GetNumericScale() { switch (PrecisionSource.GetValueOrDefault()) { case 0: return(Precision.GetValueOrDefault()); // When the precision is set to one (1), the Organization.PricingDecimalPrecision value is used. case 1: // todo need to support grabbing this info from the organization. For now just always using metadata. return(Precision.GetValueOrDefault()); // When the precision is set to two (2), the TransactionCurrency.CurrencyPrecision value is used. case 2: // todo: need to grab this information from the transaction currency itself..! return(Precision.GetValueOrDefault()); default: return(Precision.GetValueOrDefault()); } }
protected void OnKindChanged() { switch (Kind) { case IndexKind.Hash: MinPrecision = 1; MaxPrecision = 8; if (Precision.GetValueOrDefault(3) > MaxPrecision) { Precision = 3; } break; case IndexKind.Range: MinPrecision = 1; MaxPrecision = 100; break; case IndexKind.Spatial: Precision = null; break; } }
/// <summary> /// Increments the column at the given index, returning false if the /// value is already the maximum. /// </summary> /// <param name="index">The column index to increment.</param> internal bool IncrementColumn(int index) { if (!IsSet(index)) { throw new ArgumentException($"Column index {index} has not been set."); } ColumnSchema column = Schema.GetColumn(index); if (column.IsFixedSize) { KuduType type = column.Type; Span <byte> data = GetRowAllocColumn(index, column.Size); switch (type) { case KuduType.Bool: { bool isFalse = data[0] == 0; data[0] = 1; return(isFalse); } case KuduType.Int8: { sbyte existing = KuduEncoder.DecodeInt8(data); if (existing == sbyte.MaxValue) { return(false); } KuduEncoder.EncodeInt8(data, (sbyte)(existing + 1)); return(true); } case KuduType.Int16: { short existing = KuduEncoder.DecodeInt16(data); if (existing == short.MaxValue) { return(false); } KuduEncoder.EncodeInt16(data, (short)(existing + 1)); return(true); } case KuduType.Int32: { int existing = KuduEncoder.DecodeInt32(data); if (existing == int.MaxValue) { return(false); } KuduEncoder.EncodeInt32(data, existing + 1); return(true); } case KuduType.Date: { int existing = KuduEncoder.DecodeInt32(data); if (existing == EpochTime.MaxDateValue) { return(false); } KuduEncoder.EncodeInt32(data, existing + 1); return(true); } case KuduType.Int64: case KuduType.UnixtimeMicros: { long existing = KuduEncoder.DecodeInt64(data); if (existing == long.MaxValue) { return(false); } KuduEncoder.EncodeInt64(data, existing + 1); return(true); } case KuduType.Float: { float existing = KuduEncoder.DecodeFloat(data); float incremented = existing.NextUp(); if (existing == incremented) { return(false); } KuduEncoder.EncodeFloat(data, incremented); return(true); } case KuduType.Double: { double existing = KuduEncoder.DecodeDouble(data); double incremented = existing.NextUp(); if (existing == incremented) { return(false); } KuduEncoder.EncodeDouble(data, incremented); return(true); } case KuduType.Decimal32: { int existing = KuduEncoder.DecodeInt32(data); int precision = column.TypeAttributes !.Precision.GetValueOrDefault(); if (existing == DecimalUtil.MaxDecimal32(precision)) { return(false); } KuduEncoder.EncodeInt32(data, existing + 1); return(true); } case KuduType.Decimal64: { long existing = KuduEncoder.DecodeInt64(data); int precision = column.TypeAttributes !.Precision.GetValueOrDefault(); if (existing == DecimalUtil.MaxDecimal64(precision)) { return(false); } KuduEncoder.EncodeInt64(data, existing + 1); return(true); } case KuduType.Decimal128: { KuduInt128 existing = KuduEncoder.DecodeInt128(data); int precision = column.TypeAttributes !.Precision.GetValueOrDefault(); if (existing == DecimalUtil.MaxDecimal128(precision)) { return(false); } KuduEncoder.EncodeInt128(data, existing + 1); return(true); } default: throw new Exception($"Unsupported data type {type}"); } } else { // Column is either string, binary, or varchar. ReadOnlySpan <byte> data = GetVarLengthColumn(index); var incremented = new byte[data.Length + 1]; data.CopyTo(incremented); WriteBinary(index, incremented); return(true); } }
/// <summary> /// Sets the column to the minimum possible value for the column's type. /// </summary> /// <param name="index">The index of the column to set to the minimum.</param> internal void SetMin(int index) { ColumnSchema column = Schema.GetColumn(index); KuduType type = column.Type; switch (type) { case KuduType.Bool: WriteBool(index, false); break; case KuduType.Int8: WriteSByte(index, sbyte.MinValue); break; case KuduType.Int16: WriteInt16(index, short.MinValue); break; case KuduType.Int32: WriteInt32(index, int.MinValue); break; case KuduType.Date: WriteInt32(index, EpochTime.MinDateValue); break; case KuduType.Int64: case KuduType.UnixtimeMicros: WriteInt64(index, long.MinValue); break; case KuduType.Float: WriteFloat(index, float.MinValue); break; case KuduType.Double: WriteDouble(index, double.MinValue); break; case KuduType.Decimal32: WriteInt32(index, DecimalUtil.MinDecimal32( column.TypeAttributes !.Precision.GetValueOrDefault())); break; case KuduType.Decimal64: WriteInt64(index, DecimalUtil.MinDecimal64( column.TypeAttributes !.Precision.GetValueOrDefault())); break; case KuduType.Decimal128: { KuduInt128 min = DecimalUtil.MinDecimal128( column.TypeAttributes !.Precision.GetValueOrDefault()); Span <byte> span = GetSpanInRowAllocAndSetBitSet(index, 16); KuduEncoder.EncodeInt128(span, min); break; } case KuduType.String: case KuduType.Varchar: WriteString(index, string.Empty); break; case KuduType.Binary: WriteBinary(index, Array.Empty <byte>()); break; default: throw new Exception($"Unsupported data type {type}"); } }
private AxisPrintCoordinates GetPrintCoordinates(Size printArea, int offset) { Size actualyPrintArea = new Size(printArea.Width - offset, printArea.Height); AxisPrintCoordinates c = new AxisPrintCoordinates(); c.offset = offset; // minimum X coordinate (starts at zero) c.minimumX = Margins.Left; // maximum X coordinate c.maximumX = actualyPrintArea.Width - Margins.Right; // x range c.rangeX = c.maximumX - c.minimumX; // X offset from index c.indexOffsetX = AxisIndexOffsetAmount; // minimum Y coordinate c.minimumY = (base.RangeStart * actualyPrintArea.Height) + Margins.Top; // maximum Y coordinate c.maximumY = (base.RangeEnd * actualyPrintArea.Height) - Margins.Bottom; // y range c.rangeY = c.maximumY - c.minimumY; // X coordinate of the vertical axis line (all other y positions should be based off of this value) c.axisVerticalLineX = (Position == YAxisPosition.Left) ? c.maximumX - c.indexOffsetX : c.indexOffsetX; if (c.axisVerticalLineX < MinimumVerticalLineXOffset) { c.axisVerticalLineX = MinimumVerticalLineXOffset; } // effective tick widths c.smallTickWidth = SmallTickWidth.HasValue ? SmallTickWidth.Value : DefaultSmallTickWidth; c.largeTickWidth = LargeTickWidth.HasValue ? LargeTickWidth.Value : DefaultLargeTickWidth; c.maximumTickWidth = (c.largeTickWidth > c.smallTickWidth) ? c.largeTickWidth : c.smallTickWidth; // outermost x coordinate (away from vertical axis line) for all ticks c.outermostTickX = (Position == YAxisPosition.Left) ? c.axisVerticalLineX - c.maximumTickWidth : c.axisVerticalLineX + c.maximumTickWidth; // actual tick X coordinates c.smallTickX = (Position == YAxisPosition.Left) ? c.axisVerticalLineX - c.smallTickWidth : c.axisVerticalLineX; c.largeTickX = (Position == YAxisPosition.Left) ? c.axisVerticalLineX - c.largeTickWidth : c.axisVerticalLineX; // horizontal margin between tick line and label c.tickLineToLabelMargin = -2F; c.smallLabelSize = TextRenderer.MeasureText((EffectiveMaximum).ToString(Format), SmallLabelFont); c.largeLabelSize = TextRenderer.MeasureText((EffectiveMaximum).ToString(Format), LargeLabelFont); c.maximumLablelWidth = (c.smallLabelSize.Width > c.largeLabelSize.Width) ? c.smallLabelSize.Width : c.largeLabelSize.Width; // all labels are aligned vertically on the same Y coordinate. c.labelX = (Position == YAxisPosition.Left) ? c.outermostTickX - c.tickLineToLabelMargin - c.maximumLablelWidth : c.outermostTickX + c.tickLineToLabelMargin; var actualTitle = string.IsNullOrEmpty(Unit) ? Name : $"{Name} ({Unit})"; if (DrawTitleVertically) { Size horizontalSize = TextRenderer.MeasureText(actualTitle, AxisFont); // flip horizontal size to vertical c.titleSize = new Size( horizontalSize.Height, horizontalSize.Width); } else { c.titleSize = TextRenderer.MeasureText(actualTitle, AxisFont); } c.titleX = (Position == YAxisPosition.Left) ? c.labelX - c.titleToLabelMargin - c.titleSize.Width : c.labelX + c.titleToLabelMargin; c.titleY = c.minimumY + ((c.maximumY - c.minimumY) / 2); c.TitleLabel = new TitleLabel() { Text = actualTitle, X = c.titleX, Y = c.titleY }; float valueRange = Math.Abs(EffectiveMaximum - EffectiveMinimum); float largeStep = LargeStep.HasValue ? LargeStep.Value : (valueRange / 3); float smallStep = SmallStep.HasValue ? SmallStep.Value : (largeStep / 3); float startYPosition = InvertRange ? -EffectiveMaximum : EffectiveMinimum; float maxYPosition = InvertRange ? -EffectiveMinimum : EffectiveMaximum; float scalingRangeMinimum = InvertRange ? -c.maximumY : c.minimumY; float scalingRangeMaximum = InvertRange ? -c.minimumY : c.maximumY; float scalingValuesMinimum = InvertRange ? -EffectiveMinimum : EffectiveMinimum; float scalingValuesMaximum = InvertRange ? -EffectiveMaximum : EffectiveMaximum; for (float i = startYPosition; i < maxYPosition; i += largeStep) { var largeStepValue = i; var largeScaledY = LineGraphHelper.Scale(scalingRangeMinimum, scalingRangeMaximum, scalingValuesMinimum, scalingValuesMaximum, largeStepValue); c.LargeTicks.Add(new Tick() { X = c.largeTickX, Y = largeScaledY, Width = LargeTickWidth.GetValueOrDefault(8) }); c.LargeLabels.Add(new TickLabel() { X = c.labelX, Y = largeScaledY - (LargeLabelFont.SizeInPoints), Text = FormatLabel(Math.Abs(Math.Round(largeStepValue, Precision.GetValueOrDefault(2)))) }); for (float x = i + smallStep; x < i + largeStep; x += smallStep) { var smallStepValue = x; var smallScaledY = LineGraphHelper.Scale(scalingRangeMinimum, scalingRangeMaximum, scalingValuesMinimum, scalingValuesMaximum, smallStepValue); c.SmallTicks.Add(new Tick() { X = c.smallTickX, Y = smallScaledY, Width = SmallTickWidth.GetValueOrDefault(4) }); c.SmallLabels.Add(new TickLabel() { X = c.labelX, Y = smallScaledY - (SmallLabelFont.SizeInPoints), Text = FormatLabel(Math.Abs(Math.Round(smallStepValue, Precision.GetValueOrDefault(2)))) }); } } var lastScaledY = LineGraphHelper.Scale(scalingRangeMinimum, scalingRangeMaximum, scalingValuesMinimum, scalingValuesMaximum, scalingValuesMaximum); c.LargeTicks.Add(new Tick() { X = c.largeTickX, Y = Math.Abs(InvertRange ? scalingRangeMinimum : scalingRangeMaximum), Width = LargeTickWidth.GetValueOrDefault(8) }); c.LargeLabels.Add(new TickLabel() { X = c.labelX, Y = Math.Abs(InvertRange ? scalingRangeMinimum : scalingRangeMaximum) - (LargeLabelFont.SizeInPoints), Text = FormatLabel(Math.Abs(InvertRange ? scalingValuesMinimum : scalingValuesMaximum)) }); return(c); }
protected override int?GetNumericPrecision() { switch (PrecisionSource.GetValueOrDefault()) { // When the precision is set to zero (0), the MoneyAttributeMetadata.Precision value is used. case 0: var numericPrecision = Math.Max(MinValue.ToString().Length, MaxValue.ToString().Length) + Precision.GetValueOrDefault(); return(numericPrecision); // When the precision is set to one (1), the Organization.PricingDecimalPrecision value is used. case 1: // todo need to support grabbing this info from the organization. For now just always using metadata. var orgPrecision = Math.Max(MinValue.ToString().Length, MaxValue.ToString().Length) + Precision.GetValueOrDefault(); return(orgPrecision); // When the precision is set to two (2), the TransactionCurrency.CurrencyPrecision value is used. case 2: // todo: need to grab this information from the transaction currency itself..! var currencyPrecision = Math.Max(MinValue.ToString().Length, MaxValue.ToString().Length) + Precision.GetValueOrDefault(); return(currencyPrecision); default: var defaultPrecision = Math.Max(MinValue.ToString().Length, MaxValue.ToString().Length) + Precision.GetValueOrDefault(); return(defaultPrecision); } }