类型体操在databend中的应用

  pub trait Scalar: 'static + Sized + Default + Any
+ where for<'a> Self::ColumnType: ScalarColumn<RefItem<'a> = Self::RefType<'a>>
+ {

pub trait ScalarUnaryFunction<L: Scalar, O: Scalar> {
    fn eval(&self, l: L::RefType<'_>, _ctx: &mut EvalContext) -> O;
}

/// Blanket implementation for all binary expression functions
impl<L: Scalar, O: Scalar, F> ScalarUnaryFunction<L, O> for F
where F: Fn(L::RefType<'_>, &mut EvalContext) -> O
{
    fn eval(&self, i1: L::RefType<'_>, ctx: &mut EvalContext) -> O {
        self(i1, ctx)
    }
}

/// A common struct to caculate Unary expression scalar op.
#[derive(Clone)]
pub struct ScalarUnaryExpression<L: Scalar, O: Scalar, F> {
    f: F,
    _phantom: PhantomData<(L, O)>,
}

impl<'a, L: Scalar, O: Scalar, F> ScalarUnaryExpression<L, O, F>
where F: ScalarUnaryFunction<L, O>
{
    /// Create a Unary expression from generic columns  and a lambda function.
    pub fn new(f: F) -> Self {
        Self {
            f,
            _phantom: PhantomData,
        }
    }

    /// Evaluate the expression with the given array.
    pub fn eval(
        &self,
        l: &'a ColumnRef,
        ctx: &mut EvalContext,
    ) -> Result<<O as Scalar>::ColumnType> {
        let left = Series::check_get_scalar::<L>(l)?;
        let it = left.scalar_iter().map(|a| (self.f).eval(a, ctx));
        let result = <O as Scalar>::ColumnType::from_owned_iterator(it);

        if let Some(error) = ctx.error.take() {
            return Err(error);
        }
        Ok(result)
    }
}

fn hash_func<H, S, O>(l: S::RefType<'_>, _ctx: &mut EvalContext) -> O
where
    S: Scalar,
    O: Scalar + FromPrimitive,
    H: Hasher + Default,
    for<'a> <S as Scalar>::RefType<'a>: DFHash,
{
    let mut h = H::default();
    l.hash(&mut h);
    O::from_u64(h.finish()).unwrap()
}
...

fn eval(
        &self,
        columns: &common_datavalues::ColumnsWithField,
        _input_rows: usize,
) -> Result<common_datavalues::ColumnRef> {
	with_match_scalar_types_error!(columns[0].data_type().data_type_id().to_physical_type(), |$S| {
		let unary = ScalarUnaryExpression::<$S, R, _>::new(hash_func::<H, $S, R>);
		let col = unary.eval(columns[0].column(), &mut EvalContext::default())?;
		Ok(Arc::new(col))
	})
}

#[test]
fn test_binary_contains() {
    //create two string columns
    struct Contains {}

    impl ScalarBinaryFunction<Vu8, Vu8, bool> for Contains {
        fn eval(&self, a: &'_ [u8], b: &'_ [u8], _ctx: &mut EvalContext) -> bool {
            a.windows(b.len()).any(|window| window == b)
        }
    }

    let binary_expression = ScalarBinaryExpression::<Vec<u8>, Vec<u8>, bool, _>::new(Contains {});

    for _ in 0..10 {
        let l = Series::from_data(vec!["11", "22", "33"]);
        let r = Series::from_data(vec!["1", "2", "43"]);
        let expected = Series::from_data(vec![true, true, false]);
        let result = binary_expression
            .eval(&l, &r, &mut EvalContext::default())
            .unwrap();
        let result = Arc::new(result) as ColumnRef;
        assert!(result == expected);
    }
}

pub trait ScalarViewer<'a>: Clone + Sized {
    type ScalarItem: Scalar<Viewer<'a> = Self>;
    type Iterator: Iterator<Item = <Self::ScalarItem as Scalar>::RefType<'a>>
        + ExactSizeIterator
        + TrustedLen;

    fn try_create(col: &'a ColumnRef) -> Result<Self>;

    fn value_at(&self, index: usize) -> <Self::ScalarItem as Scalar>::RefType<'a>;

    fn valid_at(&self, i: usize) -> bool;

    /// len is implemented in ExactSizeIterator
    fn size(&self) -> usize;

    fn null_at(&self, i: usize) -> bool {
        !self.valid_at(i)
    }

    fn is_empty(&self) -> bool {
        self.size() == 0
    }

    fn iter(&self) -> Self::Iterator;
}

#[derive(Clone)]
pub struct PrimitiveViewer<'a, T: PrimitiveType> {
    pub(crate) values: &'a [T],
    // for not nullable column, it's 0. we only need keep one sign bit to tell `null_at` that it's not null.
    // for nullable column, it's usize::max, validity will be cloned from nullable column.
    pub(crate) null_mask: usize,
    // for const column, it's 0, `value` function will fetch the first value of the column.
    // for not const column, it's usize::max, `value` function will fetch the value of the row in the column.
    pub(crate) non_const_mask: usize,
    pub(crate) size: usize,
    pub(crate) pos: usize,
    pub(crate) validity: Bitmap,
}

#[inline]
fn value_at(&self, index: usize) -> T {
	self.values[index & self.non_const_mask]
}

#[inline]
fn valid_at(&self, i: usize) -> bool {
	unsafe { self.validity.get_bit_unchecked(i & self.null_mask) }
}

fn iter(&self) -> Self {
	let mut res = self.clone();
	res.pos = 0;
	res
}

// 实现 Iterator trait
fn next(&mut self) -> Option<Self::Item> {
	if self.pos >= self.size {
		return None;
	}

	let old = self.pos;
	self.pos += 1;

	Some(unsafe { *self.values.as_ptr().add(old & self.non_const_mask) })
}

unsafe impl<'a, T> TrustedLen for PrimitiveViewer<'a, T>
where
    T: Scalar<Viewer<'a> = Self> + PrimitiveType,
    T: ScalarRef<'a, ScalarType = T>,
    T: Scalar<RefType<'a> = T>,
{
}


impl<'a, T> ExactSizeIterator for PrimitiveViewer<'a, T>
where
    T: Scalar<Viewer<'a> = Self> + PrimitiveType,
    T: ScalarRef<'a, ScalarType = T>,
    T: Scalar<RefType<'a> = T>,
{
    fn len(&self) -> usize {
        self.size - self.pos
    }
}

let viewers = columns
	.iter()
	.map(|column| Vu8::try_create_viewer(column.column()))
	.collect::<Result<Vec<_>>>()?;

let mut builder = MutableStringColumn::with_capacity(rows);
let mut buffer: Vec<u8> = Vec::with_capacity(32);
(0..rows).for_each(|row| {
	buffer.clear();
	for (idx, viewer) in viewers.iter().enumerate() {
	if !viewer.null_at(row) {
		if idx > 0 {
		buffer.extend_from_slice(sep);
		}

		buffer.extend_from_slice(viewer.value_at(row));
	}
	}
	builder.append_value(buffer.as_slice());
});
Ok(builder.to_column())