github.com/matrixorigin/matrixone@v0.7.0/pkg/sql/plan/function/operator/compare_test.go (about)

     1  // Copyright 2022 Matrix Origin
     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 operator
    16  
    17  import (
    18  	"testing"
    19  
    20  	"github.com/matrixorigin/matrixone/pkg/container/vector"
    21  	"github.com/matrixorigin/matrixone/pkg/testutil"
    22  	"github.com/smartystreets/goconvey/convey"
    23  	"github.com/stretchr/testify/require"
    24  )
    25  
    26  func TestEqUuid(t *testing.T) {
    27  	convey.Convey("test uuid equal", t, func() {
    28  		cases := []struct {
    29  			left   string
    30  			right  string
    31  			result bool
    32  		}{
    33  			{
    34  				//name:  "test01",
    35  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
    36  				right: "0d5687da-2a67-11ed-99e0-000c29847904",
    37  				// 0
    38  				result: true,
    39  			},
    40  			{
    41  				//name:  "test02",
    42  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
    43  				right: "6119dffd-2a6b-11ed-99e0-000c29847904",
    44  				// -1
    45  				result: false,
    46  			},
    47  			{
    48  				//name:  "test03",
    49  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
    50  				right: "04ddf8bf-2a8a-11ed-99e0-000c29847904",
    51  				// -1
    52  				result: false,
    53  			},
    54  			{
    55  				//name:  "test04",
    56  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
    57  				right: "0d568802-2a67-11ed-99e0-000c29847904",
    58  				// -1
    59  				result: false,
    60  			},
    61  			{
    62  				//name:  "test05",
    63  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
    64  				right: "04ddf3f8-2a8a-11ed-99e0-000c29847904",
    65  				// 1
    66  				result: false,
    67  			},
    68  			{
    69  				//name:  "test06",
    70  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
    71  				right: "6d1b1fd4-2dbf-11ed-940f-000c29847904",
    72  				// 0
    73  				result: true,
    74  			},
    75  		}
    76  
    77  		var lefts []string
    78  		var rights []string
    79  		var wants []bool
    80  		for _, c := range cases {
    81  			lefts = append(lefts, c.left)
    82  			rights = append(rights, c.right)
    83  			wants = append(wants, c.result)
    84  		}
    85  
    86  		leftVector := testutil.MakeUuidVectorByString(lefts, nil)
    87  		rightVector := testutil.MakeUuidVectorByString(rights, nil)
    88  		wantVector := testutil.MakeBoolVector(wants)
    89  
    90  		proc := testutil.NewProc()
    91  		actVector, err := EqUuid([]*vector.Vector{leftVector, rightVector}, proc)
    92  		convey.ShouldBeNil(err)
    93  		compare := testutil.CompareVectors(wantVector, actVector)
    94  		convey.ShouldBeTrue(compare)
    95  		t.Logf("want slice: %+v \n", wantVector.Col)
    96  		t.Logf("actu slice: %+v \n", actVector.Col)
    97  		require.Equal(t, wantVector.Col, actVector.Col)
    98  	})
    99  
   100  }
   101  
   102  func TestLeUuid(t *testing.T) {
   103  	convey.Convey("test uuid less equal", t, func() {
   104  		cases := []struct {
   105  			left   string
   106  			right  string
   107  			result bool
   108  		}{
   109  			{
   110  				//name:  "test01",
   111  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
   112  				right: "0d5687da-2a67-11ed-99e0-000c29847904",
   113  				// 0
   114  				result: true,
   115  			},
   116  			{
   117  				//name:  "test02",
   118  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
   119  				right: "6119dffd-2a6b-11ed-99e0-000c29847904",
   120  				// -1
   121  				result: true,
   122  			},
   123  			{
   124  				//name:  "test03",
   125  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   126  				right: "04ddf8bf-2a8a-11ed-99e0-000c29847904",
   127  				// -1
   128  				result: true,
   129  			},
   130  			{
   131  				//name:  "test04",
   132  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   133  				right: "0d568802-2a67-11ed-99e0-000c29847904",
   134  				// -1
   135  				result: true,
   136  			},
   137  			{
   138  				//name:  "test05",
   139  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   140  				right: "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   141  				// 1
   142  				result: false,
   143  			},
   144  			{
   145  				//name:  "test06",
   146  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   147  				right: "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   148  				// 0
   149  				result: true,
   150  			},
   151  			{
   152  				//name:  "test07",
   153  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   154  				right: "0d568802-2a67-11ed-99e0-000c29847904",
   155  				//-1,
   156  				result: true,
   157  			},
   158  		}
   159  
   160  		var lefts []string
   161  		var rights []string
   162  		var wants []bool
   163  		for _, c := range cases {
   164  			lefts = append(lefts, c.left)
   165  			rights = append(rights, c.right)
   166  			wants = append(wants, c.result)
   167  		}
   168  
   169  		leftVector := testutil.MakeUuidVectorByString(lefts, nil)
   170  		rightVector := testutil.MakeUuidVectorByString(rights, nil)
   171  		wantVector := testutil.MakeBoolVector(wants)
   172  
   173  		proc := testutil.NewProc()
   174  		actVector, err := LeUuid([]*vector.Vector{leftVector, rightVector}, proc)
   175  		convey.ShouldBeNil(err)
   176  
   177  		compare := testutil.CompareVectors(wantVector, actVector)
   178  		convey.ShouldBeTrue(compare)
   179  		t.Logf("want slice: %+v \n", wantVector.Col)
   180  		t.Logf("actu slice: %+v \n", actVector.Col)
   181  		require.Equal(t, wantVector.Col, actVector.Col)
   182  
   183  	})
   184  }
   185  
   186  func TestLtUuid(t *testing.T) {
   187  	convey.Convey("test uuid less than", t, func() {
   188  		cases := []struct {
   189  			left   string
   190  			right  string
   191  			result bool
   192  		}{
   193  			{
   194  				//name:  "test01",
   195  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
   196  				right: "0d5687da-2a67-11ed-99e0-000c29847904",
   197  				// 0
   198  				result: false,
   199  			},
   200  			{
   201  				//name:  "test02",
   202  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
   203  				right: "6119dffd-2a6b-11ed-99e0-000c29847904",
   204  				// -1
   205  				result: true,
   206  			},
   207  			{
   208  				//name:  "test03",
   209  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   210  				right: "04ddf8bf-2a8a-11ed-99e0-000c29847904",
   211  				// -1
   212  				result: true,
   213  			},
   214  			{
   215  				//name:  "test04",
   216  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   217  				right: "0d568802-2a67-11ed-99e0-000c29847904",
   218  				// -1
   219  				result: true,
   220  			},
   221  			{
   222  				//name:  "test05",
   223  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   224  				right: "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   225  				// 1
   226  				result: false,
   227  			},
   228  			{
   229  				//name:  "test06",
   230  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   231  				right: "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   232  				// 0
   233  				result: false,
   234  			},
   235  			{
   236  				//name:  "test07",
   237  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   238  				right: "0d568802-2a67-11ed-99e0-000c29847904",
   239  				//-1,
   240  				result: true,
   241  			},
   242  		}
   243  
   244  		var lefts []string
   245  		var rights []string
   246  		var wants []bool
   247  		for _, c := range cases {
   248  			lefts = append(lefts, c.left)
   249  			rights = append(rights, c.right)
   250  			wants = append(wants, c.result)
   251  		}
   252  
   253  		leftVector := testutil.MakeUuidVectorByString(lefts, nil)
   254  		rightVector := testutil.MakeUuidVectorByString(rights, nil)
   255  		wantVector := testutil.MakeBoolVector(wants)
   256  
   257  		proc := testutil.NewProc()
   258  		actVector, err := LtUuid([]*vector.Vector{leftVector, rightVector}, proc)
   259  		convey.ShouldBeNil(err)
   260  
   261  		compare := testutil.CompareVectors(wantVector, actVector)
   262  		convey.ShouldBeTrue(compare)
   263  		t.Logf("want slice: %+v \n", wantVector.Col)
   264  		t.Logf("actu slice: %+v \n", actVector.Col)
   265  		require.Equal(t, wantVector.Col, actVector.Col)
   266  
   267  	})
   268  }
   269  
   270  func TestGeUuid(t *testing.T) {
   271  	convey.Convey("test uuid great equal", t, func() {
   272  		cases := []struct {
   273  			left   string
   274  			right  string
   275  			result bool
   276  		}{
   277  			{
   278  				//name:  "test01",
   279  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
   280  				right: "0d5687da-2a67-11ed-99e0-000c29847904",
   281  				// 0
   282  				result: true,
   283  			},
   284  			{
   285  				//name:  "test02",
   286  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
   287  				right: "6119dffd-2a6b-11ed-99e0-000c29847904",
   288  				// -1
   289  				result: false,
   290  			},
   291  			{
   292  				//name:  "test03",
   293  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   294  				right: "04ddf8bf-2a8a-11ed-99e0-000c29847904",
   295  				// -1
   296  				result: false,
   297  			},
   298  			{
   299  				//name:  "test04",
   300  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   301  				right: "0d568802-2a67-11ed-99e0-000c29847904",
   302  				// -1
   303  				result: false,
   304  			},
   305  			{
   306  				//name:  "test05",
   307  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   308  				right: "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   309  				// 1
   310  				result: true,
   311  			},
   312  			{
   313  				//name:  "test06",
   314  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   315  				right: "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   316  				// 0
   317  				result: true,
   318  			},
   319  			{
   320  				//name:  "test07",
   321  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   322  				right: "0d568802-2a67-11ed-99e0-000c29847904",
   323  				//-1,
   324  				result: false,
   325  			},
   326  		}
   327  
   328  		var lefts []string
   329  		var rights []string
   330  		var wants []bool
   331  		for _, c := range cases {
   332  			lefts = append(lefts, c.left)
   333  			rights = append(rights, c.right)
   334  			wants = append(wants, c.result)
   335  		}
   336  
   337  		leftVector := testutil.MakeUuidVectorByString(lefts, nil)
   338  		rightVector := testutil.MakeUuidVectorByString(rights, nil)
   339  		wantVector := testutil.MakeBoolVector(wants)
   340  
   341  		proc := testutil.NewProc()
   342  		actVector, err := GeUuid([]*vector.Vector{leftVector, rightVector}, proc)
   343  		convey.ShouldBeNil(err)
   344  
   345  		compare := testutil.CompareVectors(wantVector, actVector)
   346  		convey.ShouldBeTrue(compare)
   347  		t.Logf("want slice: %+v \n", wantVector.Col)
   348  		t.Logf("actu slice: %+v \n", actVector.Col)
   349  		require.Equal(t, wantVector.Col, actVector.Col)
   350  	})
   351  }
   352  
   353  func TestGtUuid(t *testing.T) {
   354  	convey.Convey("test uuid great than", t, func() {
   355  		cases := []struct {
   356  			left   string
   357  			right  string
   358  			result bool
   359  		}{
   360  			{
   361  				//name:  "test01",
   362  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
   363  				right: "0d5687da-2a67-11ed-99e0-000c29847904",
   364  				// 0
   365  				result: false,
   366  			},
   367  			{
   368  				//name:  "test02",
   369  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
   370  				right: "6119dffd-2a6b-11ed-99e0-000c29847904",
   371  				// -1
   372  				result: false,
   373  			},
   374  			{
   375  				//name:  "test03",
   376  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   377  				right: "04ddf8bf-2a8a-11ed-99e0-000c29847904",
   378  				// -1
   379  				result: false,
   380  			},
   381  			{
   382  				//name:  "test04",
   383  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   384  				right: "0d568802-2a67-11ed-99e0-000c29847904",
   385  				// -1
   386  				result: false,
   387  			},
   388  			{
   389  				//name:  "test05",
   390  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   391  				right: "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   392  				// 1
   393  				result: true,
   394  			},
   395  			{
   396  				//name:  "test06",
   397  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   398  				right: "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   399  				// 0
   400  				result: false,
   401  			},
   402  			{
   403  				//name:  "test07",
   404  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   405  				right: "0d568802-2a67-11ed-99e0-000c29847904",
   406  				//-1,
   407  				result: false,
   408  			},
   409  		}
   410  
   411  		var lefts []string
   412  		var rights []string
   413  		var wants []bool
   414  		for _, c := range cases {
   415  			lefts = append(lefts, c.left)
   416  			rights = append(rights, c.right)
   417  			wants = append(wants, c.result)
   418  		}
   419  
   420  		leftVector := testutil.MakeUuidVectorByString(lefts, nil)
   421  		rightVector := testutil.MakeUuidVectorByString(rights, nil)
   422  		wantVector := testutil.MakeBoolVector(wants)
   423  
   424  		proc := testutil.NewProc()
   425  		actVector, err := GtUuid([]*vector.Vector{leftVector, rightVector}, proc)
   426  		convey.ShouldBeNil(err)
   427  
   428  		compare := testutil.CompareVectors(wantVector, actVector)
   429  		convey.ShouldBeTrue(compare)
   430  		t.Logf("want slice: %+v \n", wantVector.Col)
   431  		t.Logf("actu slice: %+v \n", actVector.Col)
   432  		require.Equal(t, wantVector.Col, actVector.Col)
   433  	})
   434  }
   435  
   436  func TestNeUuid(t *testing.T) {
   437  	convey.Convey("test uuid not equal", t, func() {
   438  		cases := []struct {
   439  			left   string
   440  			right  string
   441  			result bool
   442  		}{
   443  			{
   444  				//name:  "test01",
   445  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
   446  				right: "0d5687da-2a67-11ed-99e0-000c29847904",
   447  				// 0
   448  				result: false,
   449  			},
   450  			{
   451  				//name:  "test02",
   452  				left:  "0d5687da-2a67-11ed-99e0-000c29847904",
   453  				right: "6119dffd-2a6b-11ed-99e0-000c29847904",
   454  				// -1
   455  				result: true,
   456  			},
   457  			{
   458  				//name:  "test03",
   459  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   460  				right: "04ddf8bf-2a8a-11ed-99e0-000c29847904",
   461  				// -1
   462  				result: true,
   463  			},
   464  			{
   465  				//name:  "test04",
   466  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   467  				right: "0d568802-2a67-11ed-99e0-000c29847904",
   468  				// -1
   469  				result: true,
   470  			},
   471  			{
   472  				//name:  "test05",
   473  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   474  				right: "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   475  				// 1
   476  				result: true,
   477  			},
   478  			{
   479  				//name:  "test06",
   480  				left:  "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   481  				right: "6d1b1fd4-2dbf-11ed-940f-000c29847904",
   482  				// 0
   483  				result: false,
   484  			},
   485  			{
   486  				//name:  "test07",
   487  				left:  "04ddf3f8-2a8a-11ed-99e0-000c29847904",
   488  				right: "0d568802-2a67-11ed-99e0-000c29847904",
   489  				//-1,
   490  				result: true,
   491  			},
   492  		}
   493  
   494  		var lefts []string
   495  		var rights []string
   496  		var wants []bool
   497  		for _, c := range cases {
   498  			lefts = append(lefts, c.left)
   499  			rights = append(rights, c.right)
   500  			wants = append(wants, c.result)
   501  		}
   502  
   503  		leftVector := testutil.MakeUuidVectorByString(lefts, nil)
   504  		rightVector := testutil.MakeUuidVectorByString(rights, nil)
   505  		wantVector := testutil.MakeBoolVector(wants)
   506  
   507  		proc := testutil.NewProc()
   508  		actVector, err := NeUuid([]*vector.Vector{leftVector, rightVector}, proc)
   509  		convey.ShouldBeNil(err)
   510  
   511  		compare := testutil.CompareVectors(wantVector, actVector)
   512  		convey.ShouldBeTrue(compare)
   513  		t.Logf("want slice: %+v \n", wantVector.Col)
   514  		t.Logf("actu slice: %+v \n", actVector.Col)
   515  		require.Equal(t, wantVector.Col, actVector.Col)
   516  	})
   517  }