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}"); }