TUN-2243: Revert "STOR-519: Add db-connect, a SQL over HTTPS server"

This reverts commit 5da2109811.

vendor/github.com/kshvakov/clickhouse/lib/column/array.go

@@ -1,124 +0,0 @@
-package column
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"time"
-
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type Array struct {
-	base
-	depth  int
-	column Column
-}
-
-func (array *Array) Read(decoder *binary.Decoder) (interface{}, error) {
-	return nil, fmt.Errorf("do not use Read method for Array(T) column")
-}
-
-func (array *Array) Write(encoder *binary.Encoder, v interface{}) error {
-	return array.column.Write(encoder, v)
-}
-
-func (array *Array) ReadArray(decoder *binary.Decoder, rows int) (_ []interface{}, err error) {
-	var (
-		values  = make([]interface{}, rows)
-		offsets = make([]uint64, rows)
-	)
-	for i := 0; i < rows; i++ {
-		offset, err := decoder.UInt64()
-		if err != nil {
-			return nil, err
-		}
-		offsets[i] = offset
-	}
-	for n, offset := range offsets {
-		ln := offset
-		if n != 0 {
-			ln = ln - offsets[n-1]
-		}
-		if values[n], err = array.read(decoder, int(ln)); err != nil {
-			return nil, err
-		}
-	}
-	return values, nil
-}
-
-func (array *Array) read(decoder *binary.Decoder, ln int) (interface{}, error) {
-	slice := reflect.MakeSlice(array.valueOf.Type(), 0, ln)
-	for i := 0; i < ln; i++ {
-		value, err := array.column.Read(decoder)
-		if err != nil {
-			return nil, err
-		}
-		slice = reflect.Append(slice, reflect.ValueOf(value))
-	}
-	return slice.Interface(), nil
-}
-
-func parseArray(name, chType string, timezone *time.Location) (*Array, error) {
-	if len(chType) < 11 {
-		return nil, fmt.Errorf("invalid Array column type: %s", chType)
-	}
-	var (
-		depth      int
-		columnType = chType
-	)
-
-loop:
-	for _, str := range strings.Split(chType, "Array(") {
-		switch {
-		case len(str) == 0:
-			depth++
-		default:
-			chType = str[:len(str)-depth]
-			break loop
-		}
-	}
-	column, err := Factory(name, chType, timezone)
-	if err != nil {
-		return nil, fmt.Errorf("Array(T): %v", err)
-	}
-
-	var scanType interface{}
-	switch t := column.ScanType().Kind(); t {
-	case reflect.Int8:
-		scanType = []int8{}
-	case reflect.Int16:
-		scanType = []int16{}
-	case reflect.Int32:
-		scanType = []int32{}
-	case reflect.Int64:
-		scanType = []int64{}
-	case reflect.Uint8:
-		scanType = []uint8{}
-	case reflect.Uint16:
-		scanType = []uint16{}
-	case reflect.Uint32:
-		scanType = []uint32{}
-	case reflect.Uint64:
-		scanType = []uint64{}
-	case reflect.Float32:
-		scanType = []float32{}
-	case reflect.Float64:
-		scanType = []float64{}
-	case reflect.String:
-		scanType = []string{}
-	case baseTypes[time.Time{}].Kind():
-		scanType = []time.Time{}
-	default:
-		return nil, fmt.Errorf("unsupported Array type '%s'", column.ScanType().Name())
-	}
-	return &Array{
-		base: base{
-			name:    name,
-			chType:  columnType,
-			valueOf: reflect.ValueOf(scanType),
-		},
-		depth:  depth,
-		column: column,
-	}, nil
-}

vendor/github.com/kshvakov/clickhouse/lib/column/column.go

@@ -1,168 +0,0 @@
-package column
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"time"
-
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type Column interface {
-	Name() string
-	CHType() string
-	ScanType() reflect.Type
-	Read(*binary.Decoder) (interface{}, error)
-	Write(*binary.Encoder, interface{}) error
-	defaultValue() interface{}
-}
-
-func Factory(name, chType string, timezone *time.Location) (Column, error) {
-	switch chType {
-	case "Int8":
-		return &Int8{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[int8(0)],
-			},
-		}, nil
-	case "Int16":
-		return &Int16{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[int16(0)],
-			},
-		}, nil
-	case "Int32":
-		return &Int32{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[int32(0)],
-			},
-		}, nil
-	case "Int64":
-		return &Int64{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[int64(0)],
-			},
-		}, nil
-	case "UInt8":
-		return &UInt8{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[uint8(0)],
-			},
-		}, nil
-	case "UInt16":
-		return &UInt16{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[uint16(0)],
-			},
-		}, nil
-	case "UInt32":
-		return &UInt32{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[uint32(0)],
-			},
-		}, nil
-	case "UInt64":
-		return &UInt64{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[uint64(0)],
-			},
-		}, nil
-	case "Float32":
-		return &Float32{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[float32(0)],
-			},
-		}, nil
-	case "Float64":
-		return &Float64{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[float64(0)],
-			},
-		}, nil
-	case "String":
-		return &String{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[string("")],
-			},
-		}, nil
-	case "UUID":
-		return &UUID{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[string("")],
-			},
-		}, nil
-	case "Date":
-		_, offset := time.Unix(0, 0).In(timezone).Zone()
-		return &Date{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[time.Time{}],
-			},
-			Timezone: timezone,
-			offset:   int64(offset),
-		}, nil
-	case "DateTime":
-		return &DateTime{
-			base: base{
-				name:    name,
-				chType:  chType,
-				valueOf: baseTypes[time.Time{}],
-			},
-			Timezone: timezone,
-		}, nil
-	case "IPv4":
-		return &IPv4{
-			base: base{
-				name:   name,
-				chType: chType,
-			},
-		}, nil
-	case "IPv6":
-		return &IPv6{
-			base: base{
-				name:   name,
-				chType: chType,
-			},
-		}, nil
-	}
-
-	switch {
-	case strings.HasPrefix(chType, "Array"):
-		return parseArray(name, chType, timezone)
-	case strings.HasPrefix(chType, "Nullable"):
-		return parseNullable(name, chType, timezone)
-	case strings.HasPrefix(chType, "FixedString"):
-		return parseFixedString(name, chType)
-	case strings.HasPrefix(chType, "Enum8"), strings.HasPrefix(chType, "Enum16"):
-		return parseEnum(name, chType)
-	case strings.HasPrefix(chType, "Decimal"):
-		return parseDecimal(name, chType)
-	}
-	return nil, fmt.Errorf("column: unhandled type %v", chType)
-}

vendor/github.com/kshvakov/clickhouse/lib/column/common.go

@@ -1,56 +0,0 @@
-package column
-
-import (
-	"fmt"
-	"reflect"
-	"time"
-)
-
-type ErrUnexpectedType struct {
-	Column Column
-	T      interface{}
-}
-
-func (err *ErrUnexpectedType) Error() string {
-	return fmt.Sprintf("%s: unexpected type %T", err.Column, err.T)
-}
-
-var baseTypes = map[interface{}]reflect.Value{
-	int8(0):     reflect.ValueOf(int8(0)),
-	int16(0):    reflect.ValueOf(int16(0)),
-	int32(0):    reflect.ValueOf(int32(0)),
-	int64(0):    reflect.ValueOf(int64(0)),
-	uint8(0):    reflect.ValueOf(uint8(0)),
-	uint16(0):   reflect.ValueOf(uint16(0)),
-	uint32(0):   reflect.ValueOf(uint32(0)),
-	uint64(0):   reflect.ValueOf(uint64(0)),
-	float32(0):  reflect.ValueOf(float32(0)),
-	float64(0):  reflect.ValueOf(float64(0)),
-	string(""):  reflect.ValueOf(string("")),
-	time.Time{}: reflect.ValueOf(time.Time{}),
-}
-
-type base struct {
-	name, chType string
-	valueOf      reflect.Value
-}
-
-func (base *base) Name() string {
-	return base.name
-}
-
-func (base *base) CHType() string {
-	return base.chType
-}
-
-func (base *base) ScanType() reflect.Type {
-	return base.valueOf.Type()
-}
-
-func (base *base) defaultValue() interface{} {
-	return base.valueOf.Interface()
-}
-
-func (base *base) String() string {
-	return fmt.Sprintf("%s (%s)", base.name, base.chType)
-}

vendor/github.com/kshvakov/clickhouse/lib/column/date.go

@@ -1,80 +0,0 @@
-package column
-
-import (
-	"time"
-
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type Date struct {
-	base
-	Timezone *time.Location
-	offset   int64
-}
-
-func (dt *Date) Read(decoder *binary.Decoder) (interface{}, error) {
-	sec, err := decoder.Int16()
-	if err != nil {
-		return nil, err
-	}
-	return time.Unix(int64(sec)*24*3600-dt.offset, 0).In(dt.Timezone), nil
-}
-
-func (dt *Date) Write(encoder *binary.Encoder, v interface{}) error {
-	var timestamp int64
-	switch value := v.(type) {
-	case time.Time:
-		_, offset := value.Zone()
-		timestamp = value.Unix() + int64(offset)
-	case int16:
-		return encoder.Int16(value)
-	case int32:
-		timestamp = int64(value) + dt.offset
-	case int64:
-		timestamp = value + dt.offset
-	case string:
-		var err error
-		timestamp, err = dt.parse(value)
-		if err != nil {
-			return err
-		}
-
-	// this relies on Nullable never sending nil values through
-	case *time.Time:
-		_, offset := value.Zone()
-		timestamp = (*value).Unix() + int64(offset)
-	case *int16:
-		return encoder.Int16(*value)
-	case *int32:
-		timestamp = int64(*value) + dt.offset
-	case *int64:
-		timestamp = *value + dt.offset
-	case *string:
-		var err error
-		timestamp, err = dt.parse(*value)
-		if err != nil {
-			return err
-		}
-
-	default:
-		return &ErrUnexpectedType{
-			T:      v,
-			Column: dt,
-		}
-	}
-
-	return encoder.Int16(int16(timestamp / 24 / 3600))
-}
-
-func (dt *Date) parse(value string) (int64, error) {
-	tv, err := time.Parse("2006-01-02", value)
-	if err != nil {
-		return 0, err
-	}
-	return time.Date(
-		time.Time(tv).Year(),
-		time.Time(tv).Month(),
-		time.Time(tv).Day(),
-		0, 0, 0, 0, time.UTC,
-	).Unix(), nil
-}

vendor/github.com/kshvakov/clickhouse/lib/column/datetime.go

@@ -1,83 +0,0 @@
-package column
-
-import (
-	"time"
-
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type DateTime struct {
-	base
-	Timezone *time.Location
-}
-
-func (dt *DateTime) Read(decoder *binary.Decoder) (interface{}, error) {
-	sec, err := decoder.Int32()
-	if err != nil {
-		return nil, err
-	}
-	return time.Unix(int64(sec), 0).In(dt.Timezone), nil
-}
-
-func (dt *DateTime) Write(encoder *binary.Encoder, v interface{}) error {
-	var timestamp int64
-	switch value := v.(type) {
-	case time.Time:
-		if !value.IsZero() {
-			timestamp = value.Unix()
-		}
-	case int16:
-		timestamp = int64(value)
-	case int32:
-		timestamp = int64(value)
-	case int64:
-		timestamp = value
-	case string:
-		var err error
-		timestamp, err = dt.parse(value)
-		if err != nil {
-			return err
-		}
-
-	case *time.Time:
-		if value != nil && !(*value).IsZero() {
-			timestamp = (*value).Unix()
-		}
-	case *int16:
-		timestamp = int64(*value)
-	case *int32:
-		timestamp = int64(*value)
-	case *int64:
-		timestamp = *value
-	case *string:
-		var err error
-		timestamp, err = dt.parse(*value)
-		if err != nil {
-			return err
-		}
-
-	default:
-		return &ErrUnexpectedType{
-			T:      v,
-			Column: dt,
-		}
-	}
-
-	return encoder.Int32(int32(timestamp))
-}
-
-func (dt *DateTime) parse(value string) (int64, error) {
-	tv, err := time.Parse("2006-01-02 15:04:05", value)
-	if err != nil {
-		return 0, err
-	}
-	return time.Date(
-		time.Time(tv).Year(),
-		time.Time(tv).Month(),
-		time.Time(tv).Day(),
-		time.Time(tv).Hour(),
-		time.Time(tv).Minute(),
-		time.Time(tv).Second(),
-		0, time.UTC,
-	).Unix(), nil
-}

vendor/github.com/kshvakov/clickhouse/lib/column/decimal.go

@@ -1,241 +0,0 @@
-package column
-
-import (
-	"errors"
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-// Table of powers of 10 for fast casting from floating types to decimal type
-// representations.
-var factors10 = []float64{
-	1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13,
-	1e14, 1e15, 1e16, 1e17, 1e18,
-}
-
-// Decimal represents Decimal(P, S) ClickHouse. Since there is support for
-// int128 in Golang, the implementation does not support to 128-bits decimals
-// as well. Decimal is represented as integral. Also floating-point types are
-// supported for query parameters.
-type Decimal struct {
-	base
-	nobits    int // its domain is {32, 64}
-	precision int
-	scale     int
-}
-
-func (d *Decimal) Read(decoder *binary.Decoder) (interface{}, error) {
-	switch d.nobits {
-	case 32:
-		return decoder.Int32()
-	case 64:
-		return decoder.Int64()
-	default:
-		return nil, errors.New("unachievable execution path")
-	}
-}
-
-func (d *Decimal) Write(encoder *binary.Encoder, v interface{}) error {
-	switch d.nobits {
-	case 32:
-		return d.write32(encoder, v)
-	case 64:
-		return d.write64(encoder, v)
-	default:
-		return errors.New("unachievable execution path")
-	}
-}
-
-func (d *Decimal) float2int32(floating float64) int32 {
-	fixed := int32(floating * factors10[d.scale])
-	return fixed
-}
-
-func (d *Decimal) float2int64(floating float64) int64 {
-	fixed := int64(floating * factors10[d.scale])
-	return fixed
-}
-
-func (d *Decimal) write32(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case int8:
-		return encoder.Int32(int32(v))
-	case int16:
-		return encoder.Int32(int32(v))
-	case int32:
-		return encoder.Int32(int32(v))
-	case int64:
-		return errors.New("narrowing type conversion from int64 to int32")
-
-	case uint8:
-		return encoder.Int32(int32(v))
-	case uint16:
-		return encoder.Int32(int32(v))
-	case uint32:
-		return errors.New("narrowing type conversion from uint32 to int32")
-	case uint64:
-		return errors.New("narrowing type conversion from uint64 to int32")
-
-	case float32:
-		fixed := d.float2int32(float64(v))
-		return encoder.Int32(fixed)
-	case float64:
-		fixed := d.float2int32(float64(v))
-		return encoder.Int32(fixed)
-
-	// this relies on Nullable never sending nil values through
-	case *int8:
-		return encoder.Int32(int32(*v))
-	case *int16:
-		return encoder.Int32(int32(*v))
-	case *int32:
-		return encoder.Int32(int32(*v))
-	case *int64:
-		return errors.New("narrowing type conversion from int64 to int32")
-
-	case *uint8:
-		return encoder.Int32(int32(*v))
-	case *uint16:
-		return encoder.Int32(int32(*v))
-	case *uint32:
-		return errors.New("narrowing type conversion from uint32 to int32")
-	case *uint64:
-		return errors.New("narrowing type conversion from uint64 to int32")
-
-	case *float32:
-		fixed := d.float2int32(float64(*v))
-		return encoder.Int32(fixed)
-	case *float64:
-		fixed := d.float2int32(float64(*v))
-		return encoder.Int32(fixed)
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: d,
-	}
-}
-
-func (d *Decimal) write64(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case int:
-		return encoder.Int64(int64(v))
-	case int8:
-		return encoder.Int64(int64(v))
-	case int16:
-		return encoder.Int64(int64(v))
-	case int32:
-		return encoder.Int64(int64(v))
-	case int64:
-		return encoder.Int64(int64(v))
-
-	case uint8:
-		return encoder.Int64(int64(v))
-	case uint16:
-		return encoder.Int64(int64(v))
-	case uint32:
-		return encoder.Int64(int64(v))
-	case uint64:
-		return errors.New("narrowing type conversion from uint64 to int64")
-
-	case float32:
-		fixed := d.float2int64(float64(v))
-		return encoder.Int64(fixed)
-	case float64:
-		fixed := d.float2int64(float64(v))
-		return encoder.Int64(fixed)
-
-	// this relies on Nullable never sending nil values through
-	case *int:
-		return encoder.Int64(int64(*v))
-	case *int8:
-		return encoder.Int64(int64(*v))
-	case *int16:
-		return encoder.Int64(int64(*v))
-	case *int32:
-		return encoder.Int64(int64(*v))
-	case *int64:
-		return encoder.Int64(int64(*v))
-
-	case *uint8:
-		return encoder.Int64(int64(*v))
-	case *uint16:
-		return encoder.Int64(int64(*v))
-	case *uint32:
-		return encoder.Int64(int64(*v))
-	case *uint64:
-		return errors.New("narrowing type conversion from uint64 to int64")
-
-	case *float32:
-		fixed := d.float2int64(float64(*v))
-		return encoder.Int64(fixed)
-	case *float64:
-		fixed := d.float2int64(float64(*v))
-		return encoder.Int64(fixed)
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: d,
-	}
-}
-
-func parseDecimal(name, chType string) (Column, error) {
-	switch {
-	case len(chType) < 12:
-		fallthrough
-	case !strings.HasPrefix(chType, "Decimal"):
-		fallthrough
-	case chType[7] != '(':
-		fallthrough
-	case chType[len(chType)-1] != ')':
-		return nil, fmt.Errorf("invalid Decimal format: '%s'", chType)
-	}
-
-	var params = strings.Split(chType[8:len(chType)-1], ",")
-
-	if len(params) != 2 {
-		return nil, fmt.Errorf("invalid Decimal format: '%s'", chType)
-	}
-
-	params[0] = strings.TrimSpace(params[0])
-	params[1] = strings.TrimSpace(params[1])
-
-	var err error
-	var decimal = &Decimal{
-		base: base{
-			name:   name,
-			chType: chType,
-		},
-	}
-
-	if decimal.precision, err = strconv.Atoi(params[0]); err != nil {
-		return nil, fmt.Errorf("'%s' is not Decimal type: %s", chType, err)
-	} else if decimal.precision < 1 {
-		return nil, errors.New("wrong precision of Decimal type")
-	}
-
-	if decimal.scale, err = strconv.Atoi(params[1]); err != nil {
-		return nil, fmt.Errorf("'%s' is not Decimal type: %s", chType, err)
-	} else if decimal.scale < 0 || decimal.scale > decimal.precision {
-		return nil, errors.New("wrong scale of Decimal type")
-	}
-
-	switch {
-	case decimal.precision <= 9:
-		decimal.nobits = 32
-		decimal.valueOf = baseTypes[int32(0)]
-	case decimal.precision <= 18:
-		decimal.nobits = 64
-		decimal.valueOf = baseTypes[int64(0)]
-	case decimal.precision <= 38:
-		return nil, errors.New("Decimal128 is not supported")
-	default:
-		return nil, errors.New("precision of Decimal exceeds max bound")
-	}
-
-	return decimal, nil
-}

vendor/github.com/kshvakov/clickhouse/lib/column/enum.go

@@ -1,140 +0,0 @@
-package column
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type Enum struct {
-	iv map[string]interface{}
-	vi map[interface{}]string
-	base
-	baseType interface{}
-}
-
-func (enum *Enum) Read(decoder *binary.Decoder) (interface{}, error) {
-	var (
-		err   error
-		ident interface{}
-	)
-	switch enum.baseType.(type) {
-	case int16:
-		if ident, err = decoder.Int16(); err != nil {
-			return nil, err
-		}
-	default:
-		if ident, err = decoder.Int8(); err != nil {
-			return nil, err
-		}
-	}
-	if ident, found := enum.vi[ident]; found {
-		return ident, nil
-	}
-	return nil, fmt.Errorf("invalid Enum value: %v", ident)
-}
-
-func (enum *Enum) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case string:
-		ident, found := enum.iv[v]
-		if !found {
-			return fmt.Errorf("invalid Enum ident: %s", v)
-		}
-		switch ident := ident.(type) {
-		case int8:
-			return encoder.Int8(ident)
-		case int16:
-			return encoder.Int16(ident)
-		}
-	case uint8:
-		if _, ok := enum.baseType.(int8); ok {
-			return encoder.Int8(int8(v))
-		}
-	case int8:
-		if _, ok := enum.baseType.(int8); ok {
-			return encoder.Int8(v)
-		}
-	case uint16:
-		if _, ok := enum.baseType.(int16); ok {
-			return encoder.Int16(int16(v))
-		}
-	case int16:
-		if _, ok := enum.baseType.(int16); ok {
-			return encoder.Int16(v)
-		}
-	case int64:
-		switch enum.baseType.(type) {
-		case int8:
-			return encoder.Int8(int8(v))
-		case int16:
-			return encoder.Int16(int16(v))
-		}
-	}
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: enum,
-	}
-}
-
-func (enum *Enum) defaultValue() interface{} {
-	return enum.baseType
-}
-
-func parseEnum(name, chType string) (*Enum, error) {
-	var (
-		data     string
-		isEnum16 bool
-	)
-	if len(chType) < 8 {
-		return nil, fmt.Errorf("invalid Enum format: %s", chType)
-	}
-	switch {
-	case strings.HasPrefix(chType, "Enum8"):
-		data = chType[6:]
-	case strings.HasPrefix(chType, "Enum16"):
-		data = chType[7:]
-		isEnum16 = true
-	default:
-		return nil, fmt.Errorf("'%s' is not Enum type", chType)
-	}
-	enum := Enum{
-		base: base{
-			name:    name,
-			chType:  chType,
-			valueOf: baseTypes[string("")],
-		},
-		iv: make(map[string]interface{}),
-		vi: make(map[interface{}]string),
-	}
-	for _, block := range strings.Split(data[:len(data)-1], ",") {
-		parts := strings.Split(block, "=")
-		if len(parts) != 2 {
-			return nil, fmt.Errorf("invalid Enum format: %s", chType)
-		}
-		var (
-			ident      = strings.TrimSpace(parts[0])
-			value, err = strconv.ParseInt(strings.TrimSpace(parts[1]), 10, 16)
-		)
-		if err != nil {
-			return nil, fmt.Errorf("invalid Enum value: %v", chType)
-		}
-		{
-			var (
-				ident             = ident[1 : len(ident)-1]
-				value interface{} = int16(value)
-			)
-			if !isEnum16 {
-				value = int8(value.(int16))
-			}
-			if enum.baseType == nil {
-				enum.baseType = value
-			}
-			enum.iv[ident] = value
-			enum.vi[value] = ident
-		}
-	}
-	return &enum, nil
-}

vendor/github.com/kshvakov/clickhouse/lib/column/fixed_string.go

@@ -1,71 +0,0 @@
-package column
-
-import (
-	"encoding"
-	"fmt"
-	"reflect"
-
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type FixedString struct {
-	base
-	len      int
-	scanType reflect.Type
-}
-
-func (str *FixedString) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.Fixed(str.len)
-	if err != nil {
-		return "", err
-	}
-	return string(v), nil
-}
-
-func (str *FixedString) Write(encoder *binary.Encoder, v interface{}) error {
-	var fixedString []byte
-	switch v := v.(type) {
-	case string:
-		fixedString = binary.Str2Bytes(v)
-	case []byte:
-		fixedString = v
-	case encoding.BinaryMarshaler:
-		bytes, err := v.MarshalBinary()
-		if err != nil {
-			return err
-		}
-		fixedString = bytes
-	default:
-		return &ErrUnexpectedType{
-			T:      v,
-			Column: str,
-		}
-	}
-	switch {
-	case len(fixedString) > str.len:
-		return fmt.Errorf("too large value '%s' (expected %d, got %d)", fixedString, str.len, len(fixedString))
-	case len(fixedString) < str.len:
-		tmp := make([]byte, str.len)
-		copy(tmp, fixedString)
-		fixedString = tmp
-	}
-	if _, err := encoder.Write(fixedString); err != nil {
-		return err
-	}
-	return nil
-}
-
-func parseFixedString(name, chType string) (*FixedString, error) {
-	var strLen int
-	if _, err := fmt.Sscanf(chType, "FixedString(%d)", &strLen); err != nil {
-		return nil, err
-	}
-	return &FixedString{
-		base: base{
-			name:    name,
-			chType:  chType,
-			valueOf: baseTypes[string("")],
-		},
-		len: strLen,
-	}, nil
-}

vendor/github.com/kshvakov/clickhouse/lib/column/float32.go

@@ -1,35 +0,0 @@
-package column
-
-import (
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type Float32 struct{ base }
-
-func (Float32) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.Float32()
-	if err != nil {
-		return float32(0), err
-	}
-	return v, nil
-}
-
-func (float *Float32) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case float32:
-		return encoder.Float32(v)
-	case float64:
-		return encoder.Float32(float32(v))
-
-	// this relies on Nullable never sending nil values through
-	case *float32:
-		return encoder.Float32(*v)
-	case *float64:
-		return encoder.Float32(float32(*v))
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: float,
-	}
-}

vendor/github.com/kshvakov/clickhouse/lib/column/float64.go

@@ -1,35 +0,0 @@
-package column
-
-import (
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type Float64 struct{ base }
-
-func (Float64) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.Float64()
-	if err != nil {
-		return float64(0), err
-	}
-	return v, nil
-}
-
-func (float *Float64) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case float32:
-		return encoder.Float64(float64(v))
-	case float64:
-		return encoder.Float64(v)
-
-	// this relies on Nullable never sending nil values through
-	case *float32:
-		return encoder.Float64(float64(*v))
-	case *float64:
-		return encoder.Float64(*v)
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: float,
-	}
-}

vendor/github.com/kshvakov/clickhouse/lib/column/int16.go

@@ -1,39 +0,0 @@
-package column
-
-import (
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type Int16 struct{ base }
-
-func (Int16) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.Int16()
-	if err != nil {
-		return int16(0), err
-	}
-	return v, nil
-}
-
-func (i *Int16) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case int16:
-		return encoder.Int16(v)
-	case int64:
-		return encoder.Int16(int16(v))
-	case int:
-		return encoder.Int16(int16(v))
-
-	// this relies on Nullable never sending nil values through
-	case *int16:
-		return encoder.Int16(*v)
-	case *int64:
-		return encoder.Int16(int16(*v))
-	case *int:
-		return encoder.Int16(int16(*v))
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: i,
-	}
-}

vendor/github.com/kshvakov/clickhouse/lib/column/int32.go

@@ -1,39 +0,0 @@
-package column
-
-import (
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type Int32 struct{ base }
-
-func (Int32) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.Int32()
-	if err != nil {
-		return int32(0), err
-	}
-	return v, nil
-}
-
-func (i *Int32) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case int32:
-		return encoder.Int32(v)
-	case int64:
-		return encoder.Int32(int32(v))
-	case int:
-		return encoder.Int32(int32(v))
-
-	// this relies on Nullable never sending nil values through
-	case *int32:
-		return encoder.Int32(*v)
-	case *int64:
-		return encoder.Int32(int32(*v))
-	case *int:
-		return encoder.Int32(int32(*v))
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: i,
-	}
-}

vendor/github.com/kshvakov/clickhouse/lib/column/int64.go

@@ -1,40 +0,0 @@
-package column
-
-import (
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type Int64 struct{ base }
-
-func (Int64) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.Int64()
-	if err != nil {
-		return int64(0), err
-	}
-	return v, nil
-}
-
-func (i *Int64) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case int:
-		return encoder.Int64(int64(v))
-	case int64:
-		return encoder.Int64(v)
-	case []byte:
-		if _, err := encoder.Write(v); err != nil {
-			return err
-		}
-		return nil
-
-	// this relies on Nullable never sending nil values through
-	case *int:
-		return encoder.Int64(int64(*v))
-	case *int64:
-		return encoder.Int64(*v)
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: i,
-	}
-}

vendor/github.com/kshvakov/clickhouse/lib/column/int8.go

@@ -1,49 +0,0 @@
-package column
-
-import (
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type Int8 struct{ base }
-
-func (Int8) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.Int8()
-	if err != nil {
-		return int8(0), err
-	}
-	return v, nil
-}
-
-func (i *Int8) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case int8:
-		return encoder.Int8(v)
-	case int64:
-		return encoder.Int8(int8(v))
-	case int:
-		return encoder.Int8(int8(v))
-	case bool:
-		if v {
-			return encoder.Int8(int8(1))
-		}
-		return encoder.Int8(int8(0))
-
-		// this relies on Nullable never sending nil values through
-	case *int8:
-		return encoder.Int8(*v)
-	case *int64:
-		return encoder.Int8(int8(*v))
-	case *int:
-		return encoder.Int8(int8(*v))
-	case *bool:
-		if *v {
-			return encoder.Int8(int8(1))
-		}
-		return encoder.Int8(int8(0))
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: i,
-	}
-}

vendor/github.com/kshvakov/clickhouse/lib/column/ip.go

@@ -1,73 +0,0 @@
-/*
-IP type supporting for clickhouse as FixedString(16)
-*/
-
-package column
-
-import (
-	"database/sql/driver"
-	"errors"
-	"net"
-)
-
-var (
-	errInvalidScanType  = errors.New("Invalid scan types")
-	errInvalidScanValue = errors.New("Invalid scan value")
-)
-
-// IP column type
-type IP net.IP
-
-// Value implements the driver.Valuer interface, json field interface
-// Alignment on the right side
-func (ip IP) Value() (driver.Value, error) {
-	return ip.MarshalBinary()
-}
-
-func (ip IP) MarshalBinary() ([]byte, error) {
-	if len(ip) < 16 {
-		var (
-			buff = make([]byte, 16)
-			j    = 0
-		)
-		for i := 16 - len(ip); i < 16; i++ {
-			buff[i] = ip[j]
-			j++
-		}
-		for i := 0; i < 16-len(ip); i++ {
-			buff[i] = '\x00'
-		}
-		if len(ip) == 4 {
-			buff[11] = '\xff'
-			buff[10] = '\xff'
-		}
-		return buff, nil
-	}
-	return []byte(ip), nil
-}
-
-// Scan implements the driver.Valuer interface, json field interface
-func (ip *IP) Scan(value interface{}) (err error) {
-	switch v := value.(type) {
-	case []byte:
-		if len(v) == 4 || len(v) == 16 {
-			*ip = IP(v)
-		} else {
-			err = errInvalidScanValue
-		}
-	case string:
-		if len(v) == 4 || len(v) == 16 {
-			*ip = IP([]byte(v))
-		} else {
-			err = errInvalidScanValue
-		}
-	default:
-		err = errInvalidScanType
-	}
-	return
-}
-
-// String implements the fmt.Stringer interface
-func (ip IP) String() string {
-	return net.IP(ip).String()
-}

vendor/github.com/kshvakov/clickhouse/lib/column/ipv4.go

@@ -1,34 +0,0 @@
-package column
-
-import (
-	"net"
-
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type IPv4 struct {
-	base
-}
-
-func (*IPv4) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.Fixed(4)
-	if err != nil {
-		return nil, err
-	}
-	return net.IPv4(v[3], v[2], v[1], v[0]), nil
-}
-
-func (ip *IPv4) Write(encoder *binary.Encoder, v interface{}) error {
-	netIP, ok := v.(net.IP)
-	if !ok {
-		return &ErrUnexpectedType{
-			T:      v,
-			Column: ip,
-		}
-	}
-	ip4 := netIP.To4()
-	if _, err := encoder.Write([]byte{ip4[3], ip4[2], ip4[1], ip4[0]}); err != nil {
-		return err
-	}
-	return nil
-}

vendor/github.com/kshvakov/clickhouse/lib/column/ipv6.go

@@ -1,33 +0,0 @@
-package column
-
-import (
-	"net"
-
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type IPv6 struct {
-	base
-}
-
-func (*IPv6) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.Fixed(16)
-	if err != nil {
-		return nil, err
-	}
-	return net.IP(v), nil
-}
-
-func (ip *IPv6) Write(encoder *binary.Encoder, v interface{}) error {
-	netIP, ok := v.(net.IP)
-	if !ok {
-		return &ErrUnexpectedType{
-			T:      v,
-			Column: ip,
-		}
-	}
-	if _, err := encoder.Write([]byte(netIP.To16())); err != nil {
-		return err
-	}
-	return nil
-}

vendor/github.com/kshvakov/clickhouse/lib/column/nullable.go

@@ -1,81 +0,0 @@
-package column
-
-import (
-	"fmt"
-	"reflect"
-	"time"
-
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type Nullable struct {
-	base
-	column Column
-}
-
-func (null *Nullable) ScanType() reflect.Type {
-	return null.column.ScanType()
-}
-
-func (null *Nullable) Read(decoder *binary.Decoder) (interface{}, error) {
-	return null.column.Read(decoder)
-}
-
-func (null *Nullable) Write(encoder *binary.Encoder, v interface{}) error {
-	return nil
-}
-
-func (null *Nullable) ReadNull(decoder *binary.Decoder, rows int) (_ []interface{}, err error) {
-	var (
-		isNull byte
-		value  interface{}
-		nulls  = make([]byte, rows)
-		values = make([]interface{}, rows)
-	)
-	for i := 0; i < rows; i++ {
-		if isNull, err = decoder.ReadByte(); err != nil {
-			return nil, err
-		}
-		nulls[i] = isNull
-	}
-	for i, isNull := range nulls {
-		switch value, err = null.column.Read(decoder); true {
-		case err != nil:
-			return nil, err
-		case isNull == 0:
-			values[i] = value
-		default:
-			values[i] = nil
-		}
-	}
-	return values, nil
-}
-func (null *Nullable) WriteNull(nulls, encoder *binary.Encoder, v interface{}) error {
-	if value := reflect.ValueOf(v); v == nil || (value.Kind() == reflect.Ptr && value.IsNil()) {
-		if _, err := nulls.Write([]byte{1}); err != nil {
-			return err
-		}
-		return null.column.Write(encoder, null.column.defaultValue())
-	}
-	if _, err := nulls.Write([]byte{0}); err != nil {
-		return err
-	}
-	return null.column.Write(encoder, v)
-}
-
-func parseNullable(name, chType string, timezone *time.Location) (*Nullable, error) {
-	if len(chType) < 14 {
-		return nil, fmt.Errorf("invalid Nullable column type: %s", chType)
-	}
-	column, err := Factory(name, chType[9:][:len(chType)-10], timezone)
-	if err != nil {
-		return nil, fmt.Errorf("Nullable(T): %v", err)
-	}
-	return &Nullable{
-		base: base{
-			name:   name,
-			chType: chType,
-		},
-		column: column,
-	}, nil
-}

vendor/github.com/kshvakov/clickhouse/lib/column/string.go

@@ -1,33 +0,0 @@
-package column
-
-import (
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type String struct{ base }
-
-func (String) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.String()
-	if err != nil {
-		return "", err
-	}
-	return v, nil
-}
-
-func (str *String) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case string:
-		return encoder.String(v)
-	case []byte:
-		return encoder.RawString(v)
-
-	// this relies on Nullable never sending nil values through
-	case *string:
-		return encoder.String(*v)
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: str,
-	}
-}

vendor/github.com/kshvakov/clickhouse/lib/column/uint16.go

@@ -1,39 +0,0 @@
-package column
-
-import (
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type UInt16 struct{ base }
-
-func (UInt16) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.UInt16()
-	if err != nil {
-		return uint16(0), err
-	}
-	return v, nil
-}
-
-func (u *UInt16) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case uint16:
-		return encoder.UInt16(v)
-	case int64:
-		return encoder.UInt16(uint16(v))
-	case int:
-		return encoder.UInt16(uint16(v))
-
-	// this relies on Nullable never sending nil values through
-	case *uint16:
-		return encoder.UInt16(*v)
-	case *int64:
-		return encoder.UInt16(uint16(*v))
-	case *int:
-		return encoder.UInt16(uint16(*v))
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: u,
-	}
-}

vendor/github.com/kshvakov/clickhouse/lib/column/uint32.go

@@ -1,39 +0,0 @@
-package column
-
-import (
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type UInt32 struct{ base }
-
-func (UInt32) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.UInt32()
-	if err != nil {
-		return uint32(0), err
-	}
-	return v, nil
-}
-
-func (u *UInt32) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case uint32:
-		return encoder.UInt32(v)
-	case int64:
-		return encoder.UInt32(uint32(v))
-	case int:
-		return encoder.UInt32(uint32(v))
-
-	// this relies on Nullable never sending nil values through
-	case *uint32:
-		return encoder.UInt32(*v)
-	case *int64:
-		return encoder.UInt32(uint32(*v))
-	case *int:
-		return encoder.UInt32(uint32(*v))
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: u,
-	}
-}

vendor/github.com/kshvakov/clickhouse/lib/column/uint64.go

@@ -1,44 +0,0 @@
-package column
-
-import (
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type UInt64 struct{ base }
-
-func (UInt64) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.UInt64()
-	if err != nil {
-		return uint64(0), err
-	}
-	return v, nil
-}
-
-func (u *UInt64) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case []byte:
-		if _, err := encoder.Write(v); err != nil {
-			return err
-		}
-		return nil
-	case uint64:
-		return encoder.UInt64(v)
-	case int64:
-		return encoder.UInt64(uint64(v))
-	case int:
-		return encoder.UInt64(uint64(v))
-
-	// this relies on Nullable never sending nil values through
-	case *uint64:
-		return encoder.UInt64(*v)
-	case *int64:
-		return encoder.UInt64(uint64(*v))
-	case *int:
-		return encoder.UInt64(uint64(*v))
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: u,
-	}
-}

vendor/github.com/kshvakov/clickhouse/lib/column/uint8.go

@@ -1,43 +0,0 @@
-package column
-
-import (
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-type UInt8 struct{ base }
-
-func (UInt8) Read(decoder *binary.Decoder) (interface{}, error) {
-	v, err := decoder.UInt8()
-	if err != nil {
-		return uint8(0), err
-	}
-	return v, nil
-}
-
-func (u *UInt8) Write(encoder *binary.Encoder, v interface{}) error {
-	switch v := v.(type) {
-	case bool:
-		return encoder.Bool(v)
-	case uint8:
-		return encoder.UInt8(v)
-	case int64:
-		return encoder.UInt8(uint8(v))
-	case int:
-		return encoder.UInt8(uint8(v))
-
-	// this relies on Nullable never sending nil values through
-	case *bool:
-		return encoder.Bool(*v)
-	case *uint8:
-		return encoder.UInt8(*v)
-	case *int64:
-		return encoder.UInt8(uint8(*v))
-	case *int:
-		return encoder.UInt8(uint8(*v))
-	}
-
-	return &ErrUnexpectedType{
-		T:      v,
-		Column: u,
-	}
-}

vendor/github.com/kshvakov/clickhouse/lib/column/uuid.go

@@ -1,130 +0,0 @@
-package column
-
-import (
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"reflect"
-
-	"github.com/kshvakov/clickhouse/lib/binary"
-)
-
-const UUIDLen = 16
-
-var ErrInvalidUUIDFormat = errors.New("invalid UUID format")
-
-type UUID struct {
-	base
-	scanType reflect.Type
-}
-
-func (*UUID) Read(decoder *binary.Decoder) (interface{}, error) {
-	src, err := decoder.Fixed(UUIDLen)
-	if err != nil {
-		return "", err
-	}
-
-	src = swap(src)
-
-	var uuid [36]byte
-	{
-		hex.Encode(uuid[:], src[:4])
-		uuid[8] = '-'
-		hex.Encode(uuid[9:13], src[4:6])
-		uuid[13] = '-'
-		hex.Encode(uuid[14:18], src[6:8])
-		uuid[18] = '-'
-		hex.Encode(uuid[19:23], src[8:10])
-		uuid[23] = '-'
-		hex.Encode(uuid[24:], src[10:])
-	}
-	return string(uuid[:]), nil
-}
-
-func (u *UUID) Write(encoder *binary.Encoder, v interface{}) (err error) {
-	var uuid []byte
-	switch v := v.(type) {
-	case string:
-		if uuid, err = uuid2bytes(v); err != nil {
-			return err
-		}
-	case []byte:
-		if len(v) != UUIDLen {
-			return fmt.Errorf("invalid raw UUID len '%s' (expected %d, got %d)", uuid, UUIDLen, len(uuid))
-		}
-		uuid = make([]byte, 16)
-		copy(uuid, v)
-	default:
-		return &ErrUnexpectedType{
-			T:      v,
-			Column: u,
-		}
-	}
-
-	uuid = swap(uuid)
-
-	if _, err := encoder.Write(uuid); err != nil {
-		return err
-	}
-	return nil
-}
-
-func swap(src []byte) []byte {
-	_ = src[15]
-	src[0], src[7] = src[7], src[0]
-	src[1], src[6] = src[6], src[1]
-	src[2], src[5] = src[5], src[2]
-	src[3], src[4] = src[4], src[3]
-	src[8], src[15] = src[15], src[8]
-	src[9], src[14] = src[14], src[9]
-	src[10], src[13] = src[13], src[10]
-	src[11], src[12] = src[12], src[11]
-	return src
-}
-
-func uuid2bytes(str string) ([]byte, error) {
-	var uuid [16]byte
-	if str[8] != '-' || str[13] != '-' || str[18] != '-' || str[23] != '-' {
-		return nil, ErrInvalidUUIDFormat
-	}
-	for i, x := range [16]int{
-		0, 2, 4, 6,
-		9, 11, 14, 16,
-		19, 21, 24, 26,
-		28, 30, 32, 34,
-	} {
-		if v, ok := xtob(str[x], str[x+1]); !ok {
-			return nil, ErrInvalidUUIDFormat
-		} else {
-			uuid[i] = v
-		}
-	}
-	return uuid[:], nil
-}
-
-// xvalues returns the value of a byte as a hexadecimal digit or 255.
-var xvalues = [256]byte{
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255, 255,
-	255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-}
-
-// xtob converts hex characters x1 and x2 into a byte.
-func xtob(x1, x2 byte) (byte, bool) {
-	b1 := xvalues[x1]
-	b2 := xvalues[x2]
-	return (b1 << 4) | b2, b1 != 255 && b2 != 255
-}