public static byte[] EncodeInt128(KuduInt128 value)
{
var buffer = new byte[16];
EncodeInt128(buffer, value);
return(buffer);
}
[InlineData(-667386670618854952, 7376056636151202432, 35)] //-123.1111111111111111111111111111
public void KuduDecimalTooLarge(long high, ulong low, int scale)
{
var value = new KuduInt128(high, low);
Assert.Throws <OverflowException>(
() => DecimalUtil.DecodeDecimal128(value, scale));
}
public static KuduInt128 MaxDecimal128(int precision)
{
if (precision > MaxDecimal128Precision)
{
throw new ArgumentOutOfRangeException(nameof(precision),
$"Max precision for decimal128 is {MaxDecimal128Precision}");
}
return(KuduInt128.PowerOf10(precision) - 1);
}
public static decimal DecodeDecimal128(KuduInt128 value, int scale)
{
var abs = value.Abs();
int low = (int)(abs.Low & uint.MaxValue);
int mid = (int)(abs.Low >> 32);
int high = (int)(abs.High & uint.MaxValue);
uint extraHigh = (uint)(abs.High >> 32);
if (extraHigh > 0)
{
throw new OverflowException("Kudu decimal is too large for .NET decimal. " +
"Use GetRawFixed to read the raw value.");
}
return(new decimal(low, mid, high, value < 0, (byte)scale));
}
public static KuduInt128 EncodeDecimal128(decimal value, int targetPrecision, int targetScale)
{
var dec = new DecimalAccessor(value);
var scale = (int)dec.Scale;
CheckConditions(value, scale, targetPrecision, targetScale);
int scaleAdjustment = targetScale - scale;
var maxValue = KuduInt128.PowerOf10(targetPrecision - scaleAdjustment) - 1;
var unscaledValue = new KuduInt128(dec.Low, dec.Mid, dec.High, 0);
if (unscaledValue > maxValue)
{
ThrowValueTooBig(value, targetPrecision);
}
var factor = KuduInt128.PowerOf10(scaleAdjustment);
var result = unscaledValue * factor;
return(dec.IsNegative ? result.Negate() : result);
}
/// <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}");
}
}
public static void EncodeInt128(Span <byte> destination, KuduInt128 value)
{
BinaryPrimitives.WriteUInt64LittleEndian(destination, value.Low);
BinaryPrimitives.WriteInt64LittleEndian(destination.Slice(8), value.High);
}
