Merge pull request ClickHouse#219 from cw9/master

Add a better example for WriteArrayWithValue

Author: kshvakov

clickhouse_columnar_test.go

@@ -28,8 +28,9 @@ func Test_ColumnarInsert(t *testing.T) {
 				enum8      Enum8 ('a' = 1, 'b' = 2),
 				enum16     Enum16('c' = 1, 'd' = 2),
 				array      Array(String),
-				array2     Array(UInt64),
-				arrayArray Array(Array(String))
+				arrayArray Array(Array(String)),
+				arrayWithValue Array(UInt64),
+				arrayWithValueFast Array(UInt64)
 			) Engine=Memory
 		`
 		dml = `
@@ -47,8 +48,9 @@ func Test_ColumnarInsert(t *testing.T) {
 				enum8,
 				enum16,
 				array,
-				array2,
-				arrayArray
+				arrayArray,
+				arrayWithValue,
+				arrayWithValueFast
 			) VALUES (
 				?,
 				?,
@@ -108,8 +110,9 @@ func Test_ColumnarInsert(t *testing.T) {
 						block.WriteUInt8(10, 1)
 						block.WriteUInt16(11, 2)
 						block.WriteArray(12, []string{"A", "B", "C"})
-						block.WriteArrayWithValue(13, uint64SliceValue{value: []uint64{1, 2, 3}})
-						block.WriteArray(14, [][]string{[]string{"A", "B"}, []string{"CC", "DD", "EE"}})
+						block.WriteArray(13, [][]string{[]string{"A", "B"}, []string{"CC", "DD", "EE"}})
+						block.WriteArrayWithValue(14, newUint64SliceValueSimple([]uint64{1, 2, 3}))
+						block.WriteArrayWithValue(15, newUint64SliceValueFast([]uint64{10, 20, 30}))
 						if !assert.NoError(t, err) {
 							return
 						}
@@ -126,38 +129,75 @@ type uint64Value struct {
 	value uint64
 }
 
-func (v uint64Value) Kind() reflect.Kind {
+func (v *uint64Value) Kind() reflect.Kind {
 	return reflect.String
 }
 
-func (v uint64Value) Len() int {
+func (v *uint64Value) Len() int {
 	panic("uint64 has no length")
 }
 
-func (v uint64Value) Index(i int) data.Value {
+func (v *uint64Value) Index(i int) data.Value {
 	panic("uint64 has no index")
 }
 
-func (v uint64Value) Interface() interface{} {
+func (v *uint64Value) Interface() interface{} {
 	return v.value
 }
 
-type uint64SliceValue struct {
-	value []uint64
+type uint64SliceValueSimple struct {
+	uint64Slice []uint64
 }
 
-func (v uint64SliceValue) Kind() reflect.Kind {
+func newUint64SliceValueSimple(v []uint64) *uint64SliceValueSimple {
+	return &uint64SliceValueSimple{uint64Slice: v}
+}
+
+func (v *uint64SliceValueSimple) Kind() reflect.Kind {
 	return reflect.Slice
 }
 
-func (v uint64SliceValue) Len() int {
-	return len(v.value)
+func (v *uint64SliceValueSimple) Len() int {
+	return len(v.uint64Slice)
+}
+
+func (v *uint64SliceValueSimple) Index(i int) data.Value {
+	return &uint64Value{value: v.uint64Slice[i]}
+}
+
+func (v *uint64SliceValueSimple) Interface() interface{} {
+	return v.uint64Slice
+}
+
+type uint64SliceValueFast struct {
+	uint64Slice []uint64
+	uint64Value *uint64Value
+	value       data.Value
 }
 
-func (v uint64SliceValue) Index(i int) data.Value {
-	return uint64Value{value: v.value[i]}
+func newUint64SliceValueFast(v []uint64) *uint64SliceValueFast {
+	var uint64Value uint64Value
+	return &uint64SliceValueFast{
+		uint64Slice: v,
+		uint64Value: &uint64Value,
+		value:       &uint64Value,
+	}
+}
+
+func (v *uint64SliceValueFast) Kind() reflect.Kind {
+	return reflect.Slice
 }
 
-func (v uint64SliceValue) Interface() interface{} {
+func (v *uint64SliceValueFast) Len() int {
+	return len(v.uint64Slice)
+}
+
+func (v *uint64SliceValueFast) Index(i int) data.Value {
+	v.uint64Value.value = v.uint64Slice[i]
+	// NB: This avoids the CPU cost of converting *uint64Value to data.Value.
 	return v.value
 }
+
+func (v *uint64SliceValueFast) Interface() interface{} {
+	return v.uint64Slice
+}