Merge pull request #1605 from ClickHouse/server_info_for_columns

include server revision in block/column parsing

Author: SpencerTorres

clickhouse_rows_test.go

@@ -1,6 +1,7 @@
 package clickhouse
 
 import (
+	"github.com/ClickHouse/clickhouse-go/v2/lib/column"
 	"github.com/ClickHouse/clickhouse-go/v2/lib/proto"
 	"github.com/stretchr/testify/assert"
 	"strconv"
@@ -10,9 +11,9 @@ import (
 func TestReadWithEmptyBlock(t *testing.T) {
 	blockInitFunc := func() *proto.Block {
 		retVal := &proto.Block{
-			Packet:   0,
-			Columns:  nil,
-			Timezone: nil,
+			Packet:        0,
+			Columns:       nil,
+			ServerContext: &column.ServerContext{},
 		}
 		retVal.AddColumn("col1", ("Int64"))
 		retVal.AddColumn("col2", ("String"))

conn.go

@@ -22,6 +22,7 @@ import (
 	"crypto/tls"
 	"errors"
 	"fmt"
+	"github.com/ClickHouse/clickhouse-go/v2/lib/column"
 	"io"
 	"log"
 	"net"
@@ -356,6 +357,16 @@ func (c *connect) sendData(block *proto.Block, name string) error {
 	return nil
 }
 
+func serverVersionToContext(v ServerVersion) column.ServerContext {
+	return column.ServerContext{
+		Revision:     v.Revision,
+		VersionMajor: v.Version.Major,
+		VersionMinor: v.Version.Minor,
+		VersionPatch: v.Version.Patch,
+		Timezone:     v.Timezone,
+	}
+}
+
 func (c *connect) readData(ctx context.Context, packet byte, compressible bool) (*proto.Block, error) {
 	if c.isClosed() {
 		err := errors.New("attempted reading on closed connection")
@@ -385,7 +396,9 @@ func (c *connect) readData(ctx context.Context, packet byte, compressible bool)
 		location = userLocation
 	}
 
-	block := proto.Block{Timezone: location}
+	serverContext := serverVersionToContext(c.server)
+	serverContext.Timezone = location
+	block := proto.Block{ServerContext: &serverContext}
 	if err := block.Decode(c.reader, c.revision); err != nil {
 		c.debugf("[read data] decode error: %v", err)
 		return nil, err

conn_batch.go

@@ -321,7 +321,7 @@ func (b *batch) Columns() []column.Interface {
 }
 
 func (b *batch) closeQuery() error {
-	if err := b.conn.sendData(&proto.Block{}, ""); err != nil {
+	if err := b.conn.sendData(proto.NewBlock(), ""); err != nil {
 		return err
 	}
 

conn_http.go

@@ -429,7 +429,9 @@ func (h *httpConnect) readData(reader *chproto.Reader, timezone *time.Location)
 		location = timezone
 	}
 
-	block := proto.Block{Timezone: location}
+	serverContext := serverVersionToContext(h.handshake)
+	serverContext.Timezone = location
+	block := proto.Block{ServerContext: &serverContext}
 	if h.compression == CompressionLZ4 || h.compression == CompressionZSTD {
 		reader.EnableCompression()
 		defer reader.DisableCompression()

conn_http_batch.go

@@ -107,6 +107,8 @@ func newBlock(h *httpConnect, release nativeTransportRelease, ctx context.Contex
 	}
 
 	var block proto.Block
+	serverContext := serverVersionToContext(h.handshake)
+	block.ServerContext = &serverContext
 	for _, col := range columns {
 		if err := block.AddColumn(col.Name, column.Type(col.Type)); err != nil {
 			return "", nil, err

conn_http_query.go

@@ -55,7 +55,7 @@ func (h *httpConnect) query(ctx context.Context, release nativeTransportRelease,
 
 	if res.ContentLength == 0 {
 		discardAndClose(res.Body)
-		block := &proto.Block{}
+		block := proto.NewBlock()
 		release(h, nil)
 		return &rows{
 			block:     block,
@@ -122,7 +122,7 @@ func (h *httpConnect) query(ctx context.Context, release nativeTransportRelease,
 	}()
 
 	if block == nil {
-		block = &proto.Block{}
+		block = proto.NewBlock()
 	}
 
 	return &rows{

conn_send_query.go

@@ -47,7 +47,7 @@ func (c *connect) sendQuery(body string, o *QueryOptions) error {
 			return err
 		}
 	}
-	if err := c.sendData(&proto.Block{}, ""); err != nil {
+	if err := c.sendData(proto.NewBlock(), ""); err != nil {
 		return err
 	}
 	return c.flush()

ext/ext.go

@@ -27,7 +27,7 @@ import (
 func NewTable(name string, columns ...func(t *Table) error) (*Table, error) {
 	table := &Table{
 		name:  name,
-		block: &proto.Block{},
+		block: proto.NewBlock(),
 	}
 	for _, column := range columns {
 		if err := column(table); err != nil {

lib/column/array.go

@@ -23,7 +23,6 @@ import (
 	"github.com/ClickHouse/ch-go/proto"
 	"reflect"
 	"strings"
-	"time"
 )
 
 var scanTypeAny = reflect.TypeOf((*interface{})(nil)).Elem()
@@ -53,7 +52,7 @@ func (col *Array) Name() string {
 	return col.name
 }
 
-func (col *Array) parse(t Type, tz *time.Location) (_ *Array, err error) {
+func (col *Array) parse(t Type, sc *ServerContext) (_ *Array, err error) {
 	col.chType = t
 	var typeStr = string(t)
 
@@ -69,7 +68,7 @@ parse:
 		}
 	}
 	if col.depth != 0 {
-		if col.values, err = Type(typeStr).Column(col.name, tz); err != nil {
+		if col.values, err = Type(typeStr).Column(col.name, sc); err != nil {
 			return nil, err
 		}
 		offsetScanTypes := make([]reflect.Type, 0, col.depth)

lib/column/codegen/column.tpl

@@ -36,7 +36,7 @@ import (
 	"github.com/ClickHouse/clickhouse-go/v2/lib/chcol"
 )
 
-func (t Type) Column(name string, tz *time.Location) (Interface, error) {
+func (t Type) Column(name string, sc *ServerContext) (Interface, error) {
 	switch t {
 {{- range . }}
 	case "{{ .ChType }}":
@@ -81,15 +81,15 @@ func (t Type) Column(name string, tz *time.Location) (Interface, error) {
 	case "Bool", "Boolean":
 		return &Bool{name: name}, nil
 	case "Date":
-		return &Date{name: name, location: tz}, nil
+		return &Date{name: name, location: sc.Timezone}, nil
 	case "Date32":
-		return &Date32{name: name, location: tz}, nil
+		return &Date32{name: name, location: sc.Timezone}, nil
 	case "UUID":
 		return &UUID{name: name}, nil
 	case "Nothing":
 		return &Nothing{name: name}, nil
 	case "Ring":
-		set, err := (&Array{name: name}).parse("Array(Point)", tz)
+		set, err := (&Array{name: name}).parse("Array(Point)", sc)
         if err != nil {
             return nil, err
         }
@@ -99,7 +99,7 @@ func (t Type) Column(name string, tz *time.Location) (Interface, error) {
             name: name,
         }, nil
 	case "Polygon":
-		set, err := (&Array{name: name}).parse("Array(Ring)", tz)
+		set, err := (&Array{name: name}).parse("Array(Ring)", sc)
         if err != nil {
             return nil, err
         }
@@ -109,7 +109,7 @@ func (t Type) Column(name string, tz *time.Location) (Interface, error) {
             name: name,
         }, nil
 	case "MultiPolygon":
-		set, err := (&Array{name: name}).parse("Array(Polygon)", tz)
+		set, err := (&Array{name: name}).parse("Array(Polygon)", sc)
         if err != nil {
             return nil, err
         }
@@ -123,42 +123,42 @@ func (t Type) Column(name string, tz *time.Location) (Interface, error) {
 	case "String":
 		return &String{name: name, col: colStrProvider(name)}, nil
 	case "Object('json')":
-	    return &JSONObject{name: name, root: true, tz: tz}, nil
+	    return &JSONObject{name: name, root: true, sc: sc}, nil
 	}
 
 	switch strType := string(t); {
 	case strings.HasPrefix(string(t), "Map("):
-		return (&Map{name: name}).parse(t, tz)
+		return (&Map{name: name}).parse(t, sc)
 	case strings.HasPrefix(string(t), "Tuple("):
-		return (&Tuple{name: name}).parse(t, tz)
+		return (&Tuple{name: name}).parse(t, sc)
 	case strings.HasPrefix(string(t), "Variant("):
-		return (&Variant{name: name}).parse(t, tz)
+		return (&Variant{name: name}).parse(t, sc)
 	case strings.HasPrefix(string(t), "Dynamic"):
-		return (&Dynamic{name: name}).parse(t, tz)
+		return (&Dynamic{name: name}).parse(t, sc)
 	case strings.HasPrefix(string(t), "JSON"):
-		return (&JSON{name: name}).parse(t, tz)
+		return (&JSON{name: name}).parse(t, sc)
 	case strings.HasPrefix(string(t), "Decimal("):
 		return (&Decimal{name: name}).parse(t)
 	case strings.HasPrefix(strType, "Nested("):
-		return (&Nested{name: name}).parse(t, tz)
+		return (&Nested{name: name}).parse(t, sc)
 	case strings.HasPrefix(string(t), "Array("):
-		return (&Array{name: name}).parse(t, tz)
+		return (&Array{name: name}).parse(t, sc)
 	case strings.HasPrefix(string(t), "Interval"):
 		return (&Interval{name: name}).parse(t)
 	case strings.HasPrefix(string(t), "Nullable"):
-		return (&Nullable{name: name}).parse(t, tz)
+		return (&Nullable{name: name}).parse(t, sc)
 	case strings.HasPrefix(string(t), "FixedString"):
 		return (&FixedString{name: name}).parse(t)
 	case strings.HasPrefix(string(t), "LowCardinality"):
-		return (&LowCardinality{name: name}).parse(t, tz)
+		return (&LowCardinality{name: name}).parse(t, sc)
 	case strings.HasPrefix(string(t), "SimpleAggregateFunction"):
-		return (&SimpleAggregateFunction{name: name}).parse(t, tz)
+		return (&SimpleAggregateFunction{name: name}).parse(t, sc)
 	case strings.HasPrefix(string(t), "Enum8") || strings.HasPrefix(string(t), "Enum16"):
 		return Enum(t, name)
 	case strings.HasPrefix(string(t), "DateTime64"):
-		return (&DateTime64{name: name}).parse(t, tz)
+		return (&DateTime64{name: name}).parse(t, sc.Timezone)
 	case strings.HasPrefix(strType, "DateTime") && !strings.HasPrefix(strType, "DateTime64"):
-		return (&DateTime{name: name}).parse(t, tz)
+		return (&DateTime{name: name}).parse(t, sc.Timezone)
 	}
 	return nil, &UnsupportedColumnTypeError{
 		t: t,