treewide: s/parametrize/parameterize/g

We had different spellings of this word and variations of it, and
'parameterize' was both more frequent and voted as the favorite between
the two. This commit consolidates to 'parameterize'

Change-Id: If620b059458723bff8d862daf4d0094af8a06c56
Reviewed-on: https://gerrit.readyset.name/c/readyset/+/7140
Tested-by: Buildkite CI
Reviewed-by: Jason Brown <[email protected]>

Author: Luke Osborne

query-generator/src/lib.rs

@@ -1269,7 +1269,7 @@ pub struct QueryOperationArgs {
 /// [`add_to_query`](QueryOperation::add_to_query)) with the aid of a mutable reference to a
 /// [`GeneratorState`].
 ///
-/// Some operations are parametrized on fields that, due to having too large of a state space to
+/// Some operations are parameterized on fields that, due to having too large of a state space to
 /// enumerate exhaustively, are hardcoded when query operations are built from a user-supplied
 /// string on the command-line (via [`Operations`]), and can only be changed when generating queries
 /// randomly via the proptest [`Arbitrary`] implementation. See [this design doc][0] for more

readyset-client/src/view.rs

@@ -112,7 +112,7 @@ impl ViewCreateRequest {
 #[derive(Hash, Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum ViewPlaceholder {
     /// This key column was generated by ReadySet, and has no mapping to the original query. This
-    /// is the case, for example, for a "bogokey" column generated for unparametrized queries.
+    /// is the case, for example, for a "bogokey" column generated for unparameterized queries.
     Generated,
 
     /// This key column corresponds one-to-one to a placeholder in the original query. Includes the

readyset-dataflow/src/ops/join.rs

@@ -350,7 +350,7 @@ impl Ingredient for Join {
             // [note: null-join-keys]
             // The semantics of NULL in SQL are tri-state - while obviously `1 = 1`, it is *not* the
             // case that `null = null`. Usually this is irrelevant for lookups into state since it's
-            // impossible to upquery for null keys (since IS and IS NOT can't be parametrized,
+            // impossible to upquery for null keys (since IS and IS NOT can't be parameterized,
             // syntactically), but we *do* have to have an extra case here in the case of join
             // lookups - two NULL join keys should *not* match each other in the semantics of the
             // join, even though they *would* match normally due to the semantics of the DfValue

readyset-errors/src/lib.rs

@@ -306,7 +306,7 @@ pub enum ReadySetError {
 
     /// No cache found for the given query parameters.
     ///
-    /// This error may occur when attempting to find an inlined cache to satisfy a parametrized
+    /// This error may occur when attempting to find an inlined cache to satisfy a parameterized
     /// query. This error should not reach the client when an upstream database is present.
     #[error("Existing caches do not satisfy the given query parameters.")]
     NoCacheForQuery,

readyset-mysql/tests/fallback.rs

@@ -175,7 +175,7 @@ async fn range_query() {
     shutdown_tx.shutdown().await;
 }
 
-// TODO: remove this once we support aggregates on parametrized IN
+// TODO: remove this once we support aggregates on parameterized IN
 #[tokio::test(flavor = "multi_thread")]
 #[serial]
 #[slow]

readyset-mysql/tests/integration.rs

@@ -1160,7 +1160,7 @@ async fn absurdly_simple_select() {
 }
 
 #[tokio::test(flavor = "multi_thread")]
-async fn ad_hoc_unparametrized_select() {
+async fn ad_hoc_unparameterized_select() {
     let (opts, _handle, shutdown_tx) = setup().await;
     let mut conn = mysql_async::Conn::new(opts).await.unwrap();
     conn.query_drop("CREATE TABLE test (x int, y int)")
@@ -1201,7 +1201,7 @@ async fn ad_hoc_unparametrized_select() {
 }
 
 #[tokio::test(flavor = "multi_thread")]
-async fn ad_hoc_unparametrized_where_in() {
+async fn ad_hoc_unparameterized_where_in() {
     let (opts, _handle, shutdown_tx) = setup().await;
     let mut conn = mysql_async::Conn::new(opts).await.unwrap();
     conn.query_drop("CREATE TABLE test (x int, y int)")
@@ -1236,7 +1236,7 @@ async fn ad_hoc_unparametrized_where_in() {
 }
 
 #[tokio::test(flavor = "multi_thread")]
-async fn prepared_unparametrized_select() {
+async fn prepared_unparameterized_select() {
     let (opts, _handle, shutdown_tx) = setup().await;
     let mut conn = mysql_async::Conn::new(opts).await.unwrap();
     conn.query_drop("CREATE TABLE test (x int, y int)")

readyset-server/src/controller/sql/query_graph.rs

@@ -295,9 +295,9 @@ pub struct QueryGraph {
 }
 
 impl QueryGraph {
-    /// Returns the set of columns on which this query is parametrized. They can come from
+    /// Returns the set of columns on which this query is parameterized. They can come from
     /// multiple tables involved in the query.
-    /// Does not include limit or offset parameters on which this query may be parametrized.
+    /// Does not include limit or offset parameters on which this query may be parameterized.
     pub fn parameters(&self) -> Vec<&Parameter> {
         self.relations
             .values()
@@ -306,7 +306,8 @@ impl QueryGraph {
     }
 
     /// Construct a representation of the lookup key of a view for this query graph, based on the
-    /// parameters in this query and the page number if this query is parametrized on an offset key.
+    /// parameters in this query and the page number if this query is parameterized on an offset
+    /// key.
     pub(crate) fn view_key(&self, config: &mir::Config) -> ReadySetResult<ViewKey> {
         let offset = self.pagination.as_ref().and_then(|p| p.offset);
         if self.parameters().is_empty() {
@@ -795,7 +796,7 @@ pub(crate) fn extract_limit_offset(
         Literal::Integer(val) => u64::try_from(*val)
             .map_err(|_| unsupported_err!("LIMIT field cannot have a negative value"))?,
         Literal::Placeholder(_) => {
-            unsupported!("ReadySet does not support parametrized LIMIT fields")
+            unsupported!("ReadySet does not support parameterized LIMIT fields")
         }
         _ => unsupported!("Invalid LIMIT statement"),
     };
@@ -813,7 +814,7 @@ pub(crate) fn extract_limit_offset(
                         limit,
                     })
                 }
-                _ => unsupported!("Numeric OFFSETs must be parametrized"),
+                _ => unsupported!("Numeric OFFSETs must be parameterized"),
             }
         })
         .transpose()?;

readyset-server/src/integration.rs

@@ -4111,8 +4111,8 @@ async fn between() {
 }
 
 #[tokio::test(flavor = "multi_thread")]
-async fn between_parametrized() {
-    let (mut g, shutdown_tx) = start_simple_unsharded("between_parametrized").await;
+async fn between_parameterized() {
+    let (mut g, shutdown_tx) = start_simple_unsharded("between_parameterized").await;
 
     g.extend_recipe(
         ChangeList::from_str("CREATE TABLE things (bigness INT);", Dialect::DEFAULT_MYSQL).unwrap(),

readyset-sql-passes/benches/adapter_rewrites.rs

@@ -2,20 +2,20 @@ use criterion::{black_box, criterion_group, criterion_main, BatchSize, Bencher,
 use nom_sql::{parse_select_statement, Dialect};
 use readyset_sql_passes::adapter_rewrites;
 
-fn auto_parametrize_query(c: &mut Criterion) {
+fn auto_parameterize_query(c: &mut Criterion) {
     let run_benchmark = |b: &mut Bencher, src: &str| {
         let q = parse_select_statement(Dialect::MySQL, src).unwrap();
         b.iter_batched(
             || q.clone(),
             |mut q| {
-                adapter_rewrites::auto_parametrize_query(&mut q);
+                adapter_rewrites::auto_parameterize_query(&mut q);
                 black_box(q)
             },
             BatchSize::SmallInput,
         )
     };
 
-    c.benchmark_group("auto_parametrize_query")
+    c.benchmark_group("auto_parameterize_query")
         .bench_with_input("trivial", "SELECT * FROM t", run_benchmark)
         .bench_with_input(
             "simple",
@@ -40,5 +40,5 @@ fn auto_parametrize_query(c: &mut Criterion) {
         );
 }
 
-criterion_group!(benches, auto_parametrize_query);
+criterion_group!(benches, auto_parameterize_query);
 criterion_main!(benches);