Remove extra blob arg indexes from server param conversions. (#8612)

The server param conversions passed in a `extra_blob_arg_indexes` which described how to extract the parameter's conversion data from the extra blobs. This is redundant if the bind_args_index is extended to index into the extra blobs.

Author: dnwpark

edb/_edgeql_parser.pyi

@@ -38,7 +38,6 @@ class Entry:
     extra_counts: list[int]
 
     def get_variables(self) -> dict[str, typing.Any]: ...
-    def get_extra_variable_indexes(self) -> dict[str, tuple[int, int]]: ...
     def pack(self) -> bytes: ...
 
 def normalize(text: str) -> Entry: ...

edb/edgeql-parser/edgeql-parser-python/src/pynormalize.rs

@@ -8,7 +8,7 @@ use gel_protocol::codec;
 use gel_protocol::model::{BigInt, Decimal};
 use pyo3::exceptions::{PyAssertionError, PyValueError};
 use pyo3::prelude::*;
-use pyo3::types::{PyBytes, PyDict, PyFloat, PyInt, PyList, PyString, PyTuple};
+use pyo3::types::{PyBytes, PyDict, PyFloat, PyInt, PyList, PyString};
 
 use crate::errors::SyntaxError;
 use crate::normalize::{normalize as _normalize, Error, PackedEntry, Variable};
@@ -74,23 +74,22 @@ impl Entry {
 impl Entry {
     fn get_variables(&self, py: Python) -> PyResult<PyObject> {
         let vars = PyDict::new(py);
-        for (param_name, _, _, value) in VariableNameIter::new(self) {
-            vars.set_item(param_name, TokenizerValue(value))?;
+        let first = match self.first_extra {
+            Some(first) => first,
+            None => return Ok(vars.into()),
+        };
+        for (idx, var) in self.entry_pack.variables.iter().flatten().enumerate() {
+            let s = if self.extra_named {
+                format!("__edb_arg_{}", first + idx)
+            } else {
+                (first + idx).to_string()
+            };
+            vars.set_item(s, TokenizerValue(&var.value))?;
         }
 
         Ok(vars.into())
     }
 
-    // This function returns a dictionary mapping normalized parameter names to their blob and var indexes.
-    fn get_extra_variable_indexes(&self, py: Python) -> PyResult<PyObject> {
-        let indexes = PyDict::new(py);
-        for (param_name, blob_index, var_index, _) in VariableNameIter::new(self) {
-            indexes.set_item(param_name, PyTuple::new(py, [blob_index, var_index])?)?;
-        }
-
-        Ok(indexes.into())
-    }
-
     fn pack(&self, py: Python) -> PyResult<PyObject> {
         let mut buf = vec![1u8]; // type and version
         bincode::serialize_into(&mut buf, &self.entry_pack)
@@ -99,69 +98,6 @@ impl Entry {
     }
 }
 
-struct VariableNameIter<'a> {
-    entry_pack: &'a PackedEntry,
-    first_extra: Option<usize>,
-    extra_named: bool,
-    name_index: usize,
-    blob_index: usize,
-    var_index: usize,
-}
-
-impl<'a> VariableNameIter<'a> {
-    pub fn new(entry: &'a Entry) -> Self {
-        VariableNameIter {
-            entry_pack: &entry.entry_pack,
-            first_extra: entry.first_extra,
-            extra_named: entry.extra_named,
-            name_index: 0,
-            blob_index: 0,
-            var_index: 0,
-        }
-    }
-}
-
-impl<'a> Iterator for VariableNameIter<'a> {
-    type Item = (String, usize, usize, &'a Value);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        // Check termination
-        let first = self.first_extra?;
-        if self.blob_index >= self.entry_pack.variables.len() {
-            return None;
-        }
-        if self.var_index >= self.entry_pack.variables[self.blob_index].len() {
-            return None;
-        }
-
-        // Get result
-        let blob_vars = self.entry_pack.variables.get(self.blob_index)?;
-
-        let name = if self.extra_named {
-            format!("__edb_arg_{}", first + self.name_index)
-        } else {
-            (first + self.name_index).to_string()
-        };
-
-        let result = (
-            name,
-            self.blob_index,
-            self.var_index,
-            &blob_vars[self.var_index].value,
-        );
-
-        // Advance indexes
-        self.var_index += 1;
-        if self.var_index >= blob_vars.len() {
-            self.var_index = 0;
-            self.blob_index += 1;
-        }
-        self.name_index += 1;
-
-        Some(result)
-    }
-}
-
 pub fn serialize_extra(variables: &[Variable]) -> Result<Bytes, String> {
     use gel_protocol::codec::Codec;
     use gel_protocol::value::Value as P;

edb/edgeql/compiler/context.py

@@ -145,8 +145,6 @@ class ServerParamConversion:
     volatility: qltypes.Volatility
 
     # If the parameter is a query parameter, track its script params index.
-    # This is passed to the server if the query parameter is not a normalized
-    # constant.
     script_param_index: Optional[int] = None
 
     # If the parameter is a constant value, pass to directly to the server.

edb/edgeql/tokenizer.py

@@ -77,9 +77,6 @@ def extra_counts(self) -> Sequence[int]:
     def extra_blobs(self) -> list[bytes]:
         return []
 
-    def extra_variable_indexes(self) -> dict[str, tuple[int, int]]:
-        return {}
-
     def extra_formatted_as_text(self) -> bool:
         return False
 
@@ -116,7 +113,6 @@ def __init__(
         self._first_extra = normalized.first_extra
         self._extra_counts = normalized.extra_counts
         self._extra_blobs = normalized.extra_blobs
-        self._extra_variable_indexes = normalized.get_extra_variable_indexes()
         self._serialized = serialized
 
     def text(self) -> str:
@@ -140,9 +136,6 @@ def extra_counts(self) -> Sequence[int]:
     def extra_blobs(self) -> list[bytes]:
         return self._extra_blobs
 
-    def extra_variable_indexes(self) -> dict[str, tuple[int, int]]:
-        return self._extra_variable_indexes
-
     @staticmethod
     def from_string(text: str) -> NormalizedSource:
         normalized = _normalize(text)

edb/ir/ast.py

@@ -779,8 +779,6 @@ class ServerParamConversion:
     additional_info: tuple[str, ...]
 
     # If the parameter is a query parameter, track its script params index.
-    # This is passed to the server if the query parameter is not a normalized
-    # constant.
     script_param_index: typing.Optional[int] = None
 
     # If the parameter is a constant value, pass to directly to the server.

edb/server/compiler/compiler.py

@@ -1925,45 +1925,20 @@ def _compile_ql_query(
         list[dbstate.ServerParamConversion]
     ] = None
     if isinstance(ir, irast.Statement) and ir.server_param_conversions:
-        # A server param conversion is either:
-        # - a query parameter
-        #   eg. `<str>$my_var`;
-        # - a normalized constant
-        #   eg. `select 1` normalizes to `select <int64>$0`; or,
-        # - a constant value, when a conversion is part of a schema expression,
-        #   no normalization takes place.
-        #
         # The irast.ServerParamConversion we get from the ql compiler contains
         # either a script_param_index or a constant value.
         #
-        # The script_param_index may refer to either a query param or a
-        # normalized constant. We need to check the source's extra variable
-        # indexes to see if a param_name refers to an normalized constant.
-        #
-        # If a parameter is a normalized constant, pass on the blob and arg
-        # indexes to the server.
+        # A script_param_index can refer to either an actual query param or a
+        # constant that was normalized out of a query.
         #
-        # Query parameters and constant values can be passed on as they are.
-
-        extra_variable_indexes = (
-            ctx.source.extra_variable_indexes() if ctx.source else {}
-        )
+        # A constant value is used as is by the server.
 
         server_param_conversions = [
             dbstate.ServerParamConversion(
                 param_name=p.param_name,
                 conversion_name=p.conversion_name,
                 additional_info=p.additional_info,
-                bind_args_index=(
-                    p.script_param_index
-                    if p.param_name not in extra_variable_indexes else
-                    None
-                ),
-                extra_blob_arg_indexes=(
-                    extra_variable_indexes[p.param_name]
-                    if p.param_name in extra_variable_indexes else
-                    None
-                ),
+                script_param_index=p.script_param_index,
                 constant_value=p.constant_value
             )
             for p in ir.server_param_conversions

edb/server/compiler/dbstate.py

@@ -106,15 +106,7 @@ class ServerParamConversion:
     additional_info: tuple[str, ...]
 
     # If the parameter is a query parameter, track its bind_args index.
-    bind_args_index: Optional[int] = None
-
-    # If the parameter was originally a literal which was normalized,
-    # store the location in the extra blobs to find its encoded data.
-    #
-    # The location is stored as a tuple of:
-    # - blob index
-    # - arg index
-    extra_blob_arg_indexes: Optional[tuple[int, int]] = None
+    script_param_index: Optional[int] = None
 
     # If the parameter is a constant value, pass to directly to the server.
     constant_value: Optional[Any] = None

edb/server/protocol/args_ser.pxd

@@ -67,9 +67,9 @@ cdef list[ParamConversion] get_param_conversions(
 )
 
 cdef dict[int, bytes] get_args_data_for_indexes(
-    bytes args,
+    bytes bind_args,
+    list[bytes] extra_blobs,
     list[int] target_indexes,
-    args_needs_recoding: bool,
 )
 
 cdef class ConvertedArg: