github.com/rohankumardubey/aresdb@v0.0.2-0.20190517170215-e54e3ca06b9c/query/common/dimval_test.go (about) 1 // Copyright (c) 2017-2018 Uber Technologies, Inc. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 package common 16 17 import ( 18 "github.com/onsi/ginkgo" 19 . "github.com/onsi/gomega" 20 memCom "github.com/uber/aresdb/memstore/common" 21 "time" 22 "unsafe" 23 ) 24 25 var _ = ginkgo.Describe("dimval", func() { 26 ginkgo.It("GetDimensionStartOffsets should work", func() { 27 numDimsPerDimWidth := DimCountsPerDimWidth{0, 0, 1, 1, 1} 28 valueOffset, nullsOffset := GetDimensionStartOffsets(numDimsPerDimWidth, 0, 10) 29 Ω([2]int{valueOffset, nullsOffset}).Should(Equal([2]int{0, 70})) 30 valueOffset, nullsOffset = GetDimensionStartOffsets(numDimsPerDimWidth, 1, 10) 31 Ω([2]int{valueOffset, nullsOffset}).Should(Equal([2]int{40, 80})) 32 valueOffset, nullsOffset = GetDimensionStartOffsets(numDimsPerDimWidth, 2, 10) 33 Ω([2]int{valueOffset, nullsOffset}).Should(Equal([2]int{60, 90})) 34 35 numDimsPerDimWidth = DimCountsPerDimWidth{0, 0, 0, 1, 1} 36 valueOffset, nullsOffset = GetDimensionStartOffsets(numDimsPerDimWidth, 0, 10) 37 Ω([2]int{valueOffset, nullsOffset}).Should(Equal([2]int{0, 30})) 38 valueOffset, nullsOffset = GetDimensionStartOffsets(numDimsPerDimWidth, 1, 10) 39 Ω([2]int{valueOffset, nullsOffset}).Should(Equal([2]int{20, 40})) 40 valueOffset, nullsOffset = GetDimensionStartOffsets(numDimsPerDimWidth, 2, 10) 41 Ω([2]int{valueOffset, nullsOffset}).Should(Equal([2]int{30, 50})) 42 43 numDimsPerDimWidth = DimCountsPerDimWidth{0, 0, 0, 0, 1} 44 valueOffset, nullsOffset = GetDimensionStartOffsets(numDimsPerDimWidth, 0, 10) 45 Ω([2]int{valueOffset, nullsOffset}).Should(Equal([2]int{0, 10})) 46 valueOffset, nullsOffset = GetDimensionStartOffsets(numDimsPerDimWidth, 1, 10) 47 Ω([2]int{valueOffset, nullsOffset}).Should(Equal([2]int{10, 20})) 48 valueOffset, nullsOffset = GetDimensionStartOffsets(numDimsPerDimWidth, 2, 10) 49 Ω([2]int{valueOffset, nullsOffset}).Should(Equal([2]int{10, 30})) 50 }) 51 52 ginkgo.It("ReadDimension should work", func() { 53 dimensionData := []byte{ 54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0, 0, 0, 0, 0, // dim0 57 0, 0, 0, 0, 0, 0, 0, 0, 58 2, 0, 0, 0, 0, 0, 0, 0, 59 0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0, // dim1 60 0, 0, 0, 0, 61 1, 0, 0, 0, 62 0xFF, 0xFF, 0xFF, 0xFF, // dim2 63 0, 0, 64 2, 0, 65 2, 2, // dim3 66 0, 2, 3, // dim4 67 0, 1, 1, // dim0 68 0, 1, 1, // dim1 69 0, 1, 1, // dim2 70 0, 1, 1, // dim3 71 0, 1, 1, // dim4 72 } 73 74 enumReverseDict := []string{"a", "b", "c"} 75 dimValueVector := unsafe.Pointer(&dimensionData[0]) 76 dimNullVector := unsafe.Pointer(&dimensionData[3*(16+8+4+2+1)]) 77 78 Ω(ReadDimension(memAccess(dimValueVector, 0), 79 memAccess(dimNullVector, 0), 0, memCom.UUID, nil, nil, nil)).Should(BeNil()) 80 Ω(*ReadDimension(memAccess(dimValueVector, 0), 81 memAccess(dimNullVector, 0), 1, memCom.UUID, nil, nil, nil)).Should(Equal("01000000-0000-0000-0000-000000000000")) 82 Ω(*ReadDimension(memAccess(dimValueVector, 0), 83 memAccess(dimNullVector, 0), 2, memCom.UUID, nil, nil, nil)).Should(Equal("ffffffff-ffff-ffff-0000-000000000000")) 84 85 Ω(ReadDimension(memAccess(dimValueVector, 0+3*16), 86 memAccess(dimNullVector, 3), 0, memCom.Int64, nil, nil, nil)).Should(BeNil()) 87 Ω(*ReadDimension(memAccess(dimValueVector, 0+3*16), 88 memAccess(dimNullVector, 3), 1, memCom.Int64, nil, nil, nil)).Should(Equal("2")) 89 Ω(*ReadDimension(memAccess(dimValueVector, 0+3*16), 90 memAccess(dimNullVector, 3), 2, memCom.Int64, nil, nil, nil)).Should(Equal("4294967295")) 91 92 Ω(ReadDimension(memAccess(dimValueVector, 48+3*8), 93 memAccess(dimNullVector, 6), 0, memCom.Uint32, nil, nil, nil)).Should(BeNil()) 94 Ω(*ReadDimension(memAccess(dimValueVector, 48+3*8), 95 memAccess(dimNullVector, 6), 1, memCom.Uint32, nil, nil, nil)).Should(Equal("1")) 96 Ω(*ReadDimension(memAccess(dimValueVector, 48+3*8), 97 memAccess(dimNullVector, 6), 2, memCom.Uint32, nil, nil, nil)).Should(Equal("4294967295")) 98 99 Ω(ReadDimension(memAccess(dimValueVector, 72+3*4), 100 memAccess(dimNullVector, 9), 0, memCom.Int16, nil, nil, nil)).Should(BeNil()) 101 Ω(*ReadDimension(memAccess(dimValueVector, 72+3*4), 102 memAccess(dimNullVector, 9), 1, memCom.Int16, nil, nil, nil)).Should(Equal("2")) 103 Ω(*ReadDimension(memAccess(dimValueVector, 72+3*4), 104 memAccess(dimNullVector, 9), 2, memCom.Int16, nil, nil, nil)).Should(Equal("514")) 105 106 Ω(ReadDimension(memAccess(dimValueVector, 84+3*2), 107 memAccess(dimNullVector, 12), 0, memCom.Uint8, enumReverseDict, nil, nil)).Should(BeNil()) 108 Ω(*ReadDimension(memAccess(dimValueVector, 84+3*2), 109 memAccess(dimNullVector, 12), 1, memCom.Uint8, enumReverseDict, nil, nil)).Should(Equal("c")) 110 Ω(*ReadDimension(memAccess(dimValueVector, 84+3*2), 111 memAccess(dimNullVector, 12), 2, memCom.Uint8, enumReverseDict, nil, nil)).Should(Equal("3")) 112 }) 113 114 ginkgo.It("Timezone offset should work", func() { 115 dimensionData := []byte{ 116 0, 0, 0, 0, 117 1, 0, 0, 0, 118 0xFF, 0xFF, 0xFF, 0xFF, // dim0 119 0, 0, 120 2, 0, 121 2, 2, // dim1 122 0, 2, 3, // dim2 123 0, 1, 1, // dim0 124 0, 1, 1, // dim1 125 0, 1, 1, // dim2 126 } 127 dimValueVector := unsafe.Pointer(&dimensionData[0]) 128 dimNullVector := unsafe.Pointer(&dimensionData[21]) 129 130 Ω(*ReadDimension(memAccess(dimValueVector, 0), 131 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, &TimeDimensionMeta{TimeBucketizer: "minute", TimeUnit: "", IsTimezoneTable: false}, nil)).Should(Equal("1970-01-01 00:00")) 132 Ω(*ReadDimension(memAccess(dimValueVector, 0), 133 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, &TimeDimensionMeta{TimeBucketizer: "second", TimeUnit: "", IsTimezoneTable: false}, nil)).Should(Equal("1")) 134 sfLoc, _ := time.LoadLocation("Africa/Algiers") 135 136 Ω(*ReadDimension(memAccess(dimValueVector, 0), 137 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, &TimeDimensionMeta{TimeBucketizer: "minute", TimeUnit: "", IsTimezoneTable: false, TimeZone: sfLoc}, nil)).Should(Equal("1970-01-01 00:00")) 138 Ω(*ReadDimension(memAccess(dimValueVector, 0), 139 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, &TimeDimensionMeta{TimeBucketizer: "minute", TimeUnit: "second", IsTimezoneTable: false, TimeZone: sfLoc}, nil)).Should(Equal("1")) 140 141 _, offsetInSeconds := time.Now().In(sfLoc).Zone() 142 Ω(*ReadDimension(memAccess(dimValueVector, 0), 143 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, &TimeDimensionMeta{TimeBucketizer: "minute", TimeUnit: "", IsTimezoneTable: false, TimeZone: sfLoc}, nil)).Should(Equal("1970-01-01 00:00")) 144 Ω(*ReadDimension(memAccess(dimValueVector, 0), 145 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, 146 &TimeDimensionMeta{TimeBucketizer: "minute", TimeUnit: "second", IsTimezoneTable: false, TimeZone: sfLoc, FromOffset: offsetInSeconds, ToOffset: offsetInSeconds}, nil)).Should(Equal("-3599")) 147 }) 148 149 ginkgo.It("Time unit should work", func() { 150 dimensionData := []byte{ 151 0, 0, 0, 0, 152 255, 255, 0, 0, 153 0xFF, 0xFF, 0xFF, 0xFF, // dim0 154 0, 0, 155 2, 0, 156 2, 2, // dim1 157 0, 2, 3, // dim2 158 0, 1, 1, // dim0 159 0, 1, 1, // dim1 160 0, 1, 1, // dim2 161 } 162 dimValueVector := unsafe.Pointer(&dimensionData[0]) 163 dimNullVector := unsafe.Pointer(&dimensionData[21]) 164 165 Ω(*ReadDimension(memAccess(dimValueVector, 0), 166 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, 167 nil, nil)).Should(Equal("65535")) 168 Ω(*ReadDimension(memAccess(dimValueVector, 0), 169 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, 170 &TimeDimensionMeta{TimeBucketizer: "day", TimeUnit: "second", IsTimezoneTable: false}, nil)).Should(Equal("65535")) 171 Ω(*ReadDimension(memAccess(dimValueVector, 0), 172 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, 173 &TimeDimensionMeta{TimeBucketizer: "day", TimeUnit: "millisecond", IsTimezoneTable: false}, nil)).Should(Equal("65535000")) 174 Ω(*ReadDimension(memAccess(dimValueVector, 0), 175 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, 176 &TimeDimensionMeta{TimeBucketizer: "day", TimeUnit: "day", IsTimezoneTable: false}, nil)).Should(Equal("0")) 177 Ω(*ReadDimension(memAccess(dimValueVector, 0), 178 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, 179 &TimeDimensionMeta{TimeBucketizer: "day", TimeUnit: "hour", IsTimezoneTable: false}, nil)).Should(Equal("18")) 180 Ω(*ReadDimension(memAccess(dimValueVector, 0), 181 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, 182 &TimeDimensionMeta{TimeBucketizer: "day", TimeUnit: "minute", IsTimezoneTable: false}, nil)).Should(Equal("1092")) 183 }) 184 185 ginkgo.It("ReadDimension from cache should work", func() { 186 dimensionData := []byte{ 187 0, 0, 0, 0, 188 1, 0, 0, 0, 189 0xFF, 0xFF, 0xFF, 0xFF, // dim0 190 0, 0, 191 2, 0, 192 2, 2, // dim1 193 0, 2, 3, // dim2 194 0, 1, 1, // dim0 195 0, 1, 1, // dim1 196 0, 1, 1, // dim2 197 } 198 dimValueVector := unsafe.Pointer(&dimensionData[0]) 199 dimNullVector := unsafe.Pointer(&dimensionData[21]) 200 201 meta := TimeDimensionMeta{TimeBucketizer: "minute", TimeUnit: "", IsTimezoneTable: false} 202 cache := map[TimeDimensionMeta]map[int64]string{ 203 meta: { 204 1: "foo", 205 }, 206 } 207 Ω(*ReadDimension(memAccess(dimValueVector, 0), 208 memAccess(dimNullVector, 0), 1, memCom.Uint32, nil, &TimeDimensionMeta{TimeBucketizer: "minute", TimeUnit: "", IsTimezoneTable: false}, cache)).Should(Equal("foo")) 209 Ω(cache[meta][1]).Should(Equal("foo")) 210 }) 211 })