rust/greptimedb
1
0
Fork 0
mirror of https://github.com/GreptimeTeam/greptimedb.git synced 2026-05-30 03:40:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

ci: generate apidocs when pushing to default branch (#1093)

Browse Source 
* ci: generate apidocs when pushing to default branch

* ci: require clippy before running tests

* fix: resolve new clippy warnings on primitive slice

* fix: resolve more clippy warnings

* Update .github/workflows/apidoc.yml

Co-authored-by: Ruihang Xia <waynestxia@gmail.com>

* ci: add an index html to redirect

---------

Co-authored-by: Ruihang Xia <waynestxia@gmail.com>
This commit is contained in:
Ning Sun
2023-03-01 13:18:26 +08:00
committed by GitHub
parent c5c6494e0b
commit d402f83442
35 changed files with 163 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/datatypes/src/schema/column_schema.rs
View File

@@ -341,7 +341,7 @@ mod tests {
let column_schema = ColumnSchema::new("test", ConcreteDataType::int32_datatype(), false);
let vector = column_schema.create_default_vector_for_padding(4);
assert_eq!(4, vector.len());
let expect: VectorRef = Arc::new(Int32Vector::from_slice(&[0, 0, 0, 0]));
let expect: VectorRef = Arc::new(Int32Vector::from_slice([0, 0, 0, 0]));
assert_eq!(expect, vector);
}

2
src/datatypes/src/vectors/binary.rs
View File

@@ -345,7 +345,7 @@ mod tests {
assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
builder.extend_slice_of(&input, 1, 2).unwrap();
assert!(builder
.extend_slice_of(&crate::vectors::Int32Vector::from_slice(&[13]), 0, 1)
.extend_slice_of(&crate::vectors::Int32Vector::from_slice([13]), 0, 1)
.is_err());
let vector = builder.to_vector();

2
src/datatypes/src/vectors/boolean.rs
View File

@@ -365,7 +365,7 @@ mod tests {
assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
builder.extend_slice_of(&input, 1, 2).unwrap();
assert!(builder
.extend_slice_of(&crate::vectors::Int32Vector::from_slice(&[13]), 0, 1)
.extend_slice_of(&crate::vectors::Int32Vector::from_slice([13]), 0, 1)
.is_err());
let vector = builder.to_vector();

12
src/datatypes/src/vectors/date.rs
View File

@@ -58,7 +58,7 @@ mod tests {
#[test]
fn test_date_scalar() {
let vector = DateVector::from_slice(&[1, 2]);
let vector = DateVector::from_slice([1, 2]);
assert_eq!(2, vector.len());
assert_eq!(Some(Date::new(1)), vector.get_data(0));
assert_eq!(Some(Date::new(2)), vector.get_data(1));
@@ -66,24 +66,24 @@ mod tests {
#[test]
fn test_date_vector_builder() {
let input = DateVector::from_slice(&[1, 2, 3]);
let input = DateVector::from_slice([1, 2, 3]);
let mut builder = DateType::default().create_mutable_vector(3);
builder.push_value_ref(ValueRef::Date(Date::new(5)));
assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
builder.extend_slice_of(&input, 1, 2).unwrap();
assert!(builder
.extend_slice_of(&crate::vectors::Int32Vector::from_slice(&[13]), 0, 1)
.extend_slice_of(&crate::vectors::Int32Vector::from_slice([13]), 0, 1)
.is_err());
let vector = builder.to_vector();
let expect: VectorRef = Arc::new(DateVector::from_slice(&[5, 2, 3]));
let expect: VectorRef = Arc::new(DateVector::from_slice([5, 2, 3]));
assert_eq!(expect, vector);
}
#[test]
fn test_date_from_arrow() {
let vector = DateVector::from_slice(&[1, 2]);
let vector = DateVector::from_slice([1, 2]);
let arrow = vector.as_arrow().slice(0, vector.len());
let vector2 = DateVector::try_from_arrow_array(&arrow).unwrap();
assert_eq!(vector, vector2);
@@ -91,7 +91,7 @@ mod tests {
#[test]
fn test_serialize_date_vector() {
let vector = DateVector::from_slice(&[-1, 0, 1]);
let vector = DateVector::from_slice([-1, 0, 1]);
let serialized_json = serde_json::to_string(&vector.serialize_to_json().unwrap()).unwrap();
assert_eq!(
r#"["1969-12-31","1970-01-01","1970-01-02"]"#,

8
src/datatypes/src/vectors/datetime.rs
View File

@@ -81,7 +81,7 @@ mod tests {
assert_eq!(Value::Null, v.get(1));
assert_eq!(Value::DateTime(DateTime::new(-1)), v.get(2));
let input = DateTimeVector::from_wrapper_slice(&[
let input = DateTimeVector::from_wrapper_slice([
DateTime::new(1),
DateTime::new(2),
DateTime::new(3),
@@ -92,11 +92,11 @@ mod tests {
assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
builder.extend_slice_of(&input, 1, 2).unwrap();
assert!(builder
.extend_slice_of(&crate::vectors::Int32Vector::from_slice(&[13]), 0, 1)
.extend_slice_of(&crate::vectors::Int32Vector::from_slice([13]), 0, 1)
.is_err());
let vector = builder.to_vector();
let expect: VectorRef = Arc::new(DateTimeVector::from_wrapper_slice(&[
let expect: VectorRef = Arc::new(DateTimeVector::from_wrapper_slice([
DateTime::new(5),
DateTime::new(2),
DateTime::new(3),
@@ -106,7 +106,7 @@ mod tests {
#[test]
fn test_datetime_from_arrow() {
let vector = DateTimeVector::from_wrapper_slice(&[DateTime::new(1), DateTime::new(2)]);
let vector = DateTimeVector::from_wrapper_slice([DateTime::new(1), DateTime::new(2)]);
let arrow = vector.as_arrow().slice(0, vector.len());
let vector2 = DateTimeVector::try_from_arrow_array(&arrow).unwrap();
assert_eq!(vector, vector2);

30
src/datatypes/src/vectors/eq.rs
View File

@@ -167,30 +167,30 @@ mod tests {
Some("world"),
])));
assert_vector_ref_eq(Arc::new(Int8Vector::from_slice(&[1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(UInt8Vector::from_slice(&[1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(Int16Vector::from_slice(&[1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(UInt16Vector::from_slice(&[1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(Int32Vector::from_slice(&[1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(UInt32Vector::from_slice(&[1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(Int64Vector::from_slice(&[1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(UInt64Vector::from_slice(&[1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(Float32Vector::from_slice(&[1.0, 2.0, 3.0, 4.0])));
assert_vector_ref_eq(Arc::new(Float64Vector::from_slice(&[1.0, 2.0, 3.0, 4.0])));
assert_vector_ref_eq(Arc::new(Int8Vector::from_slice([1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(UInt8Vector::from_slice([1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(Int16Vector::from_slice([1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(UInt16Vector::from_slice([1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(Int32Vector::from_slice([1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(UInt32Vector::from_slice([1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(Int64Vector::from_slice([1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(UInt64Vector::from_slice([1, 2, 3, 4])));
assert_vector_ref_eq(Arc::new(Float32Vector::from_slice([1.0, 2.0, 3.0, 4.0])));
assert_vector_ref_eq(Arc::new(Float64Vector::from_slice([1.0, 2.0, 3.0, 4.0])));
}
#[test]
fn test_vector_ne() {
assert_vector_ref_ne(
Arc::new(Int32Vector::from_slice(&[1, 2, 3, 4])),
Arc::new(Int32Vector::from_slice(&[1, 2])),
Arc::new(Int32Vector::from_slice([1, 2, 3, 4])),
Arc::new(Int32Vector::from_slice([1, 2])),
);
assert_vector_ref_ne(
Arc::new(Int32Vector::from_slice(&[1, 2, 3, 4])),
Arc::new(Int8Vector::from_slice(&[1, 2, 3, 4])),
Arc::new(Int32Vector::from_slice([1, 2, 3, 4])),
Arc::new(Int8Vector::from_slice([1, 2, 3, 4])),
);
assert_vector_ref_ne(
Arc::new(Int32Vector::from_slice(&[1, 2, 3, 4])),
Arc::new(Int32Vector::from_slice([1, 2, 3, 4])),
Arc::new(BooleanVector::from(vec![true, true])),
);
assert_vector_ref_ne(

4
src/datatypes/src/vectors/list.rs
View File

@@ -624,7 +624,7 @@ pub mod tests {
);
let mut iter = list_vector.values_iter();
assert_eq!(
Arc::new(Int32Vector::from_slice(&[1, 2, 3])) as VectorRef,
Arc::new(Int32Vector::from_slice([1, 2, 3])) as VectorRef,
*iter.next().unwrap().unwrap().unwrap()
);
assert!(iter.next().unwrap().unwrap().is_none());
@@ -674,7 +674,7 @@ pub mod tests {
let input = new_list_vector(&data);
builder.extend_slice_of(&input, 1, 2).unwrap();
assert!(builder
.extend_slice_of(&crate::vectors::Int32Vector::from_slice(&[13]), 0, 1)
.extend_slice_of(&crate::vectors::Int32Vector::from_slice([13]), 0, 1)
.is_err());
let vector = builder.to_vector();

2
src/datatypes/src/vectors/null.rs
View File

@@ -276,7 +276,7 @@ mod tests {
let input = NullVector::new(3);
builder.extend_slice_of(&input, 1, 2).unwrap();
assert!(builder
.extend_slice_of(&crate::vectors::Int32Vector::from_slice(&[13]), 0, 1)
.extend_slice_of(&crate::vectors::Int32Vector::from_slice([13]), 0, 1)
.is_err());
let vector = builder.to_vector();

4
src/datatypes/src/vectors/operations/cast.rs
View File

@@ -72,7 +72,7 @@ mod tests {
u32::MAX as f64,
u64::MAX as f64,
];
let f64_vector: VectorRef = Arc::new(Float64Vector::from_slice(&f64_values));
let f64_vector: VectorRef = Arc::new(Float64Vector::from_slice(f64_values));
let f64_expected = vec![
-9223372036854776000.0,
@@ -137,7 +137,7 @@ mod tests {
i16::MAX as i32,
i32::MAX,
];
let date32_vector: VectorRef = Arc::new(DateVector::from_slice(&i32_values));
let date32_vector: VectorRef = Arc::new(DateVector::from_slice(i32_values));
let i32_expected = vec![
"-2147483648",

2
src/datatypes/src/vectors/operations/filter.rs
View File

@@ -68,7 +68,7 @@ mod tests {
}
fn check_filter_constant(expect_length: usize, input_length: usize, filter: &[bool]) {
let v = ConstantVector::new(Arc::new(Int32Vector::from_slice(&[123])), input_length);
let v = ConstantVector::new(Arc::new(Int32Vector::from_slice([123])), input_length);
let filter = BooleanVector::from_slice(filter);
let out = v.filter(&filter).unwrap();

32
src/datatypes/src/vectors/operations/find_unique.rs
View File

@@ -165,14 +165,14 @@ mod tests {
#[test]
fn test_find_unique_scalar_multi_times_with_prev() {
let prev = Int32Vector::from_slice(&[1]);
let prev = Int32Vector::from_slice([1]);
let v1 = Int32Vector::from_slice(&[2, 3, 4]);
let v1 = Int32Vector::from_slice([2, 3, 4]);
let mut selected = BitVec::repeat(false, v1.len());
v1.find_unique(&mut selected, Some(&prev));
// Though element in v2 are the same as prev, but we should still keep them.
let v2 = Int32Vector::from_slice(&[1, 1, 1]);
let v2 = Int32Vector::from_slice([1, 1, 1]);
v2.find_unique(&mut selected, Some(&prev));
check_bitmap(&[true, true, true], &selected);
@@ -184,34 +184,34 @@ mod tests {
#[test]
fn test_find_unique_scalar_with_prev() {
let prev = Int32Vector::from_slice(&[1]);
let prev = Int32Vector::from_slice([1]);
let mut selected = new_bitmap(&[true, false, true, false]);
let v = Int32Vector::from_slice(&[2, 3, 4, 5]);
let v = Int32Vector::from_slice([2, 3, 4, 5]);
v.find_unique(&mut selected, Some(&prev));
// All elements are different.
check_bitmap(&[true, true, true, true], &selected);
let mut selected = new_bitmap(&[true, false, true, false]);
let v = Int32Vector::from_slice(&[1, 2, 3, 4]);
let v = Int32Vector::from_slice([1, 2, 3, 4]);
v.find_unique(&mut selected, Some(&prev));
// Though first element is duplicate, but we keep the flag unchanged.
check_bitmap(&[true, true, true, true], &selected);
// Same case as above, but now `prev` is None.
let mut selected = new_bitmap(&[true, false, true, false]);
let v = Int32Vector::from_slice(&[1, 2, 3, 4]);
let v = Int32Vector::from_slice([1, 2, 3, 4]);
v.find_unique(&mut selected, None);
check_bitmap(&[true, true, true, true], &selected);
// Same case as above, but now `prev` is empty.
let mut selected = new_bitmap(&[true, false, true, false]);
let v = Int32Vector::from_slice(&[1, 2, 3, 4]);
v.find_unique(&mut selected, Some(&Int32Vector::from_slice(&[])));
let v = Int32Vector::from_slice([1, 2, 3, 4]);
v.find_unique(&mut selected, Some(&Int32Vector::from_slice([])));
check_bitmap(&[true, true, true, true], &selected);
let mut selected = new_bitmap(&[false, false, false, false]);
let v = Int32Vector::from_slice(&[2, 2, 4, 5]);
let v = Int32Vector::from_slice([2, 2, 4, 5]);
v.find_unique(&mut selected, Some(&prev));
// only v[1] is duplicate.
check_bitmap(&[true, false, true, true], &selected);
@@ -269,7 +269,7 @@ mod tests {
}
fn check_find_unique_constant(len: usize) {
let input = ConstantVector::new(Arc::new(Int32Vector::from_slice(&[8])), len);
let input = ConstantVector::new(Arc::new(Int32Vector::from_slice([8])), len);
let mut selected = BitVec::repeat(false, len);
input.find_unique(&mut selected, None);
@@ -281,7 +281,7 @@ mod tests {
let mut selected = BitVec::repeat(false, len);
let prev = Some(ConstantVector::new(
Arc::new(Int32Vector::from_slice(&[8])),
Arc::new(Int32Vector::from_slice([8])),
1,
));
input.find_unique(&mut selected, prev.as_ref().map(|v| v as _));
@@ -298,11 +298,11 @@ mod tests {
#[test]
fn test_find_unique_constant_with_prev() {
let prev = ConstantVector::new(Arc::new(Int32Vector::from_slice(&[1])), 1);
let prev = ConstantVector::new(Arc::new(Int32Vector::from_slice([1])), 1);
// Keep flags unchanged.
let mut selected = new_bitmap(&[true, false, true, false]);
let v = ConstantVector::new(Arc::new(Int32Vector::from_slice(&[1])), 4);
let v = ConstantVector::new(Arc::new(Int32Vector::from_slice([1])), 4);
v.find_unique(&mut selected, Some(&prev));
check_bitmap(&[true, false, true, false], &selected);
@@ -321,7 +321,7 @@ mod tests {
v.find_unique(
&mut selected,
Some(&ConstantVector::new(
Arc::new(Int32Vector::from_slice(&[1])),
Arc::new(Int32Vector::from_slice([1])),
0,
)),
);
@@ -329,7 +329,7 @@ mod tests {
// Different constant vector.
let mut selected = new_bitmap(&[false, false, true, false]);
let v = ConstantVector::new(Arc::new(Int32Vector::from_slice(&[2])), 4);
let v = ConstantVector::new(Arc::new(Int32Vector::from_slice([2])), 4);
v.find_unique(&mut selected, Some(&prev));
check_bitmap(&[true, false, true, false], &selected);
}

8
src/datatypes/src/vectors/primitive.rs
View File

@@ -518,14 +518,14 @@ mod tests {
builder.push_value_ref(ValueRef::Int64(123));
assert!(builder.try_push_value_ref(ValueRef::Int32(123)).is_err());
let input = Int64Vector::from_slice(&[7, 8, 9]);
let input = Int64Vector::from_slice([7, 8, 9]);
builder.extend_slice_of(&input, 1, 2).unwrap();
assert!(builder
.extend_slice_of(&Int32Vector::from_slice(&[13]), 0, 1)
.extend_slice_of(&Int32Vector::from_slice([13]), 0, 1)
.is_err());
let vector = builder.to_vector();
let expect: VectorRef = Arc::new(Int64Vector::from_slice(&[123, 8, 9]));
let expect: VectorRef = Arc::new(Int64Vector::from_slice([123, 8, 9]));
assert_eq!(expect, vector);
}
@@ -537,7 +537,7 @@ mod tests {
$ty::from_native($ty::MAX),
$ty::from_native($ty::MIN),
]);
let from_slice = $vec::from_slice(&[$ty::MAX, $ty::MIN]);
let from_slice = $vec::from_slice([$ty::MAX, $ty::MIN]);
assert_eq!(from_wrapper_slice, from_slice);
};
}

2
src/datatypes/src/vectors/string.rs
View File

@@ -295,7 +295,7 @@ mod tests {
let input = StringVector::from_slice(&["world", "one", "two"]);
builder.extend_slice_of(&input, 1, 2).unwrap();
assert!(builder
.extend_slice_of(&crate::vectors::Int32Vector::from_slice(&[13]), 0, 1)
.extend_slice_of(&crate::vectors::Int32Vector::from_slice([13]), 0, 1)
.is_err());
let vector = builder.to_vector();