feat: count query and tests

crates/cli/src/main.rs

@@ -58,6 +58,9 @@ impl ResultHandler {
                 ExpressionResult::Log(query_res) => {
                     println!("{}", to_table(query_res)?);
                 }
+                ExpressionResult::Count(query_res) => {
+                    println!("{}", to_table(query_res)?);
+                }
             }
         }
 

crates/cli/src/repl.rs

@@ -241,6 +241,12 @@ impl Repl {
                         queue!(stdout(), MoveToNextLine(1), Print(line.cyan())).unwrap();
                     });
                 }
+                ExpressionResult::Count(query_res) => {
+                    let table = to_table(query_res)?;
+                    table.to_string().split("\n").for_each(|line| {
+                        queue!(stdout(), MoveToNextLine(1), Print(line.cyan())).unwrap();
+                    });
+                }
             }
         }
 

crates/core/src/common/logs.rs

@@ -142,7 +142,8 @@ impl TryFrom<Pair<'_, Rule>> for LogFilter {
         match pair.as_rule() {
             Rule::address_filter_type => extract_value(pair, |s| {
                 Ok(LogFilter::EmitterAddress(Address::parse_checksummed(
-                    Address::to_checksum(&Address::from_str(s)?, None), None,
+                    Address::to_checksum(&Address::from_str(s)?, None),
+                    None,
                 )?))
             }),
             Rule::blockrange_filter => parse_block_range(pair),

crates/core/src/common/query_result.rs

@@ -25,6 +25,9 @@ pub enum ExpressionResult {
     Transaction(Vec<TransactionQueryRes>),
     #[serde(rename = "log")]
     Log(Vec<LogQueryRes>),
+    #[serde(rename = "count")]
+    Count(Vec<CountQueryRes>),
+
 }
 
 // TODO: should this be replaced with Alloy's Block?
@@ -333,6 +336,20 @@ impl Default for LogQueryRes {
     }
 }
 
+#[serde_with::skip_serializing_none]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
+pub struct CountQueryRes {
+    pub count: usize,
+}
+
+impl Default for CountQueryRes {
+    fn default() -> Self {
+        Self {
+            count:0
+        }
+    }
+}
+
 fn serialize_option_u256<S>(option: &Option<U256>, serializer: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,

crates/core/src/common/serializer.rs

@@ -25,6 +25,7 @@ pub(crate) fn dump_results(result: &ExpressionResult, dump: &Dump) -> Result<(),
                 ExpressionResult::Block(blocks) => serialize_csv(blocks)?,
                 ExpressionResult::Transaction(txs) => serialize_csv(txs)?,
                 ExpressionResult::Log(logs) => serialize_csv(logs)?,
+                ExpressionResult::Count(count)=> serialize_csv(count)?,
             };
 
             std::fs::write(dump.path(), content)?;
@@ -59,6 +60,7 @@ fn serialize_parquet(result: &ExpressionResult) -> Result<Vec<u8>, Box<dyn Error
             create_parquet_schema_and_data(transactions)?
         }
         ExpressionResult::Log(logs) => create_parquet_schema_and_data(logs)?,
+        ExpressionResult::Count(count) => create_parquet_schema_and_data(count)?,
     };
 
     let batch = RecordBatch::try_new(Arc::new(schema), data)?;

crates/core/src/common/types.rs

@@ -10,6 +10,12 @@ use pest::iterators::Pairs;
 #[derive(Debug, PartialEq)]
 pub enum Expression {
     Get(GetExpression),
+    Count(CountExpression),
+}
+
+#[derive(Debug, PartialEq)]
+pub struct CountExpression {
+    pub query: GetExpression,
 }
 
 #[derive(Debug, PartialEq)]