rust/greptimedb
1
0
Fork 0
mirror of https://github.com/GreptimeTeam/greptimedb.git synced 2025-12-22 22:20:02 +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

39
.github/workflows/apidoc.yml vendored Normal file
View File

@@ -0,0 +1,39 @@
on:
push:
branches:
- develop
paths-ignore:
- 'docs/**'
- 'config/**'
- '**.md'
- '.dockerignore'
- 'docker/**'
- '.gitignore'
name: Build API docs
env:
RUST_TOOLCHAIN: nightly-2023-02-26
jobs:
apidoc:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: dtolnay/rust-toolchain@master
with:
toolchain: ${{ env.RUST_TOOLCHAIN }}
- run: cargo doc --workspace --no-deps --document-private-items
- run: |
cat <<EOF > target/doc/index.html
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="refresh" content="0; url='greptime/'" />
</head>
<body></body></html>
EOF
- name: Publish dist directory
uses: JamesIves/github-pages-deploy-action@v4
with:
folder: target/doc

6
.github/workflows/develop.yml vendored
View File

@@ -24,7 +24,7 @@ on:
name: CI
env:
RUST_TOOLCHAIN: nightly-2023-02-14
RUST_TOOLCHAIN: nightly-2023-02-26
jobs:
typos:
@@ -116,6 +116,7 @@ jobs:
if: github.event.pull_request.draft == false
runs-on: ubuntu-latest-8-cores
timeout-minutes: 60
needs: [clippy]
steps:
- uses: actions/checkout@v3
- uses: arduino/setup-protoc@v1
@@ -131,7 +132,7 @@ jobs:
ETCD_VER=v3.5.7
DOWNLOAD_URL=https://github.com/etcd-io/etcd/releases/download
curl -L ${DOWNLOAD_URL}/${ETCD_VER}/etcd-${ETCD_VER}-linux-amd64.tar.gz -o /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz
mkdir -p /tmp/etcd-download
mkdir -p /tmp/etcd-download
tar xzvf /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz -C /tmp/etcd-download --strip-components=1
rm -f /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz
@@ -188,6 +189,7 @@ jobs:
if: github.event.pull_request.draft == false
runs-on: ubuntu-latest-8-cores
timeout-minutes: 60
needs: [clippy]
steps:
- uses: actions/checkout@v3
- uses: arduino/setup-protoc@v1

8
.github/workflows/release.yml vendored
View File

@@ -10,7 +10,7 @@ on:
name: Release
env:
RUST_TOOLCHAIN: nightly-2023-02-14
RUST_TOOLCHAIN: nightly-2023-02-26
# FIXME(zyy17): Would be better to use `gh release list -L 1 | cut -f 3` to get the latest release version tag, but for a long time, we will stay at 'v0.1.0-alpha-*'.
SCHEDULED_BUILD_VERSION_PREFIX: v0.1.0-alpha
@@ -76,10 +76,10 @@ jobs:
ETCD_VER=v3.5.7
DOWNLOAD_URL=https://github.com/etcd-io/etcd/releases/download
curl -L ${DOWNLOAD_URL}/${ETCD_VER}/etcd-${ETCD_VER}-linux-amd64.tar.gz -o /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz
mkdir -p /tmp/etcd-download
tar xzvf /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz -C /tmp/etcd-download --strip-components=1
mkdir -p /tmp/etcd-download
tar xzvf /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz -C /tmp/etcd-download --strip-components=1
rm -f /tmp/etcd-${ETCD_VER}-linux-amd64.tar.gz
sudo cp -a /tmp/etcd-download/etcd* /usr/local/bin/
nohup etcd >/tmp/etcd.log 2>&1 &

2
rust-toolchain.toml
View File

@@ -1,2 +1,2 @@
[toolchain]
channel = "nightly-2023-02-14"
channel = "nightly-2023-02-26"

8
src/catalog/src/system.rs
View File

@@ -219,7 +219,7 @@ fn build_primary_key_columns(entry_type: EntryType, key: &[u8]) -> HashMap<Strin
let mut m = HashMap::with_capacity(3);
m.insert(
"entry_type".to_string(),
Arc::new(UInt8Vector::from_slice(&[entry_type as u8])) as _,
Arc::new(UInt8Vector::from_slice([entry_type as u8])) as _,
);
m.insert(
"key".to_string(),
@@ -228,7 +228,7 @@ fn build_primary_key_columns(entry_type: EntryType, key: &[u8]) -> HashMap<Strin
// Timestamp in key part is intentionally left to 0
m.insert(
"timestamp".to_string(),
Arc::new(TimestampMillisecondVector::from_slice(&[0])) as _,
Arc::new(TimestampMillisecondVector::from_slice([0])) as _,
);
m
}
@@ -258,12 +258,12 @@ pub fn build_insert_request(entry_type: EntryType, key: &[u8], value: &[u8]) ->
let now = util::current_time_millis();
columns_values.insert(
"gmt_created".to_string(),
Arc::new(TimestampMillisecondVector::from_slice(&[now])) as _,
Arc::new(TimestampMillisecondVector::from_slice([now])) as _,
);
columns_values.insert(
"gmt_modified".to_string(),
Arc::new(TimestampMillisecondVector::from_slice(&[now])) as _,
Arc::new(TimestampMillisecondVector::from_slice([now])) as _,
);
InsertRequest {

4
src/common/recordbatch/src/adapter.rs
View File

@@ -242,12 +242,12 @@ mod test {
)]));
let batch1 = RecordBatch::new(
schema.clone(),
vec![Arc::new(Int32Vector::from_slice(&[1])) as _],
vec![Arc::new(Int32Vector::from_slice([1])) as _],
)
.unwrap();
let batch2 = RecordBatch::new(
schema.clone(),
vec![Arc::new(Int32Vector::from_slice(&[2])) as _],
vec![Arc::new(Int32Vector::from_slice([2])) as _],
)
.unwrap();

8
src/common/recordbatch/src/lib.rs
View File

@@ -204,7 +204,7 @@ mod tests {
);
assert!(result.is_err());
let v: VectorRef = Arc::new(Int32Vector::from_slice(&[1, 2]));
let v: VectorRef = Arc::new(Int32Vector::from_slice([1, 2]));
let expected = vec![RecordBatch::new(schema.clone(), vec![v.clone()]).unwrap()];
let r = RecordBatches::try_from_columns(schema, vec![v]).unwrap();
assert_eq!(r.take(), expected);
@@ -216,7 +216,7 @@ mod tests {
let column_b = ColumnSchema::new("b", ConcreteDataType::string_datatype(), false);
let column_c = ColumnSchema::new("c", ConcreteDataType::boolean_datatype(), false);
let va: VectorRef = Arc::new(Int32Vector::from_slice(&[1, 2]));
let va: VectorRef = Arc::new(Int32Vector::from_slice([1, 2]));
let vb: VectorRef = Arc::new(StringVector::from(vec!["hello", "world"]));
let vc: VectorRef = Arc::new(BooleanVector::from(vec![true, false]));
@@ -255,11 +255,11 @@ mod tests {
let column_b = ColumnSchema::new("b", ConcreteDataType::string_datatype(), false);
let schema = Arc::new(Schema::new(vec![column_a, column_b]));
let va1: VectorRef = Arc::new(Int32Vector::from_slice(&[1, 2]));
let va1: VectorRef = Arc::new(Int32Vector::from_slice([1, 2]));
let vb1: VectorRef = Arc::new(StringVector::from(vec!["a", "b"]));
let batch1 = RecordBatch::new(schema.clone(), vec![va1, vb1]).unwrap();
let va2: VectorRef = Arc::new(Int32Vector::from_slice(&[3, 4, 5]));
let va2: VectorRef = Arc::new(Int32Vector::from_slice([3, 4, 5]));
let vb2: VectorRef = Arc::new(StringVector::from(vec!["c", "d", "e"]));
let batch2 = RecordBatch::new(schema.clone(), vec![va2, vb2]).unwrap();

6
src/common/recordbatch/src/recordbatch.rs
View File

@@ -189,8 +189,8 @@ mod tests {
]));
let schema = Arc::new(Schema::try_from(arrow_schema).unwrap());
let c1 = Arc::new(UInt32Vector::from_slice(&[1, 2, 3]));
let c2 = Arc::new(UInt32Vector::from_slice(&[4, 5, 6]));
let c1 = Arc::new(UInt32Vector::from_slice([1, 2, 3]));
let c2 = Arc::new(UInt32Vector::from_slice([4, 5, 6]));
let columns: Vec<VectorRef> = vec![c1, c2];
let batch = RecordBatch::new(schema.clone(), columns.clone()).unwrap();
@@ -222,7 +222,7 @@ mod tests {
let schema = Arc::new(Schema::try_new(column_schemas).unwrap());
let numbers: Vec<u32> = (0..10).collect();
let columns = vec![Arc::new(UInt32Vector::from_slice(&numbers)) as VectorRef];
let columns = vec![Arc::new(UInt32Vector::from_slice(numbers)) as VectorRef];
let batch = RecordBatch::new(schema, columns).unwrap();
let output = serde_json::to_string(&batch).unwrap();

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();

2
src/query/src/datafusion.rs
View File

@@ -392,7 +392,7 @@ mod tests {
assert_eq!(
*batch.column(0),
Arc::new(UInt64Vector::from_slice(&[4950])) as VectorRef
Arc::new(UInt64Vector::from_slice([4950])) as VectorRef
);
}
_ => unreachable!(),

4
src/query/src/sql.rs
View File

@@ -277,8 +277,8 @@ mod test {
.with_time_index(true),
];
let data = vec![
Arc::new(UInt32Vector::from_slice(&[0])) as _,
Arc::new(TimestampMillisecondVector::from_slice(&[0])) as _,
Arc::new(UInt32Vector::from_slice([0])) as _,
Arc::new(TimestampMillisecondVector::from_slice([0])) as _,
];
let expected_columns = vec![
Arc::new(StringVector::from(vec!["t1", "t2"])) as _,

2
src/query/src/tests/percentile_test.rs
View File

@@ -129,7 +129,7 @@ fn create_correctness_engine() -> Arc<dyn QueryEngine> {
let numbers = [3_i32, 6_i32, 8_i32, 10_i32];
let column: VectorRef = Arc::new(Int32Vector::from_slice(&numbers));
let column: VectorRef = Arc::new(Int32Vector::from_slice(numbers));
columns.push(column);
let schema = Arc::new(Schema::new(column_schemas));

4
src/query/src/tests/query_engine_test.rs
View File

@@ -96,7 +96,7 @@ async fn test_datafusion_query_engine() -> Result<()> {
let expected: Vec<u32> = (0u32..limit as u32).collect();
assert_eq!(
*batch.column(0),
Arc::new(UInt32Vector::from_slice(&expected)) as VectorRef
Arc::new(UInt32Vector::from_slice(expected)) as VectorRef
);
Ok(())
@@ -200,7 +200,7 @@ async fn test_udf() -> Result<()> {
let expected: Vec<u32> = vec![1, 1, 4, 27, 256, 3125, 46656, 823543, 16777216, 387420489];
assert_eq!(
*batch.column(0),
Arc::new(UInt32Vector::from_slice(&expected)) as VectorRef
Arc::new(UInt32Vector::from_slice(expected)) as VectorRef
);
Ok(())

6
src/script/src/table.rs
View File

@@ -108,16 +108,16 @@ impl ScriptsTable {
// Timestamp in key part is intentionally left to 0
columns_values.insert(
"timestamp".to_string(),
Arc::new(TimestampMillisecondVector::from_slice(&[0])) as _,
Arc::new(TimestampMillisecondVector::from_slice([0])) as _,
);
let now = util::current_time_millis();
columns_values.insert(
"gmt_created".to_string(),
Arc::new(TimestampMillisecondVector::from_slice(&[now])) as _,
Arc::new(TimestampMillisecondVector::from_slice([now])) as _,
);
columns_values.insert(
"gmt_modified".to_string(),
Arc::new(TimestampMillisecondVector::from_slice(&[now])) as _,
Arc::new(TimestampMillisecondVector::from_slice([now])) as _,
);
let table = self
.catalog_manager

2
src/servers/src/grpc/flight/stream.rs
View File

@@ -140,7 +140,7 @@ mod test {
false,
)]));
let v: VectorRef = Arc::new(Int32Vector::from_slice(&[1, 2]));
let v: VectorRef = Arc::new(Int32Vector::from_slice([1, 2]));
let recordbatch = RecordBatch::new(schema.clone(), vec![v]).unwrap();
let recordbatches = RecordBatches::try_new(schema.clone(), vec![recordbatch.clone()])

4
src/storage/benches/wal/util/mod.rs
View File

@@ -71,10 +71,10 @@ pub fn gen_new_batch_and_types(putdate_nums: usize) -> (WriteBatch, Vec<i32>) {
rng.fill(&mut boolvs[..]);
rng.fill(&mut tsvs[..]);
rng.fill(&mut fvs[..]);
let intv = Arc::new(UInt64Vector::from_slice(&intvs)) as VectorRef;
let intv = Arc::new(UInt64Vector::from_slice(intvs)) as VectorRef;
let boolv = Arc::new(BooleanVector::from(boolvs.to_vec())) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_values(tsvs)) as VectorRef;
let fvs = Arc::new(Float64Vector::from_slice(&fvs)) as VectorRef;
let fvs = Arc::new(Float64Vector::from_slice(fvs)) as VectorRef;
let svs = Arc::new(StringVector::from_slice(&svs)) as VectorRef;
let mut put_data = HashMap::with_capacity(11);
put_data.insert("k1".to_string(), intv.clone());

10
src/storage/src/memtable/tests.rs
View File

@@ -579,11 +579,11 @@ fn test_memtable_projection() {
assert!(iter.next().is_none());
assert_eq!(5, batch.num_columns());
let k0 = Arc::new(TimestampMillisecondVector::from_slice(&[1000, 1001, 1002])) as VectorRef;
let k1 = Arc::new(UInt64Vector::from_slice(&[0, 1, 2])) as VectorRef;
let v0 = Arc::new(UInt64Vector::from_slice(&[10, 11, 12])) as VectorRef;
let sequences = Arc::new(UInt64Vector::from_slice(&[9, 9, 9])) as VectorRef;
let op_types = Arc::new(UInt8Vector::from_slice(&[1, 1, 1])) as VectorRef;
let k0 = Arc::new(TimestampMillisecondVector::from_slice([1000, 1001, 1002])) as VectorRef;
let k1 = Arc::new(UInt64Vector::from_slice([0, 1, 2])) as VectorRef;
let v0 = Arc::new(UInt64Vector::from_slice([10, 11, 12])) as VectorRef;
let sequences = Arc::new(UInt64Vector::from_slice([9, 9, 9])) as VectorRef;
let op_types = Arc::new(UInt8Vector::from_slice([1, 1, 1])) as VectorRef;
assert_eq!(k0, *batch.column(0));
assert_eq!(k1, *batch.column(1));

8
src/storage/src/schema.rs
View File

@@ -38,18 +38,18 @@ mod tests {
}
pub(crate) fn new_batch_with_num_values(num_value_columns: usize) -> Batch {
let k0 = Int64Vector::from_slice(&[1, 2, 3]);
let k0 = Int64Vector::from_slice([1, 2, 3]);
let timestamp = TimestampMillisecondVector::from_vec(vec![4, 5, 6]);
let mut columns: Vec<VectorRef> = vec![Arc::new(k0), Arc::new(timestamp)];
for i in 0..num_value_columns {
let vi = Int64Vector::from_slice(&[i as i64, i as i64, i as i64]);
let vi = Int64Vector::from_slice([i as i64, i as i64, i as i64]);
columns.push(Arc::new(vi));
}
let sequences = UInt64Vector::from_slice(&[100, 100, 100]);
let op_types = UInt8Vector::from_slice(&[0, 0, 0]);
let sequences = UInt64Vector::from_slice([100, 100, 100]);
let op_types = UInt8Vector::from_slice([0, 0, 0]);
columns.push(Arc::new(sequences));
columns.push(Arc::new(op_types));

2
src/storage/src/sst/parquet.rs
View File

@@ -593,7 +593,7 @@ mod tests {
// timestamp
assert_eq!(
&TimestampMillisecondVector::from_slice(&[
&TimestampMillisecondVector::from_slice([
1000.into(),
1000.into(),
1001.into(),

40
src/storage/src/write_batch.rs
View File

@@ -367,8 +367,8 @@ mod tests {
let columns = NameToVector::new(HashMap::new()).unwrap();
assert!(columns.is_empty());
let vector1 = Arc::new(Int32Vector::from_slice(&[1, 2, 3, 4, 5])) as VectorRef;
let vector2 = Arc::new(UInt64Vector::from_slice(&[0, 2, 4, 6, 8])) as VectorRef;
let vector1 = Arc::new(Int32Vector::from_slice([1, 2, 3, 4, 5])) as VectorRef;
let vector2 = Arc::new(UInt64Vector::from_slice([0, 2, 4, 6, 8])) as VectorRef;
let mut put_data = HashMap::with_capacity(3);
put_data.insert("k1".to_string(), vector1.clone());
@@ -382,7 +382,7 @@ mod tests {
#[test]
fn test_name_to_vector_empty_vector() {
let vector1 = Arc::new(Int32Vector::from_slice(&[])) as VectorRef;
let vector1 = Arc::new(Int32Vector::from_slice([])) as VectorRef;
let mut put_data = HashMap::new();
put_data.insert("k1".to_string(), vector1);
@@ -393,9 +393,9 @@ mod tests {
#[test]
fn test_write_batch_put() {
let intv = Arc::new(UInt64Vector::from_slice(&[1, 2, 3])) as VectorRef;
let intv = Arc::new(UInt64Vector::from_slice([1, 2, 3])) as VectorRef;
let boolv = Arc::new(BooleanVector::from(vec![true, false, true])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice(&[0, 0, 0])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice([0, 0, 0])) as VectorRef;
let mut put_data = HashMap::with_capacity(4);
put_data.insert("k1".to_string(), intv.clone());
@@ -437,8 +437,8 @@ mod tests {
#[test]
fn test_put_data_different_len() {
let intv = Arc::new(UInt64Vector::from_slice(&[1, 2, 3])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice(&[0, 0])) as VectorRef;
let intv = Arc::new(UInt64Vector::from_slice([1, 2, 3])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice([0, 0])) as VectorRef;
let boolv = Arc::new(BooleanVector::from(vec![true, false, true])) as VectorRef;
let mut put_data = HashMap::new();
@@ -455,7 +455,7 @@ mod tests {
#[test]
fn test_put_type_mismatch() {
let boolv = Arc::new(BooleanVector::from(vec![true, false, true])) as VectorRef;
let tsv = Arc::new(Int64Vector::from_slice(&[0, 0, 0])) as VectorRef;
let tsv = Arc::new(Int64Vector::from_slice([0, 0, 0])) as VectorRef;
let mut put_data = HashMap::new();
put_data.insert("k1".to_string(), boolv);
@@ -469,7 +469,7 @@ mod tests {
#[test]
fn test_put_type_has_null() {
let intv = Arc::new(UInt64Vector::from(vec![Some(1), None, Some(3)])) as VectorRef;
let tsv = Arc::new(Int64Vector::from_slice(&[0, 0, 0])) as VectorRef;
let tsv = Arc::new(Int64Vector::from_slice([0, 0, 0])) as VectorRef;
let mut put_data = HashMap::new();
put_data.insert("k1".to_string(), intv);
@@ -483,7 +483,7 @@ mod tests {
#[test]
fn test_put_missing_column() {
let boolv = Arc::new(BooleanVector::from(vec![true, false, true])) as VectorRef;
let tsv = Arc::new(Int64Vector::from_slice(&[0, 0, 0])) as VectorRef;
let tsv = Arc::new(Int64Vector::from_slice([0, 0, 0])) as VectorRef;
let mut put_data = HashMap::new();
put_data.insert("v1".to_string(), boolv);
@@ -496,8 +496,8 @@ mod tests {
#[test]
fn test_put_unknown_column() {
let intv = Arc::new(UInt64Vector::from_slice(&[1, 2, 3])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice(&[0, 0, 0])) as VectorRef;
let intv = Arc::new(UInt64Vector::from_slice([1, 2, 3])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice([0, 0, 0])) as VectorRef;
let boolv = Arc::new(BooleanVector::from(vec![true, false, true])) as VectorRef;
let mut put_data = HashMap::new();
@@ -528,8 +528,8 @@ mod tests {
#[test]
fn test_write_batch_delete() {
let intv = Arc::new(UInt64Vector::from_slice(&[1, 2, 3])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice(&[0, 0, 0])) as VectorRef;
let intv = Arc::new(UInt64Vector::from_slice([1, 2, 3])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice([0, 0, 0])) as VectorRef;
let mut keys = HashMap::with_capacity(3);
keys.insert("k1".to_string(), intv.clone());
@@ -548,7 +548,7 @@ mod tests {
#[test]
fn test_delete_missing_column() {
let intv = Arc::new(UInt64Vector::from_slice(&[1, 2, 3])) as VectorRef;
let intv = Arc::new(UInt64Vector::from_slice([1, 2, 3])) as VectorRef;
let mut keys = HashMap::with_capacity(3);
keys.insert("k1".to_string(), intv.clone());
@@ -561,8 +561,8 @@ mod tests {
#[test]
fn test_delete_columns_more_than_row_key() {
let intv = Arc::new(UInt64Vector::from_slice(&[1, 2, 3])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice(&[0, 0, 0])) as VectorRef;
let intv = Arc::new(UInt64Vector::from_slice([1, 2, 3])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice([0, 0, 0])) as VectorRef;
let mut keys = HashMap::with_capacity(3);
keys.insert("k1".to_string(), intv.clone());
@@ -577,7 +577,7 @@ mod tests {
#[test]
fn test_delete_type_mismatch() {
let intv = Arc::new(UInt64Vector::from_slice(&[1, 2, 3])) as VectorRef;
let intv = Arc::new(UInt64Vector::from_slice([1, 2, 3])) as VectorRef;
let boolv = Arc::new(BooleanVector::from(vec![true, false, true])) as VectorRef;
let mut keys = HashMap::with_capacity(3);
@@ -592,8 +592,8 @@ mod tests {
#[test]
fn test_delete_non_null_value() {
let intv = Arc::new(UInt64Vector::from_slice(&[1, 2, 3])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice(&[0, 0, 0])) as VectorRef;
let intv = Arc::new(UInt64Vector::from_slice([1, 2, 3])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_slice([0, 0, 0])) as VectorRef;
let mut keys = HashMap::with_capacity(2);
keys.insert("k1".to_string(), intv.clone());

4
src/storage/src/write_batch/codec.rs
View File

@@ -142,7 +142,7 @@ mod tests {
fn gen_new_batch_and_types() -> (WriteBatch, Vec<i32>) {
let mut batch = write_batch::new_test_batch();
for i in 0..10 {
let intv = Arc::new(UInt64Vector::from_slice(&[1, 2, 3])) as VectorRef;
let intv = Arc::new(UInt64Vector::from_slice([1, 2, 3])) as VectorRef;
let boolv =
Arc::new(BooleanVector::from(vec![Some(true), Some(false), None])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_vec(vec![i, i, i])) as VectorRef;
@@ -181,7 +181,7 @@ mod tests {
fn gen_new_batch_and_types_with_none_column() -> (WriteBatch, Vec<i32>) {
let mut batch = write_batch::new_test_batch();
for _ in 0..10 {
let intv = Arc::new(UInt64Vector::from_slice(&[1, 2, 3])) as VectorRef;
let intv = Arc::new(UInt64Vector::from_slice([1, 2, 3])) as VectorRef;
let tsv = Arc::new(TimestampMillisecondVector::from_vec(vec![0, 0, 0])) as VectorRef;
let mut put_data = HashMap::with_capacity(3);

2
src/storage/src/write_batch/compat.rs
View File

@@ -145,7 +145,7 @@ mod tests {
fn new_put_data() -> HashMap<String, VectorRef> {
let mut put_data = HashMap::new();
let k0 = Arc::new(Int32Vector::from_slice(&[1, 2, 3])) as VectorRef;
let k0 = Arc::new(Int32Vector::from_slice([1, 2, 3])) as VectorRef;
let ts = Arc::new(TimestampMillisecondVector::from_values([11, 12, 13])) as VectorRef;
put_data.insert("k0".to_string(), k0);

4
src/table/src/table/scan.rs
View File

@@ -100,12 +100,12 @@ mod test {
let batch1 = RecordBatch::new(
schema.clone(),
vec![Arc::new(Int32Vector::from_slice(&[1, 2])) as _],
vec![Arc::new(Int32Vector::from_slice([1, 2])) as _],
)
.unwrap();
let batch2 = RecordBatch::new(
schema.clone(),
vec![Arc::new(Int32Vector::from_slice(&[3, 4, 5])) as _],
vec![Arc::new(Int32Vector::from_slice([3, 4, 5])) as _],
)
.unwrap();