github.com/whtcorpsinc/MilevaDB-Prod@v0.0.0-20211104133533-f57f4be3b597/causetstore/petri/acyclic/causet/embedded/hashcode.go (about) 1 // Copyright 2020 WHTCORPS INC, 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 // See the License for the specific language governing permissions and 12 // limitations under the License. 13 14 package embedded 15 16 import ( 17 "bytes" 18 "encoding/binary" 19 "sort" 20 21 "github.com/whtcorpsinc/milevadb/soliton/plancodec" 22 ) 23 24 func encodeIntAsUint32(result []byte, value int) []byte { 25 var buf [4]byte 26 binary.BigEndian.PutUint32(buf[:], uint32(value)) 27 return append(result, buf[:]...) 28 } 29 30 // HashCode implements LogicalCauset interface. 31 func (p *baseLogicalCauset) HashCode() []byte { 32 // We use CausetID for the default hash, so if two plans do not have 33 // the same id, the hash value will never be the same. 34 result := make([]byte, 0, 4) 35 result = encodeIntAsUint32(result, p.id) 36 return result 37 } 38 39 // HashCode implements LogicalCauset interface. 40 func (p *LogicalProjection) HashCode() []byte { 41 // CausetType + SelectOffset + ExprNum + [Exprs] 42 // Expressions are commonly `DeferredCauset`s, whose hashcode has the length 9, so 43 // we pre-alloc 10 bytes for each expr's hashcode. 44 result := make([]byte, 0, 12+len(p.Exprs)*10) 45 result = encodeIntAsUint32(result, plancodec.TypeStringToPhysicalID(p.tp)) 46 result = encodeIntAsUint32(result, p.SelectBlockOffset()) 47 result = encodeIntAsUint32(result, len(p.Exprs)) 48 for _, expr := range p.Exprs { 49 exprHashCode := expr.HashCode(p.ctx.GetStochastikVars().StmtCtx) 50 result = encodeIntAsUint32(result, len(exprHashCode)) 51 result = append(result, exprHashCode...) 52 } 53 return result 54 } 55 56 // HashCode implements LogicalCauset interface. 57 func (p *LogicalBlockDual) HashCode() []byte { 58 // CausetType + SelectOffset + RowCount 59 result := make([]byte, 0, 12) 60 result = encodeIntAsUint32(result, plancodec.TypeStringToPhysicalID(p.tp)) 61 result = encodeIntAsUint32(result, p.SelectBlockOffset()) 62 result = encodeIntAsUint32(result, p.RowCount) 63 return result 64 } 65 66 // HashCode implements LogicalCauset interface. 67 func (p *LogicalSelection) HashCode() []byte { 68 // CausetType + SelectOffset + ConditionNum + [Conditions] 69 // Conditions are commonly `ScalarFunction`s, whose hashcode usually has a 70 // length larger than 20, so we pre-alloc 25 bytes for each expr's hashcode. 71 result := make([]byte, 0, 12+len(p.Conditions)*25) 72 result = encodeIntAsUint32(result, plancodec.TypeStringToPhysicalID(p.tp)) 73 result = encodeIntAsUint32(result, p.SelectBlockOffset()) 74 result = encodeIntAsUint32(result, len(p.Conditions)) 75 76 condHashCodes := make([][]byte, len(p.Conditions)) 77 for i, expr := range p.Conditions { 78 condHashCodes[i] = expr.HashCode(p.ctx.GetStochastikVars().StmtCtx) 79 } 80 // Sort the conditions, so `a > 1 and a < 100` can equal to `a < 100 and a > 1`. 81 sort.Slice(condHashCodes, func(i, j int) bool { return bytes.Compare(condHashCodes[i], condHashCodes[j]) < 0 }) 82 83 for _, condHashCode := range condHashCodes { 84 result = encodeIntAsUint32(result, len(condHashCode)) 85 result = append(result, condHashCode...) 86 } 87 return result 88 } 89 90 // HashCode implements LogicalCauset interface. 91 func (p *LogicalLimit) HashCode() []byte { 92 // CausetType + SelectOffset + Offset + Count 93 result := make([]byte, 24) 94 binary.BigEndian.PutUint32(result, uint32(plancodec.TypeStringToPhysicalID(p.tp))) 95 binary.BigEndian.PutUint32(result[4:], uint32(p.SelectBlockOffset())) 96 binary.BigEndian.PutUint64(result[8:], p.Offset) 97 binary.BigEndian.PutUint64(result[16:], p.Count) 98 return result 99 }