type -> value_type

zanmato1984 · zanmato1984 · commit eaa9a3ca748c · 2025-01-15T20:03:11.000+08:00
diff --git a/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc b/cpp/src/arrow/compute/kernels/vector_swizzle_test.cc
@@ -467,12 +467,12 @@ void DoTestScatter(const std::shared_ptr<Array>& values,
   DoTestScatterForIndicesTypes(kSignedIntegerTypes, values, indices, max_index, expected);
 }
 
-void TestScatter(const std::shared_ptr<DataType>& type, const std::string& values_str,
-                 const std::string& indices_str, int64_t max_index,
-                 const std::string& expected_str) {
-  auto values = ArrayFromJSON(type, values_str);
+void TestScatter(const std::shared_ptr<DataType>& value_type,
+                 const std::string& values_str, const std::string& indices_str,
+                 int64_t max_index, const std::string& expected_str) {
+  auto values = ArrayFromJSON(value_type, values_str);
   auto indices = ArrayFromJSON(int8(), indices_str);
-  auto expected = ArrayFromJSON(type, expected_str);
+  auto expected = ArrayFromJSON(value_type, expected_str);
   DoTestScatter(values, indices, max_index, expected);
 }
 
@@ -639,141 +639,141 @@ TEST(Scatter, Boolean) {
 }
 
 TEST(Scatter, Numeric) {
-  for (const auto& type : kSignedIntegerTypes) {
-    ARROW_SCOPED_TRACE(type->ToString());
+  for (const auto& value_type : kSignedIntegerTypes) {
+    ARROW_SCOPED_TRACE(value_type->ToString());
     {
       ARROW_SCOPED_TRACE("Basic");
       auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
       auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
       int64_t max_index = 9;
       auto expected = "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Values with nulls");
       auto values = "[null, 11, null, 13, null, 15, null, 17, null, 19]";
       auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
       int64_t max_index = 9;
       auto expected = "[19, null, 17, null, 15, null, 13, null, 11, null]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Indices with nulls");
       auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";
       auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
       int64_t max_index = 9;
       auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Output greater than input");
       auto values = "[0, 0, 0, 1, 1, 1]";
       auto indices = "[0, 3, 6, 1, 4, 7]";
       int64_t max_index = 8;
       auto expected = "[0, 1, null, 0, 1, null, 0, 1, null]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Values all null");
       auto values = "[null, null]";
       auto indices = "[0, 1]";
       int64_t max_index = 1;
       auto expected = "[null, null]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Indices all null");
       auto values = "[0, 1]";
       auto indices = "[null, null]";
       int64_t max_index = 1;
       auto expected = "[null, null]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Empty input output null");
       auto values = "[]";
       auto indices = "[]";
       int64_t max_index = 1;
       auto expected = "[null, null]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Indices duplicated indices");
       auto values = "[1, 0, null, null]";
       auto indices = "[0, 1, 0, 1]";
       int64_t max_index = 3;
       auto expected = "[null, null, null, null]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
   }
 }
 
 TEST(Scatter, Binary) {
-  for (const auto& type : kBinaryTypes) {
-    ARROW_SCOPED_TRACE(type->ToString());
+  for (const auto& value_type : kBinaryTypes) {
+    ARROW_SCOPED_TRACE(value_type->ToString());
     {
       ARROW_SCOPED_TRACE("Basic");
       auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
       auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
       int64_t max_index = 9;
       auto expected = R"(["j", "i", "h", "g", "f", "e", "d", "c", "b", "a"])";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Values with nulls");
       auto values = R"([null, "b", null, "d", null, "f", null, "h", null, "j"])";
       auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";
       int64_t max_index = 9;
       auto expected = R"(["j", null, "h", null, "f", null, "d", null, "b", null])";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Indices with nulls");
       auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";
       auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";
       int64_t max_index = 9;
       auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Output greater than input");
       auto values = R"(["a", "a", "a", "b", "b", "b"])";
       auto indices = "[0, 3, 6, 1, 4, 7]";
       int64_t max_index = 8;
       auto expected = R"(["a", "b", null, "a", "b", null, "a", "b", null])";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Values all null");
       auto values = "[null, null]";
       auto indices = "[0, 1]";
       int64_t max_index = 1;
       auto expected = "[null, null]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Indices all null");
       auto values = R"(["a", "b"])";
       auto indices = "[null, null]";
       int64_t max_index = 1;
       auto expected = "[null, null]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Empty input output null");
       auto values = "[]";
       auto indices = "[]";
       int64_t max_index = 1;
       auto expected = "[null, null]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
     {
       ARROW_SCOPED_TRACE("Indices duplicated indices");
       auto values = R"(["a", "b", null, null])";
       auto indices = "[0, 1, 0, 1]";
       int64_t max_index = 3;
       auto expected = "[null, null, null, null]";
-      TestScatter(type, values, indices, max_index, expected);
+      TestScatter(value_type, values, indices, max_index, expected);
     }
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -467,12 +467,12 @@ void DoTestScatter(const std::shared_ptr<Array>& values,`
`467`	`467`	`DoTestScatterForIndicesTypes(kSignedIntegerTypes, values, indices, max_index, expected);`
`468`	`468`	`}`
`469`	`469`
`470`		`-void TestScatter(const std::shared_ptr<DataType>& type, const std::string& values_str,`
`471`		`- const std::string& indices_str, int64_t max_index,`
`472`		`- const std::string& expected_str) {`
`473`		`- auto values = ArrayFromJSON(type, values_str);`
	`470`	`+void TestScatter(const std::shared_ptr<DataType>& value_type,`
	`471`	`+ const std::string& values_str, const std::string& indices_str,`
	`472`	`+ int64_t max_index, const std::string& expected_str) {`
	`473`	`+ auto values = ArrayFromJSON(value_type, values_str);`
`474`	`474`	`auto indices = ArrayFromJSON(int8(), indices_str);`
`475`		`- auto expected = ArrayFromJSON(type, expected_str);`
	`475`	`+ auto expected = ArrayFromJSON(value_type, expected_str);`
`476`	`476`	`DoTestScatter(values, indices, max_index, expected);`
`477`	`477`	`}`
`478`	`478`
`@@ -639,141 +639,141 @@ TEST(Scatter, Boolean) {`
`639`	`639`	`}`
`640`	`640`
`641`	`641`	`TEST(Scatter, Numeric) {`
`642`		`- for (const auto& type : kSignedIntegerTypes) {`
`643`		`- ARROW_SCOPED_TRACE(type->ToString());`
	`642`	`+ for (const auto& value_type : kSignedIntegerTypes) {`
	`643`	`+ ARROW_SCOPED_TRACE(value_type->ToString());`
`644`	`644`	`{`
`645`	`645`	`ARROW_SCOPED_TRACE("Basic");`
`646`	`646`	`auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";`
`647`	`647`	`auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";`
`648`	`648`	`int64_t max_index = 9;`
`649`	`649`	`auto expected = "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10]";`
`650`		`- TestScatter(type, values, indices, max_index, expected);`
	`650`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`651`	`651`	`}`
`652`	`652`	`{`
`653`	`653`	`ARROW_SCOPED_TRACE("Values with nulls");`
`654`	`654`	`auto values = "[null, 11, null, 13, null, 15, null, 17, null, 19]";`
`655`	`655`	`auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";`
`656`	`656`	`int64_t max_index = 9;`
`657`	`657`	`auto expected = "[19, null, 17, null, 15, null, 13, null, 11, null]";`
`658`		`- TestScatter(type, values, indices, max_index, expected);`
	`658`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`659`	`659`	`}`
`660`	`660`	`{`
`661`	`661`	`ARROW_SCOPED_TRACE("Indices with nulls");`
`662`	`662`	`auto values = "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]";`
`663`	`663`	`auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";`
`664`	`664`	`int64_t max_index = 9;`
`665`	`665`	`auto expected = "[null, 18, null, 16, null, 14, null, 12, null, 10]";`
`666`		`- TestScatter(type, values, indices, max_index, expected);`
	`666`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`667`	`667`	`}`
`668`	`668`	`{`
`669`	`669`	`ARROW_SCOPED_TRACE("Output greater than input");`
`670`	`670`	`auto values = "[0, 0, 0, 1, 1, 1]";`
`671`	`671`	`auto indices = "[0, 3, 6, 1, 4, 7]";`
`672`	`672`	`int64_t max_index = 8;`
`673`	`673`	`auto expected = "[0, 1, null, 0, 1, null, 0, 1, null]";`
`674`		`- TestScatter(type, values, indices, max_index, expected);`
	`674`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`675`	`675`	`}`
`676`	`676`	`{`
`677`	`677`	`ARROW_SCOPED_TRACE("Values all null");`
`678`	`678`	`auto values = "[null, null]";`
`679`	`679`	`auto indices = "[0, 1]";`
`680`	`680`	`int64_t max_index = 1;`
`681`	`681`	`auto expected = "[null, null]";`
`682`		`- TestScatter(type, values, indices, max_index, expected);`
	`682`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`683`	`683`	`}`
`684`	`684`	`{`
`685`	`685`	`ARROW_SCOPED_TRACE("Indices all null");`
`686`	`686`	`auto values = "[0, 1]";`
`687`	`687`	`auto indices = "[null, null]";`
`688`	`688`	`int64_t max_index = 1;`
`689`	`689`	`auto expected = "[null, null]";`
`690`		`- TestScatter(type, values, indices, max_index, expected);`
	`690`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`691`	`691`	`}`
`692`	`692`	`{`
`693`	`693`	`ARROW_SCOPED_TRACE("Empty input output null");`
`694`	`694`	`auto values = "[]";`
`695`	`695`	`auto indices = "[]";`
`696`	`696`	`int64_t max_index = 1;`
`697`	`697`	`auto expected = "[null, null]";`
`698`		`- TestScatter(type, values, indices, max_index, expected);`
	`698`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`699`	`699`	`}`
`700`	`700`	`{`
`701`	`701`	`ARROW_SCOPED_TRACE("Indices duplicated indices");`
`702`	`702`	`auto values = "[1, 0, null, null]";`
`703`	`703`	`auto indices = "[0, 1, 0, 1]";`
`704`	`704`	`int64_t max_index = 3;`
`705`	`705`	`auto expected = "[null, null, null, null]";`
`706`		`- TestScatter(type, values, indices, max_index, expected);`
	`706`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`707`	`707`	`}`
`708`	`708`	`}`
`709`	`709`	`}`
`710`	`710`
`711`	`711`	`TEST(Scatter, Binary) {`
`712`		`- for (const auto& type : kBinaryTypes) {`
`713`		`- ARROW_SCOPED_TRACE(type->ToString());`
	`712`	`+ for (const auto& value_type : kBinaryTypes) {`
	`713`	`+ ARROW_SCOPED_TRACE(value_type->ToString());`
`714`	`714`	`{`
`715`	`715`	`ARROW_SCOPED_TRACE("Basic");`
`716`	`716`	`auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";`
`717`	`717`	`auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";`
`718`	`718`	`int64_t max_index = 9;`
`719`	`719`	`auto expected = R"(["j", "i", "h", "g", "f", "e", "d", "c", "b", "a"])";`
`720`		`- TestScatter(type, values, indices, max_index, expected);`
	`720`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`721`	`721`	`}`
`722`	`722`	`{`
`723`	`723`	`ARROW_SCOPED_TRACE("Values with nulls");`
`724`	`724`	`auto values = R"([null, "b", null, "d", null, "f", null, "h", null, "j"])";`
`725`	`725`	`auto indices = "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]";`
`726`	`726`	`int64_t max_index = 9;`
`727`	`727`	`auto expected = R"(["j", null, "h", null, "f", null, "d", null, "b", null])";`
`728`		`- TestScatter(type, values, indices, max_index, expected);`
	`728`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`729`	`729`	`}`
`730`	`730`	`{`
`731`	`731`	`ARROW_SCOPED_TRACE("Indices with nulls");`
`732`	`732`	`auto values = R"(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"])";`
`733`	`733`	`auto indices = "[9, null, 7, null, 5, null, 3, null, 1, null]";`
`734`	`734`	`int64_t max_index = 9;`
`735`	`735`	`auto expected = R"([null, "i", null, "g", null, "e", null, "c", null, "a"])";`
`736`		`- TestScatter(type, values, indices, max_index, expected);`
	`736`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`737`	`737`	`}`
`738`	`738`	`{`
`739`	`739`	`ARROW_SCOPED_TRACE("Output greater than input");`
`740`	`740`	`auto values = R"(["a", "a", "a", "b", "b", "b"])";`
`741`	`741`	`auto indices = "[0, 3, 6, 1, 4, 7]";`
`742`	`742`	`int64_t max_index = 8;`
`743`	`743`	`auto expected = R"(["a", "b", null, "a", "b", null, "a", "b", null])";`
`744`		`- TestScatter(type, values, indices, max_index, expected);`
	`744`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`745`	`745`	`}`
`746`	`746`	`{`
`747`	`747`	`ARROW_SCOPED_TRACE("Values all null");`
`748`	`748`	`auto values = "[null, null]";`
`749`	`749`	`auto indices = "[0, 1]";`
`750`	`750`	`int64_t max_index = 1;`
`751`	`751`	`auto expected = "[null, null]";`
`752`		`- TestScatter(type, values, indices, max_index, expected);`
	`752`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`753`	`753`	`}`
`754`	`754`	`{`
`755`	`755`	`ARROW_SCOPED_TRACE("Indices all null");`
`756`	`756`	`auto values = R"(["a", "b"])";`
`757`	`757`	`auto indices = "[null, null]";`
`758`	`758`	`int64_t max_index = 1;`
`759`	`759`	`auto expected = "[null, null]";`
`760`		`- TestScatter(type, values, indices, max_index, expected);`
	`760`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`761`	`761`	`}`
`762`	`762`	`{`
`763`	`763`	`ARROW_SCOPED_TRACE("Empty input output null");`
`764`	`764`	`auto values = "[]";`
`765`	`765`	`auto indices = "[]";`
`766`	`766`	`int64_t max_index = 1;`
`767`	`767`	`auto expected = "[null, null]";`
`768`		`- TestScatter(type, values, indices, max_index, expected);`
	`768`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`769`	`769`	`}`
`770`	`770`	`{`
`771`	`771`	`ARROW_SCOPED_TRACE("Indices duplicated indices");`
`772`	`772`	`auto values = R"(["a", "b", null, null])";`
`773`	`773`	`auto indices = "[0, 1, 0, 1]";`
`774`	`774`	`int64_t max_index = 3;`
`775`	`775`	`auto expected = "[null, null, null, null]";`
`776`		`- TestScatter(type, values, indices, max_index, expected);`
	`776`	`+ TestScatter(value_type, values, indices, max_index, expected);`
`777`	`777`	`}`
`778`	`778`	`}`
`779`	`779`	`}`