mirror of
https://github.com/uptrace/go-clickhouse.git
synced 2025-06-08 23:26:11 +02:00
352 lines
6.4 KiB
Go
352 lines
6.4 KiB
Go
//go:build amd64 || arm64
|
|
|
|
package chschema
|
|
|
|
import (
|
|
"io"
|
|
"reflect"
|
|
"unsafe"
|
|
|
|
"github.com/uptrace/go-clickhouse/ch/chproto"
|
|
)
|
|
|
|
func (c *Int8Column) ReadFrom(rd *chproto.Reader, numRow int) error {
|
|
const size = 8 / 8
|
|
|
|
if numRow == 0 {
|
|
return nil
|
|
}
|
|
|
|
c.AllocForReading(numRow)
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
dest := *(*[]byte)(unsafe.Pointer(&slice))
|
|
_, err := io.ReadFull(rd, dest)
|
|
return err
|
|
}
|
|
|
|
func (c *Int8Column) WriteTo(wr *chproto.Writer) error {
|
|
const size = 8 / 8
|
|
|
|
if len(c.Column) == 0 {
|
|
return nil
|
|
}
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
src := *(*[]byte)(unsafe.Pointer(&slice))
|
|
wr.Write(src)
|
|
return nil
|
|
}
|
|
|
|
func (c *UInt8Column) ReadFrom(rd *chproto.Reader, numRow int) error {
|
|
const size = 8 / 8
|
|
|
|
if numRow == 0 {
|
|
return nil
|
|
}
|
|
|
|
c.AllocForReading(numRow)
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
dest := *(*[]byte)(unsafe.Pointer(&slice))
|
|
_, err := io.ReadFull(rd, dest)
|
|
return err
|
|
}
|
|
|
|
func (c *UInt8Column) WriteTo(wr *chproto.Writer) error {
|
|
const size = 8 / 8
|
|
|
|
if len(c.Column) == 0 {
|
|
return nil
|
|
}
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
src := *(*[]byte)(unsafe.Pointer(&slice))
|
|
wr.Write(src)
|
|
return nil
|
|
}
|
|
|
|
func (c *Int16Column) ReadFrom(rd *chproto.Reader, numRow int) error {
|
|
const size = 16 / 8
|
|
|
|
if numRow == 0 {
|
|
return nil
|
|
}
|
|
|
|
c.AllocForReading(numRow)
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
dest := *(*[]byte)(unsafe.Pointer(&slice))
|
|
_, err := io.ReadFull(rd, dest)
|
|
return err
|
|
}
|
|
|
|
func (c *Int16Column) WriteTo(wr *chproto.Writer) error {
|
|
const size = 16 / 8
|
|
|
|
if len(c.Column) == 0 {
|
|
return nil
|
|
}
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
src := *(*[]byte)(unsafe.Pointer(&slice))
|
|
wr.Write(src)
|
|
return nil
|
|
}
|
|
|
|
func (c *UInt16Column) ReadFrom(rd *chproto.Reader, numRow int) error {
|
|
const size = 16 / 8
|
|
|
|
if numRow == 0 {
|
|
return nil
|
|
}
|
|
|
|
c.AllocForReading(numRow)
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
dest := *(*[]byte)(unsafe.Pointer(&slice))
|
|
_, err := io.ReadFull(rd, dest)
|
|
return err
|
|
}
|
|
|
|
func (c *UInt16Column) WriteTo(wr *chproto.Writer) error {
|
|
const size = 16 / 8
|
|
|
|
if len(c.Column) == 0 {
|
|
return nil
|
|
}
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
src := *(*[]byte)(unsafe.Pointer(&slice))
|
|
wr.Write(src)
|
|
return nil
|
|
}
|
|
|
|
func (c *Int32Column) ReadFrom(rd *chproto.Reader, numRow int) error {
|
|
const size = 32 / 8
|
|
|
|
if numRow == 0 {
|
|
return nil
|
|
}
|
|
|
|
c.AllocForReading(numRow)
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
dest := *(*[]byte)(unsafe.Pointer(&slice))
|
|
_, err := io.ReadFull(rd, dest)
|
|
return err
|
|
}
|
|
|
|
func (c *Int32Column) WriteTo(wr *chproto.Writer) error {
|
|
const size = 32 / 8
|
|
|
|
if len(c.Column) == 0 {
|
|
return nil
|
|
}
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
src := *(*[]byte)(unsafe.Pointer(&slice))
|
|
wr.Write(src)
|
|
return nil
|
|
}
|
|
|
|
func (c *UInt32Column) ReadFrom(rd *chproto.Reader, numRow int) error {
|
|
const size = 32 / 8
|
|
|
|
if numRow == 0 {
|
|
return nil
|
|
}
|
|
|
|
c.AllocForReading(numRow)
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
dest := *(*[]byte)(unsafe.Pointer(&slice))
|
|
_, err := io.ReadFull(rd, dest)
|
|
return err
|
|
}
|
|
|
|
func (c *UInt32Column) WriteTo(wr *chproto.Writer) error {
|
|
const size = 32 / 8
|
|
|
|
if len(c.Column) == 0 {
|
|
return nil
|
|
}
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
src := *(*[]byte)(unsafe.Pointer(&slice))
|
|
wr.Write(src)
|
|
return nil
|
|
}
|
|
|
|
func (c *Int64Column) ReadFrom(rd *chproto.Reader, numRow int) error {
|
|
const size = 64 / 8
|
|
|
|
if numRow == 0 {
|
|
return nil
|
|
}
|
|
|
|
c.AllocForReading(numRow)
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
dest := *(*[]byte)(unsafe.Pointer(&slice))
|
|
_, err := io.ReadFull(rd, dest)
|
|
return err
|
|
}
|
|
|
|
func (c *Int64Column) WriteTo(wr *chproto.Writer) error {
|
|
const size = 64 / 8
|
|
|
|
if len(c.Column) == 0 {
|
|
return nil
|
|
}
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
src := *(*[]byte)(unsafe.Pointer(&slice))
|
|
wr.Write(src)
|
|
return nil
|
|
}
|
|
|
|
func (c *UInt64Column) ReadFrom(rd *chproto.Reader, numRow int) error {
|
|
const size = 64 / 8
|
|
|
|
if numRow == 0 {
|
|
return nil
|
|
}
|
|
|
|
c.AllocForReading(numRow)
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
dest := *(*[]byte)(unsafe.Pointer(&slice))
|
|
_, err := io.ReadFull(rd, dest)
|
|
return err
|
|
}
|
|
|
|
func (c *UInt64Column) WriteTo(wr *chproto.Writer) error {
|
|
const size = 64 / 8
|
|
|
|
if len(c.Column) == 0 {
|
|
return nil
|
|
}
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
src := *(*[]byte)(unsafe.Pointer(&slice))
|
|
wr.Write(src)
|
|
return nil
|
|
}
|
|
|
|
func (c *Float32Column) ReadFrom(rd *chproto.Reader, numRow int) error {
|
|
const size = 32 / 8
|
|
|
|
if numRow == 0 {
|
|
return nil
|
|
}
|
|
|
|
c.AllocForReading(numRow)
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
dest := *(*[]byte)(unsafe.Pointer(&slice))
|
|
_, err := io.ReadFull(rd, dest)
|
|
return err
|
|
}
|
|
|
|
func (c *Float32Column) WriteTo(wr *chproto.Writer) error {
|
|
const size = 32 / 8
|
|
|
|
if len(c.Column) == 0 {
|
|
return nil
|
|
}
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
src := *(*[]byte)(unsafe.Pointer(&slice))
|
|
wr.Write(src)
|
|
return nil
|
|
}
|
|
|
|
func (c *Float64Column) ReadFrom(rd *chproto.Reader, numRow int) error {
|
|
const size = 64 / 8
|
|
|
|
if numRow == 0 {
|
|
return nil
|
|
}
|
|
|
|
c.AllocForReading(numRow)
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
dest := *(*[]byte)(unsafe.Pointer(&slice))
|
|
_, err := io.ReadFull(rd, dest)
|
|
return err
|
|
}
|
|
|
|
func (c *Float64Column) WriteTo(wr *chproto.Writer) error {
|
|
const size = 64 / 8
|
|
|
|
if len(c.Column) == 0 {
|
|
return nil
|
|
}
|
|
|
|
slice := *(*reflect.SliceHeader)(unsafe.Pointer(&c.Column))
|
|
slice.Len *= size
|
|
slice.Cap *= size
|
|
|
|
src := *(*[]byte)(unsafe.Pointer(&slice))
|
|
wr.Write(src)
|
|
return nil
|
|
}
|