func TestRandIntInRange(t *testing.T) {
rand, _ := randutil.NewPseudoRand()
for i := 0; i < 100; i++ {
x := randutil.RandIntInRange(rand, 20, 40)
if x < 20 || x >= 40 {
t.Errorf("got result out of range: %d", x)
}
}
}
func BenchmarkDecimalPow(b *testing.B) {
rng, _ := randutil.NewPseudoRand()
xs := make([]*inf.Dec, 100)
ys := make([]*inf.Dec, 100)
for i := range ys {
ys[i] = NewDecFromFloat(math.Abs(rng.Float64()))
ys[i].Add(ys[i], inf.NewDec(int64(randutil.RandIntInRange(rng, 0, 10)), 0))
xs[i] = NewDecFromFloat(math.Abs(rng.Float64()))
xs[i].Add(xs[i], inf.NewDec(int64(randutil.RandIntInRange(rng, 0, 10)), 0))
}
z := new(inf.Dec)
b.ResetTimer()
for i := 0; i < b.N; i++ {
Pow(z, xs[i%len(ys)], ys[i%len(ys)], 16)
}
}
func BenchmarkDecimalExp(b *testing.B) {
rng, _ := randutil.NewPseudoRand()
vals := make([]*inf.Dec, 100)
for i := range vals {
vals[i] = NewDecFromFloat(math.Abs(rng.Float64()))
vals[i].Add(vals[i], inf.NewDec(int64(randutil.RandIntInRange(rng, 0, 100)), 0))
}
z := new(inf.Dec)
b.ResetTimer()
for i := 0; i < b.N; i++ {
Exp(z, vals[i%len(vals)], 16)
}
}
// randDecimal generates a random decimal with exponent in the
// range [minExp, maxExp].
func randDecimal(rng *rand.Rand, minExp, maxExp int) *inf.Dec {
exp := randutil.RandIntInRange(rng, minExp, maxExp+1)
// Transform random float in [0, 1) to [-1, 1) and multiply by 10^exp.
floatVal := (rng.Float64()*2 - 1) * math.Pow10(exp)
return decimal.NewDecFromFloat(floatVal)
}
func TestIndexKey(t *testing.T) {
rng, _ := randutil.NewPseudoRand()
var a DatumAlloc
tests := []indexKeyTest{
{nil, nil,
[]parser.Datum{parser.NewDInt(10)},
[]parser.Datum{parser.NewDInt(20)},
},
{[]ID{100}, nil,
[]parser.Datum{parser.NewDInt(10), parser.NewDInt(11)},
[]parser.Datum{parser.NewDInt(20)},
},
{[]ID{100, 200}, nil,
[]parser.Datum{parser.NewDInt(10), parser.NewDInt(11), parser.NewDInt(12)},
[]parser.Datum{parser.NewDInt(20)},
},
{nil, []ID{100},
[]parser.Datum{parser.NewDInt(10)},
[]parser.Datum{parser.NewDInt(20), parser.NewDInt(21)},
},
{[]ID{100}, []ID{100},
[]parser.Datum{parser.NewDInt(10), parser.NewDInt(11)},
[]parser.Datum{parser.NewDInt(20), parser.NewDInt(21)},
},
{[]ID{100}, []ID{200},
[]parser.Datum{parser.NewDInt(10), parser.NewDInt(11)},
[]parser.Datum{parser.NewDInt(20), parser.NewDInt(21)},
},
{[]ID{100, 200}, []ID{100, 300},
[]parser.Datum{parser.NewDInt(10), parser.NewDInt(11), parser.NewDInt(12)},
[]parser.Datum{parser.NewDInt(20), parser.NewDInt(21), parser.NewDInt(22)},
},
}
for i := 0; i < 1000; i++ {
var t indexKeyTest
t.primaryInterleaves = make([]ID, rng.Intn(10))
for j := range t.primaryInterleaves {
t.primaryInterleaves[j] = ID(1 + rng.Intn(10))
}
valuesLen := randutil.RandIntInRange(rng, len(t.primaryInterleaves)+1, len(t.primaryInterleaves)+10)
t.primaryValues = make([]parser.Datum, valuesLen)
for j := range t.primaryValues {
t.primaryValues[j] = RandDatum(rng, ColumnType_INT, true)
}
t.secondaryInterleaves = make([]ID, rng.Intn(10))
for j := range t.secondaryInterleaves {
t.secondaryInterleaves[j] = ID(1 + rng.Intn(10))
}
valuesLen = randutil.RandIntInRange(rng, len(t.secondaryInterleaves)+1, len(t.secondaryInterleaves)+10)
t.secondaryValues = make([]parser.Datum, valuesLen)
for j := range t.secondaryValues {
t.secondaryValues[j] = RandDatum(rng, ColumnType_INT, true)
}
tests = append(tests, t)
}
for i, test := range tests {
tableDesc, colMap := makeTableDescForTest(test)
testValues := append(test.primaryValues, test.secondaryValues...)
primaryKeyPrefix := MakeIndexKeyPrefix(&tableDesc, tableDesc.PrimaryIndex.ID)
primaryKey, _, err := EncodeIndexKey(
&tableDesc, &tableDesc.PrimaryIndex, colMap, testValues, primaryKeyPrefix)
if err != nil {
t.Fatal(err)
}
primaryValue := roachpb.MakeValueFromBytes(nil)
primaryIndexKV := client.KeyValue{Key: primaryKey, Value: &primaryValue}
secondaryIndexEntry, err := EncodeSecondaryIndex(
&tableDesc, &tableDesc.Indexes[0], colMap, testValues)
if err != nil {
t.Fatal(err)
}
secondaryIndexKV := client.KeyValue{
Key: secondaryIndexEntry.Key,
Value: &secondaryIndexEntry.Value,
}
checkEntry := func(index *IndexDescriptor, entry client.KeyValue) {
values, err := decodeIndex(&a, &tableDesc, index, entry.Key)
if err != nil {
t.Fatal(err)
}
for j, value := range values {
testValue := testValues[colMap[index.ColumnIDs[j]]]
if value.Compare(testValue) != 0 {
t.Fatalf("%d: value %d got %q but expected %q", i, j, value, testValue)
}
}
indexID, _, err := DecodeIndexKeyPrefix(&a, &tableDesc, entry.Key)
if err != nil {
t.Fatal(err)
}
if indexID != index.ID {
t.Errorf("%d", i)
}
extracted, err := ExtractIndexKey(&a, &tableDesc, entry)
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(extracted, primaryKey) {
t.Errorf("%d got %s <%x>, but expected %s <%x>", i, extracted, []byte(extracted), roachpb.Key(primaryKey), primaryKey)
}
}
checkEntry(&tableDesc.PrimaryIndex, primaryIndexKV)
checkEntry(&tableDesc.Indexes[0], secondaryIndexKV)
}
}