vitess.io/vitess@v0.16.2/go/vt/vtgate/semantics/table_set_test.go (about)

     1  /*
     2  Copyright 2020 The Vitess Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package semantics
    18  
    19  import (
    20  	"math/rand"
    21  	"testing"
    22  
    23  	"github.com/stretchr/testify/assert"
    24  )
    25  
    26  var (
    27  	F1 = SingleTableSet(0)
    28  	F2 = SingleTableSet(1)
    29  	F3 = SingleTableSet(2)
    30  
    31  	F12  = F1.Merge(F2)
    32  	F123 = F12.Merge(F3)
    33  )
    34  
    35  func TestTableSet_IsOverlapping(t *testing.T) {
    36  	assert.True(t, F12.IsOverlapping(F12))
    37  	assert.True(t, F1.IsOverlapping(F12))
    38  	assert.True(t, F12.IsOverlapping(F1))
    39  	assert.False(t, F3.IsOverlapping(F12))
    40  	assert.False(t, F12.IsOverlapping(F3))
    41  }
    42  
    43  func TestTableSet_IsSolvedBy(t *testing.T) {
    44  	assert.True(t, F1.IsSolvedBy(F12))
    45  	assert.False(t, (F12).IsSolvedBy(F1))
    46  	assert.False(t, F3.IsSolvedBy(F12))
    47  	assert.False(t, (F12).IsSolvedBy(F3))
    48  }
    49  
    50  func TestTableSet_Constituents(t *testing.T) {
    51  	assert.Equal(t, []TableSet{F1, F2, F3}, (F123).Constituents())
    52  	assert.Equal(t, []TableSet{F1, F2}, (F12).Constituents())
    53  	assert.Equal(t, []TableSet{F1, F3}, (F1.Merge(F3)).Constituents())
    54  	assert.Equal(t, []TableSet{F2, F3}, (F2.Merge(F3)).Constituents())
    55  	assert.Empty(t, EmptyTableSet().Constituents())
    56  }
    57  
    58  func TestTableSet_TableOffset(t *testing.T) {
    59  	assert.Equal(t, 0, F1.TableOffset())
    60  	assert.Equal(t, 1, F2.TableOffset())
    61  	assert.Equal(t, 2, F3.TableOffset())
    62  }
    63  
    64  func TestTableSet_LargeTablesConstituents(t *testing.T) {
    65  	const GapSize = 32
    66  
    67  	var ts TableSet
    68  	var expected []TableSet
    69  	var table int
    70  
    71  	for t := 0; t < 256; t++ {
    72  		table += rand.Intn(GapSize) + 1
    73  		expected = append(expected, SingleTableSet(table))
    74  		ts = ts.WithTable(table)
    75  	}
    76  
    77  	assert.Equal(t, expected, ts.Constituents())
    78  }
    79  
    80  func TestTabletSet_LargeMergeInPlace(t *testing.T) {
    81  	const SetRange = 256
    82  	const Blocks = 64
    83  
    84  	var tablesets = make([]TableSet, 64)
    85  
    86  	for i := range tablesets {
    87  		setrng := i * SetRange
    88  		for tid := 0; tid < SetRange; tid++ {
    89  			tablesets[i] = tablesets[i].WithTable(setrng + tid)
    90  		}
    91  	}
    92  
    93  	var result TableSet
    94  	for _, ts := range tablesets {
    95  		result = result.Merge(ts)
    96  	}
    97  
    98  	var expected = make([]TableSet, SetRange*Blocks)
    99  	for tid := range expected {
   100  		expected[tid] = SingleTableSet(tid)
   101  	}
   102  
   103  	assert.Equal(t, expected, result.Constituents())
   104  }
   105  
   106  func TestTabletSet_LargeMerge(t *testing.T) {
   107  	const SetRange = 256
   108  	const Blocks = 64
   109  
   110  	var tablesets = make([]TableSet, 64)
   111  
   112  	for i := range tablesets {
   113  		setrng := i * SetRange
   114  		for tid := 0; tid < SetRange; tid++ {
   115  			tablesets[i] = tablesets[i].WithTable(setrng + tid)
   116  		}
   117  	}
   118  
   119  	var result TableSet
   120  	for _, ts := range tablesets {
   121  		result = result.Merge(ts)
   122  	}
   123  
   124  	var expected = make([]TableSet, SetRange*Blocks)
   125  	for tid := range expected {
   126  		expected[tid] = SingleTableSet(tid)
   127  	}
   128  
   129  	assert.Equal(t, expected, result.Constituents())
   130  }
   131  
   132  func TestTableSet_LargeOffset(t *testing.T) {
   133  	for tid := 0; tid < 1024; tid++ {
   134  		ts := SingleTableSet(tid)
   135  		assert.Equal(t, tid, ts.TableOffset())
   136  	}
   137  }
   138  
   139  func TestTableSet_KeepOnly(t *testing.T) {
   140  	testcases := []struct {
   141  		name   string
   142  		ts1    TableSet
   143  		ts2    TableSet
   144  		result TableSet
   145  	}{
   146  		{
   147  			name:   "both small",
   148  			ts1:    SingleTableSet(1).Merge(SingleTableSet(2)).Merge(SingleTableSet(3)),
   149  			ts2:    SingleTableSet(1).Merge(SingleTableSet(3)).Merge(SingleTableSet(4)),
   150  			result: SingleTableSet(1).Merge(SingleTableSet(3)),
   151  		}, {
   152  			name:   "both large",
   153  			ts1:    SingleTableSet(1428).Merge(SingleTableSet(2432)).Merge(SingleTableSet(3412)),
   154  			ts2:    SingleTableSet(1428).Merge(SingleTableSet(3412)).Merge(SingleTableSet(4342)),
   155  			result: SingleTableSet(1428).Merge(SingleTableSet(3412)),
   156  		}, {
   157  			name:   "ts1 small ts2 large",
   158  			ts1:    SingleTableSet(1).Merge(SingleTableSet(2)).Merge(SingleTableSet(3)),
   159  			ts2:    SingleTableSet(1).Merge(SingleTableSet(3)).Merge(SingleTableSet(4342)),
   160  			result: SingleTableSet(1).Merge(SingleTableSet(3)),
   161  		}, {
   162  			name:   "ts1 large ts2 small",
   163  			ts1:    SingleTableSet(1).Merge(SingleTableSet(2771)).Merge(SingleTableSet(3)),
   164  			ts2:    SingleTableSet(1).Merge(SingleTableSet(3)).Merge(SingleTableSet(4)),
   165  			result: SingleTableSet(1).Merge(SingleTableSet(3)),
   166  		},
   167  	}
   168  
   169  	for _, testcase := range testcases {
   170  		t.Run(testcase.name, func(t *testing.T) {
   171  			keep := testcase.ts1.KeepOnly(testcase.ts2)
   172  			assert.Equal(t, testcase.result, keep)
   173  		})
   174  	}
   175  }
   176  
   177  func TestTableSet_RemoveInPlace(t *testing.T) {
   178  	testcases := []struct {
   179  		name   string
   180  		ts1    TableSet
   181  		ts2    TableSet
   182  		result TableSet
   183  	}{
   184  		{
   185  			name:   "both small",
   186  			ts1:    SingleTableSet(1).Merge(SingleTableSet(2)).Merge(SingleTableSet(3)),
   187  			ts2:    SingleTableSet(1).Merge(SingleTableSet(5)).Merge(SingleTableSet(4)),
   188  			result: SingleTableSet(2).Merge(SingleTableSet(3)),
   189  		}, {
   190  			name:   "both large",
   191  			ts1:    SingleTableSet(1428).Merge(SingleTableSet(2432)).Merge(SingleTableSet(3412)),
   192  			ts2:    SingleTableSet(1424).Merge(SingleTableSet(2432)).Merge(SingleTableSet(4342)),
   193  			result: SingleTableSet(1428).Merge(SingleTableSet(3412)),
   194  		}, {
   195  			name:   "ts1 small ts2 large",
   196  			ts1:    SingleTableSet(1).Merge(SingleTableSet(2)).Merge(SingleTableSet(3)),
   197  			ts2:    SingleTableSet(14).Merge(SingleTableSet(2)).Merge(SingleTableSet(4342)),
   198  			result: SingleTableSet(1).Merge(SingleTableSet(3)),
   199  		}, {
   200  			name:   "ts1 large ts2 small",
   201  			ts1:    SingleTableSet(1).Merge(SingleTableSet(2771)).Merge(SingleTableSet(3)),
   202  			ts2:    SingleTableSet(1).Merge(SingleTableSet(3)).Merge(SingleTableSet(4)),
   203  			result: SingleTableSet(2771),
   204  		},
   205  	}
   206  
   207  	for _, testcase := range testcases {
   208  		t.Run(testcase.name, func(t *testing.T) {
   209  			remove := testcase.ts1.Remove(testcase.ts2)
   210  			assert.Equal(t, testcase.result, remove)
   211  		})
   212  	}
   213  }