package chschema import ( "reflect" "time" "github.com/uptrace/go-clickhouse/ch/chproto" ) type Int8Column struct { NumericColumnOf[int8] } var _ Columnar = (*Int8Column)(nil) func NewInt8Column() Columnar { return new(Int8Column) } var _Int8Type = reflect.TypeOf((*int8)(nil)).Elem() func (c *Int8Column) Type() reflect.Type { return _Int8Type } func (c *Int8Column) AppendValue(v reflect.Value) { c.Column = append(c.Column, int8(v.Int())) } //------------------------------------------------------------------------------ type ArrayInt8Column struct { ColumnOf[[]int8] elem Int8Column } var ( _ Columnar = (*ArrayInt8Column)(nil) _ ArrayColumnar = (*ArrayInt8Column)(nil) ) func NewArrayInt8Column() Columnar { return new(ArrayInt8Column) } func (c *ArrayInt8Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayInt8Column) Type() reflect.Type { return reflect.TypeOf((*[]int8)(nil)).Elem() } func (c *ArrayInt8Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayInt8Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayInt8Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayInt8Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayInt8Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayInt8Column struct { ColumnOf[[][]int8] elem ArrayInt8Column } var ( _ Columnar = (*ArrayArrayInt8Column)(nil) _ ArrayColumnar = (*ArrayArrayInt8Column)(nil) ) func NewArrayArrayInt8Column() Columnar { return new(ArrayArrayInt8Column) } func (c *ArrayArrayInt8Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayInt8Column) Type() reflect.Type { return reflect.TypeOf((*[][]int8)(nil)).Elem() } func (c *ArrayArrayInt8Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayInt8Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayInt8Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayInt8Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayInt8Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type UInt8Column struct { NumericColumnOf[uint8] } var _ Columnar = (*UInt8Column)(nil) func NewUInt8Column() Columnar { return new(UInt8Column) } var _UInt8Type = reflect.TypeOf((*uint8)(nil)).Elem() func (c *UInt8Column) Type() reflect.Type { return _UInt8Type } func (c *UInt8Column) AppendValue(v reflect.Value) { c.Column = append(c.Column, uint8(v.Uint())) } //------------------------------------------------------------------------------ type ArrayUInt8Column struct { ColumnOf[[]uint8] elem UInt8Column } var ( _ Columnar = (*ArrayUInt8Column)(nil) _ ArrayColumnar = (*ArrayUInt8Column)(nil) ) func NewArrayUInt8Column() Columnar { return new(ArrayUInt8Column) } func (c *ArrayUInt8Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayUInt8Column) Type() reflect.Type { return reflect.TypeOf((*[]uint8)(nil)).Elem() } func (c *ArrayUInt8Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayUInt8Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayUInt8Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayUInt8Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayUInt8Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayUInt8Column struct { ColumnOf[[][]uint8] elem ArrayUInt8Column } var ( _ Columnar = (*ArrayArrayUInt8Column)(nil) _ ArrayColumnar = (*ArrayArrayUInt8Column)(nil) ) func NewArrayArrayUInt8Column() Columnar { return new(ArrayArrayUInt8Column) } func (c *ArrayArrayUInt8Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayUInt8Column) Type() reflect.Type { return reflect.TypeOf((*[][]uint8)(nil)).Elem() } func (c *ArrayArrayUInt8Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayUInt8Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayUInt8Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayUInt8Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayUInt8Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type Int16Column struct { NumericColumnOf[int16] } var _ Columnar = (*Int16Column)(nil) func NewInt16Column() Columnar { return new(Int16Column) } var _Int16Type = reflect.TypeOf((*int16)(nil)).Elem() func (c *Int16Column) Type() reflect.Type { return _Int16Type } func (c *Int16Column) AppendValue(v reflect.Value) { c.Column = append(c.Column, int16(v.Int())) } //------------------------------------------------------------------------------ type ArrayInt16Column struct { ColumnOf[[]int16] elem Int16Column } var ( _ Columnar = (*ArrayInt16Column)(nil) _ ArrayColumnar = (*ArrayInt16Column)(nil) ) func NewArrayInt16Column() Columnar { return new(ArrayInt16Column) } func (c *ArrayInt16Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayInt16Column) Type() reflect.Type { return reflect.TypeOf((*[]int16)(nil)).Elem() } func (c *ArrayInt16Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayInt16Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayInt16Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayInt16Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayInt16Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayInt16Column struct { ColumnOf[[][]int16] elem ArrayInt16Column } var ( _ Columnar = (*ArrayArrayInt16Column)(nil) _ ArrayColumnar = (*ArrayArrayInt16Column)(nil) ) func NewArrayArrayInt16Column() Columnar { return new(ArrayArrayInt16Column) } func (c *ArrayArrayInt16Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayInt16Column) Type() reflect.Type { return reflect.TypeOf((*[][]int16)(nil)).Elem() } func (c *ArrayArrayInt16Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayInt16Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayInt16Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayInt16Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayInt16Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type UInt16Column struct { NumericColumnOf[uint16] } var _ Columnar = (*UInt16Column)(nil) func NewUInt16Column() Columnar { return new(UInt16Column) } var _UInt16Type = reflect.TypeOf((*uint16)(nil)).Elem() func (c *UInt16Column) Type() reflect.Type { return _UInt16Type } func (c *UInt16Column) AppendValue(v reflect.Value) { c.Column = append(c.Column, uint16(v.Uint())) } //------------------------------------------------------------------------------ type ArrayUInt16Column struct { ColumnOf[[]uint16] elem UInt16Column } var ( _ Columnar = (*ArrayUInt16Column)(nil) _ ArrayColumnar = (*ArrayUInt16Column)(nil) ) func NewArrayUInt16Column() Columnar { return new(ArrayUInt16Column) } func (c *ArrayUInt16Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayUInt16Column) Type() reflect.Type { return reflect.TypeOf((*[]uint16)(nil)).Elem() } func (c *ArrayUInt16Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayUInt16Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayUInt16Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayUInt16Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayUInt16Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayUInt16Column struct { ColumnOf[[][]uint16] elem ArrayUInt16Column } var ( _ Columnar = (*ArrayArrayUInt16Column)(nil) _ ArrayColumnar = (*ArrayArrayUInt16Column)(nil) ) func NewArrayArrayUInt16Column() Columnar { return new(ArrayArrayUInt16Column) } func (c *ArrayArrayUInt16Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayUInt16Column) Type() reflect.Type { return reflect.TypeOf((*[][]uint16)(nil)).Elem() } func (c *ArrayArrayUInt16Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayUInt16Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayUInt16Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayUInt16Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayUInt16Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type Int32Column struct { NumericColumnOf[int32] } var _ Columnar = (*Int32Column)(nil) func NewInt32Column() Columnar { return new(Int32Column) } var _Int32Type = reflect.TypeOf((*int32)(nil)).Elem() func (c *Int32Column) Type() reflect.Type { return _Int32Type } func (c *Int32Column) AppendValue(v reflect.Value) { c.Column = append(c.Column, int32(v.Int())) } //------------------------------------------------------------------------------ type ArrayInt32Column struct { ColumnOf[[]int32] elem Int32Column } var ( _ Columnar = (*ArrayInt32Column)(nil) _ ArrayColumnar = (*ArrayInt32Column)(nil) ) func NewArrayInt32Column() Columnar { return new(ArrayInt32Column) } func (c *ArrayInt32Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayInt32Column) Type() reflect.Type { return reflect.TypeOf((*[]int32)(nil)).Elem() } func (c *ArrayInt32Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayInt32Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayInt32Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayInt32Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayInt32Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayInt32Column struct { ColumnOf[[][]int32] elem ArrayInt32Column } var ( _ Columnar = (*ArrayArrayInt32Column)(nil) _ ArrayColumnar = (*ArrayArrayInt32Column)(nil) ) func NewArrayArrayInt32Column() Columnar { return new(ArrayArrayInt32Column) } func (c *ArrayArrayInt32Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayInt32Column) Type() reflect.Type { return reflect.TypeOf((*[][]int32)(nil)).Elem() } func (c *ArrayArrayInt32Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayInt32Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayInt32Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayInt32Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayInt32Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type UInt32Column struct { NumericColumnOf[uint32] } var _ Columnar = (*UInt32Column)(nil) func NewUInt32Column() Columnar { return new(UInt32Column) } var _UInt32Type = reflect.TypeOf((*uint32)(nil)).Elem() func (c *UInt32Column) Type() reflect.Type { return _UInt32Type } func (c *UInt32Column) AppendValue(v reflect.Value) { c.Column = append(c.Column, uint32(v.Uint())) } //------------------------------------------------------------------------------ type ArrayUInt32Column struct { ColumnOf[[]uint32] elem UInt32Column } var ( _ Columnar = (*ArrayUInt32Column)(nil) _ ArrayColumnar = (*ArrayUInt32Column)(nil) ) func NewArrayUInt32Column() Columnar { return new(ArrayUInt32Column) } func (c *ArrayUInt32Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayUInt32Column) Type() reflect.Type { return reflect.TypeOf((*[]uint32)(nil)).Elem() } func (c *ArrayUInt32Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayUInt32Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayUInt32Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayUInt32Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayUInt32Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayUInt32Column struct { ColumnOf[[][]uint32] elem ArrayUInt32Column } var ( _ Columnar = (*ArrayArrayUInt32Column)(nil) _ ArrayColumnar = (*ArrayArrayUInt32Column)(nil) ) func NewArrayArrayUInt32Column() Columnar { return new(ArrayArrayUInt32Column) } func (c *ArrayArrayUInt32Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayUInt32Column) Type() reflect.Type { return reflect.TypeOf((*[][]uint32)(nil)).Elem() } func (c *ArrayArrayUInt32Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayUInt32Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayUInt32Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayUInt32Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayUInt32Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type Int64Column struct { NumericColumnOf[int64] } var _ Columnar = (*Int64Column)(nil) func NewInt64Column() Columnar { return new(Int64Column) } var _Int64Type = reflect.TypeOf((*int64)(nil)).Elem() func (c *Int64Column) Type() reflect.Type { return _Int64Type } func (c *Int64Column) AppendValue(v reflect.Value) { c.Column = append(c.Column, int64(v.Int())) } //------------------------------------------------------------------------------ type ArrayInt64Column struct { ColumnOf[[]int64] elem Int64Column } var ( _ Columnar = (*ArrayInt64Column)(nil) _ ArrayColumnar = (*ArrayInt64Column)(nil) ) func NewArrayInt64Column() Columnar { return new(ArrayInt64Column) } func (c *ArrayInt64Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayInt64Column) Type() reflect.Type { return reflect.TypeOf((*[]int64)(nil)).Elem() } func (c *ArrayInt64Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayInt64Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayInt64Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayInt64Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayInt64Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayInt64Column struct { ColumnOf[[][]int64] elem ArrayInt64Column } var ( _ Columnar = (*ArrayArrayInt64Column)(nil) _ ArrayColumnar = (*ArrayArrayInt64Column)(nil) ) func NewArrayArrayInt64Column() Columnar { return new(ArrayArrayInt64Column) } func (c *ArrayArrayInt64Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayInt64Column) Type() reflect.Type { return reflect.TypeOf((*[][]int64)(nil)).Elem() } func (c *ArrayArrayInt64Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayInt64Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayInt64Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayInt64Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayInt64Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type UInt64Column struct { NumericColumnOf[uint64] } var _ Columnar = (*UInt64Column)(nil) func NewUInt64Column() Columnar { return new(UInt64Column) } var _UInt64Type = reflect.TypeOf((*uint64)(nil)).Elem() func (c *UInt64Column) Type() reflect.Type { return _UInt64Type } func (c *UInt64Column) AppendValue(v reflect.Value) { c.Column = append(c.Column, uint64(v.Uint())) } //------------------------------------------------------------------------------ type ArrayUInt64Column struct { ColumnOf[[]uint64] elem UInt64Column } var ( _ Columnar = (*ArrayUInt64Column)(nil) _ ArrayColumnar = (*ArrayUInt64Column)(nil) ) func NewArrayUInt64Column() Columnar { return new(ArrayUInt64Column) } func (c *ArrayUInt64Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayUInt64Column) Type() reflect.Type { return reflect.TypeOf((*[]uint64)(nil)).Elem() } func (c *ArrayUInt64Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayUInt64Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayUInt64Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayUInt64Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayUInt64Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayUInt64Column struct { ColumnOf[[][]uint64] elem ArrayUInt64Column } var ( _ Columnar = (*ArrayArrayUInt64Column)(nil) _ ArrayColumnar = (*ArrayArrayUInt64Column)(nil) ) func NewArrayArrayUInt64Column() Columnar { return new(ArrayArrayUInt64Column) } func (c *ArrayArrayUInt64Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayUInt64Column) Type() reflect.Type { return reflect.TypeOf((*[][]uint64)(nil)).Elem() } func (c *ArrayArrayUInt64Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayUInt64Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayUInt64Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayUInt64Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayUInt64Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type Float32Column struct { NumericColumnOf[float32] } var _ Columnar = (*Float32Column)(nil) func NewFloat32Column() Columnar { return new(Float32Column) } var _Float32Type = reflect.TypeOf((*float32)(nil)).Elem() func (c *Float32Column) Type() reflect.Type { return _Float32Type } func (c *Float32Column) AppendValue(v reflect.Value) { c.Column = append(c.Column, float32(v.Float())) } //------------------------------------------------------------------------------ type ArrayFloat32Column struct { ColumnOf[[]float32] elem Float32Column } var ( _ Columnar = (*ArrayFloat32Column)(nil) _ ArrayColumnar = (*ArrayFloat32Column)(nil) ) func NewArrayFloat32Column() Columnar { return new(ArrayFloat32Column) } func (c *ArrayFloat32Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayFloat32Column) Type() reflect.Type { return reflect.TypeOf((*[]float32)(nil)).Elem() } func (c *ArrayFloat32Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayFloat32Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayFloat32Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayFloat32Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayFloat32Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayFloat32Column struct { ColumnOf[[][]float32] elem ArrayFloat32Column } var ( _ Columnar = (*ArrayArrayFloat32Column)(nil) _ ArrayColumnar = (*ArrayArrayFloat32Column)(nil) ) func NewArrayArrayFloat32Column() Columnar { return new(ArrayArrayFloat32Column) } func (c *ArrayArrayFloat32Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayFloat32Column) Type() reflect.Type { return reflect.TypeOf((*[][]float32)(nil)).Elem() } func (c *ArrayArrayFloat32Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayFloat32Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayFloat32Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayFloat32Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayFloat32Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type Float64Column struct { NumericColumnOf[float64] } var _ Columnar = (*Float64Column)(nil) func NewFloat64Column() Columnar { return new(Float64Column) } var _Float64Type = reflect.TypeOf((*float64)(nil)).Elem() func (c *Float64Column) Type() reflect.Type { return _Float64Type } func (c *Float64Column) AppendValue(v reflect.Value) { c.Column = append(c.Column, float64(v.Float())) } //------------------------------------------------------------------------------ type ArrayFloat64Column struct { ColumnOf[[]float64] elem Float64Column } var ( _ Columnar = (*ArrayFloat64Column)(nil) _ ArrayColumnar = (*ArrayFloat64Column)(nil) ) func NewArrayFloat64Column() Columnar { return new(ArrayFloat64Column) } func (c *ArrayFloat64Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayFloat64Column) Type() reflect.Type { return reflect.TypeOf((*[]float64)(nil)).Elem() } func (c *ArrayFloat64Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayFloat64Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayFloat64Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayFloat64Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayFloat64Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayFloat64Column struct { ColumnOf[[][]float64] elem ArrayFloat64Column } var ( _ Columnar = (*ArrayArrayFloat64Column)(nil) _ ArrayColumnar = (*ArrayArrayFloat64Column)(nil) ) func NewArrayArrayFloat64Column() Columnar { return new(ArrayArrayFloat64Column) } func (c *ArrayArrayFloat64Column) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayFloat64Column) Type() reflect.Type { return reflect.TypeOf((*[][]float64)(nil)).Elem() } func (c *ArrayArrayFloat64Column) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayFloat64Column) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayFloat64Column) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayFloat64Column) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayFloat64Column) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type BoolColumn struct { ColumnOf[bool] } var _ Columnar = (*BoolColumn)(nil) func NewBoolColumn() Columnar { return new(BoolColumn) } var _BoolType = reflect.TypeOf((*bool)(nil)).Elem() func (c *BoolColumn) Type() reflect.Type { return _BoolType } func (c *BoolColumn) AppendValue(v reflect.Value) { c.Column = append(c.Column, bool(v.Bool())) } func (c *BoolColumn) ReadFrom(rd *chproto.Reader, numRow int) error { c.AllocForReading(numRow) for i := range c.Column { n, err := rd.Bool() if err != nil { return err } c.Column[i] = n } return nil } func (c *BoolColumn) WriteTo(wr *chproto.Writer) error { for _, n := range c.Column { wr.Bool(n) } return nil } //------------------------------------------------------------------------------ type ArrayBoolColumn struct { ColumnOf[[]bool] elem BoolColumn } var ( _ Columnar = (*ArrayBoolColumn)(nil) _ ArrayColumnar = (*ArrayBoolColumn)(nil) ) func NewArrayBoolColumn() Columnar { return new(ArrayBoolColumn) } func (c *ArrayBoolColumn) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayBoolColumn) Type() reflect.Type { return reflect.TypeOf((*[]bool)(nil)).Elem() } func (c *ArrayBoolColumn) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayBoolColumn) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayBoolColumn) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayBoolColumn) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayBoolColumn) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayBoolColumn struct { ColumnOf[[][]bool] elem ArrayBoolColumn } var ( _ Columnar = (*ArrayArrayBoolColumn)(nil) _ ArrayColumnar = (*ArrayArrayBoolColumn)(nil) ) func NewArrayArrayBoolColumn() Columnar { return new(ArrayArrayBoolColumn) } func (c *ArrayArrayBoolColumn) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayBoolColumn) Type() reflect.Type { return reflect.TypeOf((*[][]bool)(nil)).Elem() } func (c *ArrayArrayBoolColumn) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayBoolColumn) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayBoolColumn) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayBoolColumn) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayBoolColumn) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type StringColumn struct { ColumnOf[string] } var _ Columnar = (*StringColumn)(nil) func NewStringColumn() Columnar { return new(StringColumn) } var _StringType = reflect.TypeOf((*string)(nil)).Elem() func (c *StringColumn) Type() reflect.Type { return _StringType } func (c *StringColumn) AppendValue(v reflect.Value) { c.Column = append(c.Column, string(v.String())) } func (c *StringColumn) ReadFrom(rd *chproto.Reader, numRow int) error { c.AllocForReading(numRow) for i := range c.Column { n, err := rd.String() if err != nil { return err } c.Column[i] = n } return nil } func (c *StringColumn) WriteTo(wr *chproto.Writer) error { for _, n := range c.Column { wr.String(n) } return nil } //------------------------------------------------------------------------------ type ArrayStringColumn struct { ColumnOf[[]string] elem StringColumn } var ( _ Columnar = (*ArrayStringColumn)(nil) _ ArrayColumnar = (*ArrayStringColumn)(nil) ) func NewArrayStringColumn() Columnar { return new(ArrayStringColumn) } func (c *ArrayStringColumn) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayStringColumn) Type() reflect.Type { return reflect.TypeOf((*[]string)(nil)).Elem() } func (c *ArrayStringColumn) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayStringColumn) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayStringColumn) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayStringColumn) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayStringColumn) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayStringColumn struct { ColumnOf[[][]string] elem ArrayStringColumn } var ( _ Columnar = (*ArrayArrayStringColumn)(nil) _ ArrayColumnar = (*ArrayArrayStringColumn)(nil) ) func NewArrayArrayStringColumn() Columnar { return new(ArrayArrayStringColumn) } func (c *ArrayArrayStringColumn) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayStringColumn) Type() reflect.Type { return reflect.TypeOf((*[][]string)(nil)).Elem() } func (c *ArrayArrayStringColumn) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayStringColumn) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayStringColumn) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayStringColumn) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayStringColumn) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type BytesColumn struct { ColumnOf[[]byte] } var _ Columnar = (*BytesColumn)(nil) func NewBytesColumn() Columnar { return new(BytesColumn) } var _BytesType = reflect.TypeOf((*[]byte)(nil)).Elem() func (c *BytesColumn) Type() reflect.Type { return _BytesType } func (c *BytesColumn) AppendValue(v reflect.Value) { c.Column = append(c.Column, []byte(v.Bytes())) } func (c *BytesColumn) ReadFrom(rd *chproto.Reader, numRow int) error { c.AllocForReading(numRow) for i := range c.Column { n, err := rd.Bytes() if err != nil { return err } c.Column[i] = n } return nil } func (c *BytesColumn) WriteTo(wr *chproto.Writer) error { for _, n := range c.Column { wr.Bytes(n) } return nil } //------------------------------------------------------------------------------ type ArrayBytesColumn struct { ColumnOf[[][]byte] elem BytesColumn } var ( _ Columnar = (*ArrayBytesColumn)(nil) _ ArrayColumnar = (*ArrayBytesColumn)(nil) ) func NewArrayBytesColumn() Columnar { return new(ArrayBytesColumn) } func (c *ArrayBytesColumn) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayBytesColumn) Type() reflect.Type { return reflect.TypeOf((*[][]byte)(nil)).Elem() } func (c *ArrayBytesColumn) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayBytesColumn) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayBytesColumn) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayBytesColumn) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayBytesColumn) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayBytesColumn struct { ColumnOf[[][][]byte] elem ArrayBytesColumn } var ( _ Columnar = (*ArrayArrayBytesColumn)(nil) _ ArrayColumnar = (*ArrayArrayBytesColumn)(nil) ) func NewArrayArrayBytesColumn() Columnar { return new(ArrayArrayBytesColumn) } func (c *ArrayArrayBytesColumn) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayBytesColumn) Type() reflect.Type { return reflect.TypeOf((*[][][]byte)(nil)).Elem() } func (c *ArrayArrayBytesColumn) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayBytesColumn) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayBytesColumn) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayBytesColumn) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayBytesColumn) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayEnumColumn struct { ColumnOf[[]string] elem EnumColumn } var ( _ Columnar = (*ArrayEnumColumn)(nil) _ ArrayColumnar = (*ArrayEnumColumn)(nil) ) func NewArrayEnumColumn() Columnar { return new(ArrayEnumColumn) } func (c *ArrayEnumColumn) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayEnumColumn) Type() reflect.Type { return reflect.TypeOf((*[]string)(nil)).Elem() } func (c *ArrayEnumColumn) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayEnumColumn) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayEnumColumn) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayEnumColumn) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayEnumColumn) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayEnumColumn struct { ColumnOf[[][]string] elem ArrayEnumColumn } var ( _ Columnar = (*ArrayArrayEnumColumn)(nil) _ ArrayColumnar = (*ArrayArrayEnumColumn)(nil) ) func NewArrayArrayEnumColumn() Columnar { return new(ArrayArrayEnumColumn) } func (c *ArrayArrayEnumColumn) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayEnumColumn) Type() reflect.Type { return reflect.TypeOf((*[][]string)(nil)).Elem() } func (c *ArrayArrayEnumColumn) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayEnumColumn) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayEnumColumn) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayEnumColumn) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayEnumColumn) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil } type DateTimeColumn struct { ColumnOf[time.Time] } var _ Columnar = (*DateTimeColumn)(nil) func NewDateTimeColumn() Columnar { return new(DateTimeColumn) } var _DateTimeType = reflect.TypeOf((*time.Time)(nil)).Elem() func (c *DateTimeColumn) Type() reflect.Type { return _DateTimeType } func (c *DateTimeColumn) ReadFrom(rd *chproto.Reader, numRow int) error { c.AllocForReading(numRow) for i := range c.Column { n, err := rd.DateTime() if err != nil { return err } c.Column[i] = n } return nil } func (c *DateTimeColumn) WriteTo(wr *chproto.Writer) error { for _, n := range c.Column { wr.DateTime(n) } return nil } //------------------------------------------------------------------------------ type ArrayDateTimeColumn struct { ColumnOf[[]time.Time] elem DateTimeColumn } var ( _ Columnar = (*ArrayDateTimeColumn)(nil) _ ArrayColumnar = (*ArrayDateTimeColumn)(nil) ) func NewArrayDateTimeColumn() Columnar { return new(ArrayDateTimeColumn) } func (c *ArrayDateTimeColumn) Init(chType string) error { return c.elem.Init(chArrayElemType(chType)) } func (c *ArrayDateTimeColumn) Type() reflect.Type { return reflect.TypeOf((*[]time.Time)(nil)).Elem() } func (c *ArrayDateTimeColumn) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayDateTimeColumn) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayDateTimeColumn) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayDateTimeColumn) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } return offset } func (c *ArrayDateTimeColumn) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteTo(wr); err != nil { return err } } return nil } //------------------------------------------------------------------------------ type ArrayArrayDateTimeColumn struct { ColumnOf[[][]time.Time] elem ArrayDateTimeColumn } var ( _ Columnar = (*ArrayArrayDateTimeColumn)(nil) _ ArrayColumnar = (*ArrayArrayDateTimeColumn)(nil) ) func NewArrayArrayDateTimeColumn() Columnar { return new(ArrayArrayDateTimeColumn) } func (c *ArrayArrayDateTimeColumn) Init(chType string) error { return c.elem.Init(chArrayElemType(chArrayElemType(chType))) } func (c *ArrayArrayDateTimeColumn) Type() reflect.Type { return reflect.TypeOf((*[][]time.Time)(nil)).Elem() } func (c *ArrayArrayDateTimeColumn) ReadFrom(rd *chproto.Reader, numRow int) error { if numRow == 0 { return nil } c.AllocForReading(numRow) offsets, err := c.readOffsets(rd, numRow) if err != nil { return err } if err := c.elem.ReadFrom(rd, offsets[len(offsets)-1]); err != nil { return err } var prev int for i, offset := range offsets { c.Column[i] = c.elem.Column[prev:offset] prev = offset } return nil } func (c *ArrayArrayDateTimeColumn) readOffsets(rd *chproto.Reader, numRow int) ([]int, error) { offsets := make([]int, numRow) for i := range offsets { offset, err := rd.UInt64() if err != nil { return nil, err } offsets[i] = int(offset) } return offsets, nil } func (c *ArrayArrayDateTimeColumn) WriteTo(wr *chproto.Writer) error { _ = c.WriteOffset(wr, 0) return c.WriteData(wr) } func (c *ArrayArrayDateTimeColumn) WriteOffset(wr *chproto.Writer, offset int) int { for _, el := range c.Column { offset += len(el) wr.UInt64(uint64(offset)) } offset = 0 for _, elem := range c.Column { c.elem.Column = elem offset = c.elem.WriteOffset(wr, offset) } return offset } func (c *ArrayArrayDateTimeColumn) WriteData(wr *chproto.Writer) error { for _, ss := range c.Column { c.elem.Column = ss if err := c.elem.WriteData(wr); err != nil { return err } } return nil }