private ColumnSchema CheckType(int columnIndex, KuduType type)
{
var columnSchema = Schema.GetColumn(columnIndex);
KuduTypeValidation.ValidateColumnType(columnSchema, type);
return(columnSchema);
}
/// <summary>
/// Add a new column to the table. The column defaults to a
/// nullable non-key column.
/// </summary>
/// <param name="name">The column name.</param>
/// <param name="type">The column type.</param>
/// <param name="configure">A delegate to further configure the column.</param>
public AlterTableBuilder AddColumn(
string name, KuduType type, Action <ColumnBuilder>?configure = null)
{
var columnBuilder = new ColumnBuilder(name, type);
configure?.Invoke(columnBuilder);
var schema = columnBuilder.Build();
if (!schema.IsNullable && schema.DefaultValue is null)
{
ThrowNewColumnMustHaveDefaultException();
}
if (schema.IsKey)
{
ThrowAddKeyColumnException();
}
_request.AlterSchemaSteps.Add(new Step
{
Type = StepType.AddColumn,
AddColumn = new AddColumn
{
Schema = schema.ToColumnSchemaPb()
}
});
return(this);
}
public ColumnSchema(
string name, KuduType type,
bool isKey = false,
bool isNullable = false,
object?defaultValue = null,
int desiredBlockSize = 0,
EncodingType encoding = EncodingType.AutoEncoding,
CompressionType compression = CompressionType.DefaultCompression,
ColumnTypeAttributes?typeAttributes = null,
string?comment = null)
{
Name = name;
Type = type;
IsKey = isKey;
IsNullable = isNullable;
DefaultValue = defaultValue;
DesiredBlockSize = desiredBlockSize;
Encoding = encoding;
Compression = compression;
TypeAttributes = typeAttributes;
Comment = comment;
Size = KuduSchema.GetTypeSize(type);
IsSigned = KuduSchema.IsSigned(type);
IsFixedSize = IsTypeFixedSize(type);
}
public static bool IsTypeFixedSize(KuduType type)
{
return
(type != KuduType.String &&
type != KuduType.Binary &&
type != KuduType.Varchar);
}
public static void ValidateColumnType(
this ColumnSchema column, KuduType type)
{
if (column.Type != type)
{
ThrowException(column, type);
}
}
/// <summary>
/// Add a new column to the table. The column defaults to a
/// nullable non-key column.
/// </summary>
/// <param name="name">The column name.</param>
/// <param name="type">The column type.</param>
/// <param name="configure">A delegate to further configure the column.</param>
public TableBuilder AddColumn(
string name, KuduType type, Action <ColumnBuilder>?configure = null)
{
var builder = new ColumnBuilder(name, type);
configure?.Invoke(builder);
var columnSchemaPb = builder.Build().ToColumnSchemaPb();
_createTableRequest.Schema.Columns.Add(columnSchemaPb);
return(this);
}
private static SortedSet <long> CreateIntegerValues(KuduType type)
{
var values = new SortedSet <long>();
for (long i = -50; i < 50; i++)
{
values.Add(i);
}
values.Add(KuduPredicate.MinIntValue(type));
values.Add(KuduPredicate.MinIntValue(type) + 1);
values.Add(KuduPredicate.MaxIntValue(type) - 1);
values.Add(KuduPredicate.MaxIntValue(type));
return(values);
}
private static List <long> CreateIntegerTestValues(KuduType type)
{
return(new List <long>
{
KuduPredicate.MinIntValue(type),
KuduPredicate.MinIntValue(type) + 1,
-51L,
-50L,
0L,
49L,
50L,
KuduPredicate.MaxIntValue(type) - 1,
KuduPredicate.MaxIntValue(type)
});
}
/// <summary>
/// Return a string representation appropriate for `type`.
/// This is meant to be postfixed to the name of a primitive type to
/// describe the full type, e.g. decimal(10, 4).
/// </summary>
/// <param name="type">The data type.</param>
public string ToStringForType(KuduType type)
{
switch (type)
{
case KuduType.Decimal32:
case KuduType.Decimal64:
case KuduType.Decimal128:
return($"({Precision}, {Scale})");
case KuduType.Varchar:
return($"({Length})");
default:
return("");
}
}
public static void EncodeDecimal(
Span <byte> destination, KuduType kuduType, decimal value, int precision, int scale)
{
switch (kuduType)
{
case KuduType.Decimal32:
int intVal = DecimalUtil.EncodeDecimal32(value, precision, scale);
EncodeInt32(destination, intVal);
break;
case KuduType.Decimal64:
long longVal = DecimalUtil.EncodeDecimal64(value, precision, scale);
EncodeInt64(destination, longVal);
break;
default:
var int128Val = DecimalUtil.EncodeDecimal128(value, precision, scale);
EncodeInt128(destination, int128Val);
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}");
}
}
public ColumnBuilder(string name, KuduType type)
{
_name = name;
_type = type;
_isNullable = true;
}
public static bool IsOfType(this KuduType type, KuduTypeFlags types)
{
int typeFlag = 1 << (int)type;
return((typeFlag & (int)types) != 0);
}
public static void ThrowException(ColumnSchema column, KuduType type)
{
throw new ArgumentException(
$"Expected column {column} to be of {type}");
}
