1
0
mirror of https://github.com/uptrace/go-clickhouse.git synced 2025-06-08 23:26:11 +02:00
go-clickhouse/ch/chschema/column_gen.go
2023-01-21 12:14:00 +02:00

3009 lines
60 KiB
Go

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
}