Skip to content
Snippets Groups Projects
Commit b67ebee7 authored by nnsgmsone's avatar nnsgmsone Committed by GitHub
Browse files

Add compare (#22)

parent 4dae3c27
No related branches found
No related tags found
No related merge requests found
Showing
with 370 additions and 134 deletions
package bools
import "matrixbase/pkg/container/nulls"
type compare struct {
vs [][]bool
ns []*nulls.Nulls
}
package bytes
import (
"bytes"
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/types"
"matrixbase/pkg/container/vector"
)
func New() *compare {
return &compare{
vs: make([]*types.Bytes, 2),
ns: make([]*nulls.Nulls, 2),
}
}
func (c *compare) Vector() *vector.Vector {
return &vector.Vector{
Col: c.vs[0],
Nsp: c.ns[0],
Typ: types.T_bytes,
}
}
func (c *compare) Set(idx int, v *vector.Vector) {
c.ns[idx] = v.Nsp
c.vs[idx] = v.Bytes()
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int) int {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
return 0
} else {
c.ns[vecDst].Del(uint64(dst))
return c.vs[vecDst].Set(dst, c.vs[vecSrc], src)
}
return 0
}
func (c *compare) Compare(veci, vecj int, vi, vj int) int {
x, y := c.vs[veci], c.vs[vecj]
return bytes.Compare(x.Get(vi), y.Get(vj))
}
package float32s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
"matrixbase/pkg/vm/process"
)
func New() *compare {
return &compare{
xs: make([][]float32, 2),
ns: make([]*nulls.Nulls, 2),
vs: make([]*vector.Vector, 2),
}
}
func (c *compare) Vector() *vector.Vector {
return c.vs[0]
}
func (c *compare) Set(idx int, v *vector.Vector) {
c.vs[idx] = v
c.ns[idx] = v.Nsp
c.xs[idx] = v.Col.([]float32)
}
func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
if c.xs[veci][vi] == c.xs[vecj][vj] {
return 0
}
if c.xs[veci][vi] < c.xs[vecj][vj] {
return -1
}
return +1
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
} else {
c.ns[vecDst].Del(uint64(dst))
c.xs[vecDst][dst] = c.xs[vecSrc][src]
}
return nil
}
package float32s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
)
type compare struct {
xs [][]float32
ns []*nulls.Nulls
vs []*vector.Vector
}
package float64s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
"matrixbase/pkg/vm/process"
)
func New() *compare {
return &compare{
xs: make([][]float64, 2),
ns: make([]*nulls.Nulls, 2),
vs: make([]*vector.Vector, 2),
}
}
func (c *compare) Vector() *vector.Vector {
return c.vs[0]
}
func (c *compare) Set(idx int, v *vector.Vector) {
c.vs[idx] = v
c.ns[idx] = v.Nsp
c.xs[idx] = v.Col.([]float64)
}
func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
if c.xs[veci][vi] == c.xs[vecj][vj] {
return 0
}
if c.xs[veci][vi] < c.xs[vecj][vj] {
return -1
}
return +1
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
} else {
c.ns[vecDst].Del(uint64(dst))
c.xs[vecDst][dst] = c.xs[vecSrc][src]
}
return nil
}
package float64s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
)
type compare struct {
xs [][]float64
ns []*nulls.Nulls
vs []*vector.Vector
}
package floats
import "matrixbase/pkg/container/nulls"
type compare struct {
vs [][]float64
ns []*nulls.Nulls
}
package floats
package int16s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/types"
"matrixbase/pkg/container/vector"
"matrixbase/pkg/vm/process"
)
func New() *compare {
return &compare{
vs: make([][]float64, 2),
xs: make([][]int16, 2),
ns: make([]*nulls.Nulls, 2),
vs: make([]*vector.Vector, 2),
}
}
func (c *compare) Vector() *vector.Vector {
return &vector.Vector{
Col: c.vs[0],
Nsp: c.ns[0],
Typ: types.T_float,
}
return c.vs[0]
}
func (c *compare) Set(idx int, v *vector.Vector) {
c.vs[idx] = v
c.ns[idx] = v.Nsp
c.vs[idx] = v.Floats()
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int64) int {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
} else {
c.ns[vecDst].Del(uint64(dst))
c.vs[vecDst][dst] = c.vs[vecSrc][src]
}
return 0
c.xs[idx] = v.Col.([]int16)
}
func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
if c.vs[veci][vi] == c.vs[vecj][vj] {
if c.xs[veci][vi] == c.xs[vecj][vj] {
return 0
}
if c.vs[veci][vi] < c.vs[vecj][vj] {
if c.xs[veci][vi] < c.xs[vecj][vj] {
return -1
}
return +1
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
} else {
c.ns[vecDst].Del(uint64(dst))
c.xs[vecDst][dst] = c.xs[vecSrc][src]
}
return nil
}
package int16s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
)
type compare struct {
xs [][]int16
ns []*nulls.Nulls
vs []*vector.Vector
}
package ints
package int32s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/types"
"matrixbase/pkg/container/vector"
"matrixbase/pkg/vm/process"
)
func New() *compare {
return &compare{
vs: make([][]int64, 2),
xs: make([][]int32, 2),
ns: make([]*nulls.Nulls, 2),
vs: make([]*vector.Vector, 2),
}
}
func (c *compare) Vector() *vector.Vector {
return &vector.Vector{
Col: c.vs[0],
Nsp: c.ns[0],
Typ: types.T_int,
}
return c.vs[0]
}
func (c *compare) Set(idx int, v *vector.Vector) {
c.vs[idx] = v
c.ns[idx] = v.Nsp
c.vs[idx] = v.Ints()
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int64) int {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
} else {
c.ns[vecDst].Del(uint64(dst))
c.vs[vecDst][dst] = c.vs[vecSrc][src]
}
return 0
c.xs[idx] = v.Col.([]int32)
}
func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
if c.vs[veci][vi] == c.vs[vecj][vj] {
if c.xs[veci][vi] == c.xs[vecj][vj] {
return 0
}
if c.vs[veci][vi] < c.vs[vecj][vj] {
if c.xs[veci][vi] < c.xs[vecj][vj] {
return -1
}
return +1
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
} else {
c.ns[vecDst].Del(uint64(dst))
c.xs[vecDst][dst] = c.xs[vecSrc][src]
}
return nil
}
package int32s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
)
type compare struct {
xs [][]int32
ns []*nulls.Nulls
vs []*vector.Vector
}
package int64s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
"matrixbase/pkg/vm/process"
)
func New() *compare {
return &compare{
xs: make([][]int64, 2),
ns: make([]*nulls.Nulls, 2),
vs: make([]*vector.Vector, 2),
}
}
func (c *compare) Vector() *vector.Vector {
return c.vs[0]
}
func (c *compare) Set(idx int, v *vector.Vector) {
c.vs[idx] = v
c.ns[idx] = v.Nsp
c.xs[idx] = v.Col.([]int64)
}
func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
if c.xs[veci][vi] == c.xs[vecj][vj] {
return 0
}
if c.xs[veci][vi] < c.xs[vecj][vj] {
return -1
}
return +1
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
} else {
c.ns[vecDst].Del(uint64(dst))
c.xs[vecDst][dst] = c.xs[vecSrc][src]
}
return nil
}
package int64s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
)
type compare struct {
xs [][]int64
ns []*nulls.Nulls
vs []*vector.Vector
}
package bools
package int8s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/types"
"matrixbase/pkg/container/vector"
"matrixbase/pkg/vm/process"
)
func New() *compare {
return &compare{
vs: make([][]bool, 2),
xs: make([][]int8, 2),
ns: make([]*nulls.Nulls, 2),
vs: make([]*vector.Vector, 2),
}
}
func (c *compare) Vector() *vector.Vector {
return &vector.Vector{
Col: c.vs[0],
Nsp: c.ns[0],
Typ: types.T_bool,
}
return c.vs[0]
}
func (c *compare) Set(idx int, v *vector.Vector) {
c.vs[idx] = v
c.ns[idx] = v.Nsp
c.vs[idx] = v.Bools()
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int64) int {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
} else {
c.ns[vecDst].Del(uint64(dst))
c.vs[vecDst][dst] = c.vs[vecSrc][src]
}
return 0
c.xs[idx] = v.Col.([]int8)
}
func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
if c.vs[veci][vi] == c.vs[vecj][vj] {
if c.xs[veci][vi] == c.xs[vecj][vj] {
return 0
}
if !c.vs[veci][vi] && c.vs[vecj][vj] {
if c.xs[veci][vi] < c.xs[vecj][vj] {
return -1
}
return +1
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
} else {
c.ns[vecDst].Del(uint64(dst))
c.xs[vecDst][dst] = c.xs[vecSrc][src]
}
return nil
}
package bytes
package int8s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/types"
"matrixbase/pkg/container/vector"
)
type compare struct {
xs [][]int8
ns []*nulls.Nulls
vs []*types.Bytes
vs []*vector.Vector
}
package ints
import "matrixbase/pkg/container/nulls"
type compare struct {
vs [][]int64
ns []*nulls.Nulls
}
package uint16s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
"matrixbase/pkg/vm/process"
)
func New() *compare {
return &compare{
xs: make([][]uint16, 2),
ns: make([]*nulls.Nulls, 2),
vs: make([]*vector.Vector, 2),
}
}
func (c *compare) Vector() *vector.Vector {
return c.vs[0]
}
func (c *compare) Set(idx int, v *vector.Vector) {
c.vs[idx] = v
c.ns[idx] = v.Nsp
c.xs[idx] = v.Col.([]uint16)
}
func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
if c.xs[veci][vi] == c.xs[vecj][vj] {
return 0
}
if c.xs[veci][vi] < c.xs[vecj][vj] {
return -1
}
return +1
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
} else {
c.ns[vecDst].Del(uint64(dst))
c.xs[vecDst][dst] = c.xs[vecSrc][src]
}
return nil
}
package uint16s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
)
type compare struct {
xs [][]uint16
ns []*nulls.Nulls
vs []*vector.Vector
}
package uint32s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
"matrixbase/pkg/vm/process"
)
func New() *compare {
return &compare{
xs: make([][]uint32, 2),
ns: make([]*nulls.Nulls, 2),
vs: make([]*vector.Vector, 2),
}
}
func (c *compare) Vector() *vector.Vector {
return c.vs[0]
}
func (c *compare) Set(idx int, v *vector.Vector) {
c.vs[idx] = v
c.ns[idx] = v.Nsp
c.xs[idx] = v.Col.([]uint32)
}
func (c *compare) Compare(veci, vecj int, vi, vj int64) int {
if c.xs[veci][vi] == c.xs[vecj][vj] {
return 0
}
if c.xs[veci][vi] < c.xs[vecj][vj] {
return -1
}
return +1
}
func (c *compare) Copy(vecSrc, vecDst int, src, dst int64, _ *process.Process) error {
if c.ns[vecSrc].Any() && c.ns[vecSrc].Contains(uint64(src)) {
c.ns[vecDst].Add(uint64(dst))
} else {
c.ns[vecDst].Del(uint64(dst))
c.xs[vecDst][dst] = c.xs[vecSrc][src]
}
return nil
}
package uint32s
import (
"matrixbase/pkg/container/nulls"
"matrixbase/pkg/container/vector"
)
type compare struct {
xs [][]uint32
ns []*nulls.Nulls
vs []*vector.Vector
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment