## Coverage Report

#### Created: 2024-10-13 08:39

    /Users/andrewlamb/Software/datafusion/datafusion/physical-expr/src/expressions/no_op.rs

    Line
    Count
    Source (jump to first uncovered line)
    1
    // Licensed to the Apache Software Foundation (ASF) under one
    2
    // or more contributor license agreements.  See the NOTICE file
    3
    // distributed with this work for additional information
    4
    // regarding copyright ownership.  The ASF licenses this file
    5
    // to you under the Apache License, Version 2.0 (the
    6
    // "License"); you may not use this file except in compliance
    7
    // with the License.  You may obtain a copy of the License at
    8
    //
    9
    //   http://www.apache.org/licenses/LICENSE-2.0
    10
    //
    11
    // Unless required by applicable law or agreed to in writing,
    12
    // software distributed under the License is distributed on an
    13
    // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    14
    // KIND, either express or implied.  See the License for the
    15
    // specific language governing permissions and limitations
    16
    // under the License.
    17
    18
    //! NoOp placeholder for physical operations
    19
    20
    use std::any::Any;
    21
    use std::hash::{Hash, Hasher};
    22
    use std::sync::Arc;
    23
    24
    use arrow::{
    25
        datatypes::{DataType, Schema},
    26
        record_batch::RecordBatch,
    27
    };
    28
    29
    use crate::physical_expr::down_cast_any_ref;
    30
    use crate::PhysicalExpr;
    31
    use datafusion_common::{internal_err, Result};
    32
    use datafusion_expr::ColumnarValue;
    33
    34
    /// A place holder expression, can not be evaluated.
    35
    ///
    36
    /// Used in some cases where an `Arc<dyn PhysicalExpr>` is needed, such as `children()`
    37
    #[derive(Debug, PartialEq, Eq, Default, Hash)]
    38
    pub struct NoOp {}
    39
    40
    impl NoOp {
    41
        /// Create a NoOp expression
    42
    0
        pub fn new() -> Self {
    43
    0
            Self {}
    44
    0
        }
    45
    }
    46
    47
    impl std::fmt::Display for NoOp {
    48
    0
        fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    49
    0
            write!(f, "NoOp")
    50
    0
        }
    51
    }
    52
    53
    impl PhysicalExpr for NoOp {
    54
        /// Return a reference to Any that can be used for downcasting
    55
    0
        fn as_any(&self) -> &dyn Any {
    56
    0
            self
    57
    0
        }
    58
    59
    0
        fn data_type(&self, _input_schema: &Schema) -> Result<DataType> {
    60
    0
            Ok(DataType::Null)
    61
    0
        }
    62
    63
    0
        fn nullable(&self, _input_schema: &Schema) -> Result<bool> {
    64
    0
            Ok(true)
    65
    0
        }
    66
    67
    0
        fn evaluate(&self, _batch: &RecordBatch) -> Result<ColumnarValue> {
    68
    0
            internal_err!("NoOp::evaluate() should not be called")
    69
    0
        }
    70
    71
    0
        fn children(&self) -> Vec<&Arc<dyn PhysicalExpr>> {
    72
    0
            vec![]
    73
    0
        }
    74
    75
    0
        fn with_new_children(
    76
    0
            self: Arc<Self>,
    77
    0
            _children: Vec<Arc<dyn PhysicalExpr>>,
    78
    0
        ) -> Result<Arc<dyn PhysicalExpr>> {
    79
    0
            Ok(self)
    80
    0
        }
    81
    82
    0
        fn dyn_hash(&self, state: &mut dyn Hasher) {
    83
    0
            let mut s = state;
    84
    0
            self.hash(&mut s);
    85
    0
        }
    86
    }
    87
    88
    impl PartialEq<dyn Any> for NoOp {
    89
    0
        fn eq(&self, other: &dyn Any) -> bool {
    90
    0
            down_cast_any_ref(other)
    91
    0
                .downcast_ref::<Self>()
    92
    0
                .map(|x| self == x)
    93
    0
                .unwrap_or(false)
    94
    0
        }
    95
    }