mirror of
https://github.com/uptrace/go-clickhouse.git
synced 2025-06-12 23:37:29 +02:00
3009 lines
60 KiB
Go
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
|
|
}
|