all: Rename 'constraint violation' to 'internal error'

Author: lutter

graph/src/components/server/query.rs

@@ -28,7 +28,7 @@ impl From<QueryError> for ServerError {
 impl From<StoreError> for ServerError {
     fn from(e: StoreError) -> Self {
         match e {
-            StoreError::ConstraintViolation(s) => ServerError::InternalError(s),
+            StoreError::InternalError(s) => ServerError::InternalError(s),
             _ => ServerError::ClientError(e.to_string()),
         }
     }

graph/src/components/store/err.rs

@@ -36,8 +36,8 @@ pub enum StoreError {
     /// An internal error where we expected the application logic to enforce
     /// some constraint, e.g., that subgraph names are unique, but found that
     /// constraint to not hold
-    #[error("internal constraint violated: {0}")]
-    ConstraintViolation(String),
+    #[error("internal error: {0}")]
+    InternalError(String),
     #[error("deployment not found: {0}")]
     DeploymentNotFound(String),
     #[error("shard not found: {0} (this usually indicates a misconfiguration)")]
@@ -72,14 +72,14 @@ pub enum StoreError {
     StatementTimeout,
 }
 
-// Convenience to report a constraint violation
+// Convenience to report an internal error
 #[macro_export]
-macro_rules! constraint_violation {
+macro_rules! internal_error {
     ($msg:expr) => {{
-        $crate::prelude::StoreError::ConstraintViolation(format!("{}", $msg))
+        $crate::prelude::StoreError::InternalError(format!("{}", $msg))
     }};
     ($fmt:expr, $($arg:tt)*) => {{
-        $crate::prelude::StoreError::ConstraintViolation(format!($fmt, $($arg)*))
+        $crate::prelude::StoreError::InternalError(format!($fmt, $($arg)*))
     }}
 }
 
@@ -106,7 +106,7 @@ impl Clone for StoreError {
             Self::DuplicateBlockProcessing(arg0, arg1) => {
                 Self::DuplicateBlockProcessing(arg0.clone(), arg1.clone())
             }
-            Self::ConstraintViolation(arg0) => Self::ConstraintViolation(arg0.clone()),
+            Self::InternalError(arg0) => Self::InternalError(arg0.clone()),
             Self::DeploymentNotFound(arg0) => Self::DeploymentNotFound(arg0.clone()),
             Self::UnknownShard(arg0) => Self::UnknownShard(arg0.clone()),
             Self::FulltextSearchNonDeterministic => Self::FulltextSearchNonDeterministic,
@@ -181,7 +181,7 @@ impl StoreError {
             | QueryExecutionError(_)
             | ChildFilterNestingNotSupportedError(_, _)
             | DuplicateBlockProcessing(_, _)
-            | ConstraintViolation(_)
+            | InternalError(_)
             | DeploymentNotFound(_)
             | UnknownShard(_)
             | FulltextSearchNonDeterministic

graph/src/components/store/mod.rs

@@ -26,13 +26,13 @@ use std::time::Duration;
 use crate::blockchain::{Block, BlockHash, BlockPtr};
 use crate::cheap_clone::CheapClone;
 use crate::components::store::write::EntityModification;
-use crate::constraint_violation;
 use crate::data::store::scalar::Bytes;
 use crate::data::store::{Id, IdList, Value};
 use crate::data::value::Word;
 use crate::data_source::CausalityRegion;
 use crate::derive::CheapClone;
 use crate::env::ENV_VARS;
+use crate::internal_error;
 use crate::prelude::{s, Attribute, DeploymentHash, ValueType};
 use crate::schema::{ast as sast, EntityKey, EntityType, InputSchema};
 use crate::util::stats::MovingStats;
@@ -1000,17 +1000,17 @@ impl PruneRequest {
         let rebuild_threshold = ENV_VARS.store.rebuild_threshold;
         let delete_threshold = ENV_VARS.store.delete_threshold;
         if rebuild_threshold < 0.0 || rebuild_threshold > 1.0 {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "the copy threshold must be between 0 and 1 but is {rebuild_threshold}"
             ));
         }
         if delete_threshold < 0.0 || delete_threshold > 1.0 {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "the delete threshold must be between 0 and 1 but is {delete_threshold}"
             ));
         }
         if history_blocks <= reorg_threshold {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "the deployment {} needs to keep at least {} blocks \
                    of history and can't be pruned to only {} blocks of history",
                 deployment,
@@ -1019,7 +1019,7 @@ impl PruneRequest {
             ));
         }
         if first_block >= latest_block {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "the earliest block {} must be before the latest block {}",
                 first_block,
                 latest_block

graph/src/components/store/write.rs

@@ -5,10 +5,10 @@ use crate::{
     blockchain::{block_stream::FirehoseCursor, BlockPtr, BlockTime},
     cheap_clone::CheapClone,
     components::subgraph::Entity,
-    constraint_violation,
     data::{store::Id, subgraph::schema::SubgraphError},
     data_source::CausalityRegion,
     derive::CacheWeight,
+    internal_error,
     util::cache_weight::CacheWeight,
 };
 
@@ -182,7 +182,7 @@ impl EntityModification {
         match self {
             Insert { end, .. } | Overwrite { end, .. } => {
                 if end.is_some() {
-                    return Err(constraint_violation!(
+                    return Err(internal_error!(
                         "can not clamp {:?} to block {}",
                         self,
                         block
@@ -191,7 +191,7 @@ impl EntityModification {
                 *end = Some(block);
             }
             Remove { .. } => {
-                return Err(constraint_violation!(
+                return Err(internal_error!(
                     "can not clamp block range for removal of {:?} to {}",
                     self,
                     block
@@ -219,7 +219,7 @@ impl EntityModification {
                 end,
             }),
             Remove { key, .. } => {
-                return Err(constraint_violation!(
+                return Err(internal_error!(
                     "a remove for {}[{}] can not be converted into an insert",
                     entity_type,
                     key.entity_id
@@ -330,7 +330,7 @@ impl RowGroup {
         if !is_forward {
             // unwrap: we only get here when `last()` is `Some`
             let last_block = self.rows.last().map(|emod| emod.block()).unwrap();
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "we already have a modification for block {}, can not append {:?}",
                 last_block,
                 emod
@@ -412,7 +412,7 @@ impl RowGroup {
                     self.rows.push(row);
                 }
                 EntityModification::Overwrite { .. } | EntityModification::Remove { .. } => {
-                    return Err(constraint_violation!(
+                    return Err(internal_error!(
                         "immutable entity type {} only allows inserts, not {:?}",
                         self.entity_type,
                         row
@@ -426,7 +426,7 @@ impl RowGroup {
             use EntityModification::*;
 
             if row.block() <= prev_row.block() {
-                return Err(constraint_violation!(
+                return Err(internal_error!(
                     "can not append operations that go backwards from {:?} to {:?}",
                     prev_row,
                     row
@@ -444,7 +444,7 @@ impl RowGroup {
                     Insert { end: Some(_), .. } | Overwrite { end: Some(_), .. },
                     Overwrite { .. } | Remove { .. },
                 ) => {
-                    return Err(constraint_violation!(
+                    return Err(internal_error!(
                         "impossible combination of entity operations: {:?} and then {:?}",
                         prev_row,
                         row
@@ -481,7 +481,7 @@ impl RowGroup {
 
     fn append(&mut self, group: RowGroup) -> Result<(), StoreError> {
         if self.entity_type != group.entity_type {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "Can not append a row group for {} to a row group for {}",
                 group.entity_type,
                 self.entity_type
@@ -710,7 +710,7 @@ impl Batch {
 
     fn append_inner(&mut self, mut batch: Batch) -> Result<(), StoreError> {
         if batch.block_ptr.number <= self.block_ptr.number {
-            return Err(constraint_violation!("Batches must go forward. Can't append a batch with block pointer {} to one with block pointer {}", batch.block_ptr, self.block_ptr));
+            return Err(internal_error!("Batches must go forward. Can't append a batch with block pointer {} to one with block pointer {}", batch.block_ptr, self.block_ptr));
         }
 
         self.block_ptr = batch.block_ptr;

graph/src/data/query/error.rs

@@ -74,7 +74,7 @@ pub enum QueryExecutionError {
     DeploymentNotFound(String),
     IdMissing,
     IdNotString,
-    ConstraintViolation(String),
+    InternalError(String),
 }
 
 impl QueryExecutionError {
@@ -132,7 +132,7 @@ impl QueryExecutionError {
             | DeploymentNotFound(_)
             | IdMissing
             | IdNotString
-            | ConstraintViolation(_) => false,
+            | InternalError(_) => false,
         }
     }
 }
@@ -274,7 +274,7 @@ impl fmt::Display for QueryExecutionError {
             DeploymentNotFound(id_or_name) => write!(f, "deployment `{}` does not exist", id_or_name),
             IdMissing => write!(f, "entity is missing an `id` attribute"),
             IdNotString => write!(f, "entity `id` attribute is not a string"),
-            ConstraintViolation(msg) => write!(f, "internal constraint violated: {}", msg),
+            InternalError(msg) => write!(f, "internal error: {}", msg),
         }
     }
 }
@@ -306,7 +306,7 @@ impl From<StoreError> for QueryExecutionError {
             StoreError::ChildFilterNestingNotSupportedError(attr, filter) => {
                 QueryExecutionError::ChildFilterNestingNotSupportedError(attr, filter)
             }
-            StoreError::ConstraintViolation(msg) => QueryExecutionError::ConstraintViolation(msg),
+            StoreError::InternalError(msg) => QueryExecutionError::InternalError(msg),
             _ => QueryExecutionError::StoreError(CloneableAnyhowError(Arc::new(e.into()))),
         }
     }

graph/src/data/store/id.rs

@@ -20,9 +20,9 @@ use crate::{
 
 use crate::{
     components::store::StoreError,
-    constraint_violation,
     data::value::Word,
     derive::CacheWeight,
+    internal_error,
     prelude::QueryExecutionError,
     runtime::gas::{Gas, GasSizeOf},
 };
@@ -367,7 +367,7 @@ impl IdList {
                         ids.push(id);
                         Ok(ids)
                     }
-                    _ => Err(constraint_violation!(
+                    _ => Err(internal_error!(
                         "expected string id, got {}: {}",
                         id.id_type(),
                         id,
@@ -381,7 +381,7 @@ impl IdList {
                         ids.push(id);
                         Ok(ids)
                     }
-                    _ => Err(constraint_violation!(
+                    _ => Err(internal_error!(
                         "expected bytes id, got {}: {}",
                         id.id_type(),
                         id,
@@ -395,7 +395,7 @@ impl IdList {
                         ids.push(id);
                         Ok(ids)
                     }
-                    _ => Err(constraint_violation!(
+                    _ => Err(internal_error!(
                         "expected int8 id, got {}: {}",
                         id.id_type(),
                         id,
@@ -423,7 +423,7 @@ impl IdList {
                         ids.push(Word::from(id));
                         Ok(ids)
                     }
-                    _ => Err(constraint_violation!(
+                    _ => Err(internal_error!(
                         "expected string id, got {}: 0x{}",
                         id.id_type(),
                         id,
@@ -438,7 +438,7 @@ impl IdList {
                             ids.push(scalar::Bytes::from(id));
                             Ok(ids)
                         }
-                        _ => Err(constraint_violation!(
+                        _ => Err(internal_error!(
                             "expected bytes id, got {}: {}",
                             id.id_type(),
                             id,
@@ -452,7 +452,7 @@ impl IdList {
                         ids.push(id);
                         Ok(ids)
                     }
-                    _ => Err(constraint_violation!(
+                    _ => Err(internal_error!(
                         "expected int8 id, got {}: {}",
                         id.id_type(),
                         id,
@@ -533,7 +533,7 @@ impl IdList {
                 ids.push(id);
                 Ok(())
             }
-            (list, id) => Err(constraint_violation!(
+            (list, id) => Err(internal_error!(
                 "expected id of type {}, but got {}[{}]",
                 list.id_type(),
                 id.id_type(),

graph/src/util/ogive.rs

@@ -1,6 +1,6 @@
 use std::ops::RangeInclusive;
 
-use crate::{constraint_violation, prelude::StoreError};
+use crate::{internal_error, prelude::StoreError};
 
 /// A helper to deal with cumulative histograms, also known as ogives. This
 /// implementation is restricted to histograms where each bin has the same
@@ -37,9 +37,7 @@ impl Ogive {
     /// and deduplicated, i.e., they don't have to be in ascending order.
     pub fn from_equi_histogram(mut points: Vec<i64>, total: usize) -> Result<Self, StoreError> {
         if points.is_empty() {
-            return Err(constraint_violation!(
-                "histogram must have at least one point"
-            ));
+            return Err(internal_error!("histogram must have at least one point"));
         }
 
         points.sort_unstable();
@@ -124,7 +122,7 @@ impl Ogive {
     fn inverse(&self, value: i64) -> Result<i64, StoreError> {
         let value = value as f64;
         if value < 0.0 {
-            return Err(constraint_violation!("value {} can not be negative", value));
+            return Err(internal_error!("value {} can not be negative", value));
         }
         let idx = (value / self.bin_size) as usize;
         if idx >= self.points.len() - 1 {
@@ -138,7 +136,7 @@ impl Ogive {
 
     fn check_in_range(&self, point: i64) -> Result<(), StoreError> {
         if !self.range.contains(&point) {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "point {} is outside of the range [{}, {}]",
                 point,
                 self.range.start(),

graphql/src/store/prefetch.rs

@@ -632,7 +632,7 @@ impl<'a> Loader<'a> {
                     let object_type = input_schema
                         .object_or_aggregation(&object_type.name, parent_interval)
                         .ok_or_else(|| {
-                            vec![QueryExecutionError::ConstraintViolation(format!(
+                            vec![QueryExecutionError::InternalError(format!(
                                 "the type `{}`(interval {}) is not an object type",
                                 object_type.name,
                                 parent_interval

graphql/src/store/resolver.rs

@@ -327,7 +327,7 @@ impl Resolver for StoreResolver {
                     None => {
                         let child0_id = child_id(&children[0]);
                         let child1_id = child_id(&children[1]);
-                        QueryExecutionError::ConstraintViolation(format!(
+                        QueryExecutionError::InternalError(format!(
                             "expected only one child for {}.{} but got {}. One child has id {}, another has id {}",
                             object_type.name(), field.name,
                             children.len(), child0_id, child1_id