github.com/matrixorigin/matrixone@v0.7.0/pkg/partition/partition.go (about)

     1  // Copyright 2021 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 partition
    16  
    17  import (
    18  	"github.com/matrixorigin/matrixone/pkg/container/nulls"
    19  	"github.com/matrixorigin/matrixone/pkg/container/types"
    20  	"github.com/matrixorigin/matrixone/pkg/container/vector"
    21  )
    22  
    23  // Partitions will return the rowSels; vs[rowSel] != vs[last_rowSel].
    24  // by default, the 0th row is always not equal to the one before it
    25  // (though it doesn't exist)
    26  func Partition(sels []int64, diffs []bool, partitions []int64, vec *vector.Vector) []int64 {
    27  	diffs[0] = true
    28  	diffs = diffs[:len(sels)]
    29  	switch vec.Typ.Oid {
    30  	case types.T_int8:
    31  		var n bool
    32  		var v int8
    33  
    34  		vs := vec.Col.([]int8)
    35  		if nulls.Any(vec.Nsp) {
    36  			for i, sel := range sels {
    37  				w := vs[sel]
    38  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
    39  				if n != isNull {
    40  					diffs[i] = true
    41  				} else {
    42  					diffs[i] = diffs[i] || (v != vs[sel])
    43  				}
    44  				v = w
    45  				n = isNull
    46  			}
    47  			break
    48  		}
    49  		for i, sel := range sels {
    50  			w := vs[sel]
    51  			diffs[i] = diffs[i] || (v != w)
    52  			v = w
    53  		}
    54  	case types.T_int16:
    55  		var n bool
    56  		var v int16
    57  
    58  		vs := vec.Col.([]int16)
    59  		if nulls.Any(vec.Nsp) {
    60  			for i, sel := range sels {
    61  				w := vs[sel]
    62  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
    63  				if n != isNull {
    64  					diffs[i] = true
    65  				} else {
    66  					diffs[i] = diffs[i] || (v != vs[sel])
    67  				}
    68  				v = w
    69  				n = isNull
    70  			}
    71  			break
    72  		}
    73  		for i, sel := range sels {
    74  			w := vs[sel]
    75  			diffs[i] = diffs[i] || (v != w)
    76  			v = w
    77  		}
    78  	case types.T_int32:
    79  		var n bool
    80  		var v int32
    81  
    82  		vs := vec.Col.([]int32)
    83  		if nulls.Any(vec.Nsp) {
    84  			for i, sel := range sels {
    85  				w := vs[sel]
    86  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
    87  				if n != isNull {
    88  					diffs[i] = true
    89  				} else {
    90  					diffs[i] = diffs[i] || (v != vs[sel])
    91  				}
    92  				v = w
    93  				n = isNull
    94  			}
    95  			break
    96  		}
    97  		for i, sel := range sels {
    98  			w := vs[sel]
    99  			diffs[i] = diffs[i] || (v != w)
   100  			v = w
   101  		}
   102  	case types.T_date:
   103  		var n bool
   104  		var v types.Date
   105  
   106  		vs := vec.Col.([]types.Date)
   107  		if nulls.Any(vec.Nsp) {
   108  			for i, sel := range sels {
   109  				w := vs[sel]
   110  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
   111  				if n != isNull {
   112  					diffs[i] = true
   113  				} else {
   114  					diffs[i] = diffs[i] || (v != vs[sel])
   115  				}
   116  				v = w
   117  				n = isNull
   118  			}
   119  			break
   120  		}
   121  		for i, sel := range sels {
   122  			w := vs[sel]
   123  			diffs[i] = diffs[i] || (v != w)
   124  			v = w
   125  		}
   126  	case types.T_int64:
   127  		var n bool
   128  		var v int64
   129  
   130  		vs := vec.Col.([]int64)
   131  		if nulls.Any(vec.Nsp) {
   132  			for i, sel := range sels {
   133  				w := vs[sel]
   134  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
   135  				if n != isNull {
   136  					diffs[i] = true
   137  				} else {
   138  					diffs[i] = diffs[i] || (v != vs[sel])
   139  				}
   140  				v = w
   141  				n = isNull
   142  			}
   143  			break
   144  		}
   145  		for i, sel := range sels {
   146  			w := vs[sel]
   147  			diffs[i] = diffs[i] || (v != w)
   148  			v = w
   149  		}
   150  	case types.T_datetime:
   151  		var n bool
   152  		var v types.Datetime
   153  
   154  		vs := vec.Col.([]types.Datetime)
   155  		if nulls.Any(vec.Nsp) {
   156  			for i, sel := range sels {
   157  				w := vs[sel]
   158  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
   159  				if n != isNull {
   160  					diffs[i] = true
   161  				} else {
   162  					diffs[i] = diffs[i] || (v != vs[sel])
   163  				}
   164  				v = w
   165  				n = isNull
   166  			}
   167  			break
   168  		}
   169  		for i, sel := range sels {
   170  			w := vs[sel]
   171  			diffs[i] = diffs[i] || (v != w)
   172  			v = w
   173  		}
   174  	case types.T_time:
   175  		var n bool
   176  		var v types.Time
   177  
   178  		vs := vec.Col.([]types.Time)
   179  		if nulls.Any(vec.Nsp) {
   180  			for i, sel := range sels {
   181  				w := vs[sel]
   182  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
   183  				if n != isNull {
   184  					diffs[i] = true
   185  				} else {
   186  					diffs[i] = diffs[i] || (v != vs[sel])
   187  				}
   188  				v = w
   189  				n = isNull
   190  			}
   191  			break
   192  		}
   193  		for i, sel := range sels {
   194  			w := vs[sel]
   195  			diffs[i] = diffs[i] || (v != w)
   196  			v = w
   197  		}
   198  
   199  	case types.T_uint8:
   200  		var n bool
   201  		var v uint8
   202  
   203  		vs := vec.Col.([]uint8)
   204  		if nulls.Any(vec.Nsp) {
   205  			for i, sel := range sels {
   206  				w := vs[sel]
   207  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
   208  				if n != isNull {
   209  					diffs[i] = true
   210  				} else {
   211  					diffs[i] = diffs[i] || (v != vs[sel])
   212  				}
   213  				v = w
   214  				n = isNull
   215  			}
   216  			break
   217  		}
   218  		for i, sel := range sels {
   219  			w := vs[sel]
   220  			diffs[i] = diffs[i] || (v != w)
   221  			v = w
   222  		}
   223  	case types.T_uint16:
   224  		var n bool
   225  		var v uint16
   226  
   227  		vs := vec.Col.([]uint16)
   228  		if nulls.Any(vec.Nsp) {
   229  			for i, sel := range sels {
   230  				w := vs[sel]
   231  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
   232  				if n != isNull {
   233  					diffs[i] = true
   234  				} else {
   235  					diffs[i] = diffs[i] || (v != vs[sel])
   236  				}
   237  				v = w
   238  				n = isNull
   239  			}
   240  			break
   241  		}
   242  		for i, sel := range sels {
   243  			w := vs[sel]
   244  			diffs[i] = diffs[i] || (v != w)
   245  			v = w
   246  		}
   247  	case types.T_uint32:
   248  		var n bool
   249  		var v uint32
   250  
   251  		vs := vec.Col.([]uint32)
   252  		if nulls.Any(vec.Nsp) {
   253  			for i, sel := range sels {
   254  				w := vs[sel]
   255  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
   256  				if n != isNull {
   257  					diffs[i] = true
   258  				} else {
   259  					diffs[i] = diffs[i] || (v != vs[sel])
   260  				}
   261  				v = w
   262  				n = isNull
   263  			}
   264  			break
   265  		}
   266  		for i, sel := range sels {
   267  			w := vs[sel]
   268  			diffs[i] = diffs[i] || (v != w)
   269  			v = w
   270  		}
   271  	case types.T_uint64:
   272  		var n bool
   273  		var v uint64
   274  
   275  		vs := vec.Col.([]uint64)
   276  		if nulls.Any(vec.Nsp) {
   277  			for i, sel := range sels {
   278  				w := vs[sel]
   279  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
   280  				if n != isNull {
   281  					diffs[i] = true
   282  				} else {
   283  					diffs[i] = diffs[i] || (v != vs[sel])
   284  				}
   285  				v = w
   286  				n = isNull
   287  			}
   288  			break
   289  		}
   290  		for i, sel := range sels {
   291  			w := vs[sel]
   292  			diffs[i] = diffs[i] || (v != w)
   293  			v = w
   294  		}
   295  	case types.T_float32:
   296  		var n bool
   297  		var v float32
   298  
   299  		vs := vec.Col.([]float32)
   300  		if nulls.Any(vec.Nsp) {
   301  			for i, sel := range sels {
   302  				w := vs[sel]
   303  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
   304  				if n != isNull {
   305  					diffs[i] = true
   306  				} else {
   307  					diffs[i] = diffs[i] || (v != vs[sel])
   308  				}
   309  				v = w
   310  				n = isNull
   311  			}
   312  			break
   313  		}
   314  		for i, sel := range sels {
   315  			w := vs[sel]
   316  			diffs[i] = diffs[i] || (v != w)
   317  			v = w
   318  		}
   319  	case types.T_float64:
   320  		var n bool
   321  		var v float64
   322  
   323  		vs := vec.Col.([]float64)
   324  		if nulls.Any(vec.Nsp) {
   325  			for i, sel := range sels {
   326  				w := vs[sel]
   327  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
   328  				if n != isNull {
   329  					diffs[i] = true
   330  				} else {
   331  					diffs[i] = diffs[i] || (v != vs[sel])
   332  				}
   333  				v = w
   334  				n = isNull
   335  			}
   336  			break
   337  		}
   338  		for i, sel := range sels {
   339  			w := vs[sel]
   340  			diffs[i] = diffs[i] || (v != w)
   341  			v = w
   342  		}
   343  	case types.T_char, types.T_varchar, types.T_json:
   344  		var n bool
   345  		var v string
   346  		vs := vector.GetStrVectorValues(vec)
   347  		if nulls.Any(vec.Nsp) {
   348  			for i, sel := range sels {
   349  				w := vs[sel]
   350  				isNull := nulls.Contains(vec.Nsp, uint64(sel))
   351  				if n != isNull {
   352  					diffs[i] = true
   353  				} else {
   354  					diffs[i] = diffs[i] || (v != w)
   355  				}
   356  				n = isNull
   357  				v = w
   358  			}
   359  			break
   360  		}
   361  		for i, sel := range sels {
   362  			w := vs[sel]
   363  			diffs[i] = diffs[i] || (v != w)
   364  			v = w
   365  		}
   366  	}
   367  	partitions = partitions[:0]
   368  	for i, j := int64(0), int64(len(diffs)); i < j; i++ {
   369  		if diffs[i] {
   370  			partitions = append(partitions, i)
   371  		}
   372  	}
   373  	return partitions
   374  }