diff --git a/Cargo.toml b/Cargo.toml
index 3d11101..64b327b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,6 +31,12 @@ lazy_static = "1.4.0"
 lrlex = "0.13.5"
 lrpar = "0.13.5"
 regex = "1"
+serde = { version = "1", optional = true }
+serde_json = { version = "1", optional = true }
+
+[features]
+default = []
+ser = ["serde", "serde_json"]
 
 [build-dependencies]
 cfgrammar = "0.13.5"
diff --git a/src/label/matcher.rs b/src/label/matcher.rs
index 2e009f4..5764d01 100644
--- a/src/label/matcher.rs
+++ b/src/label/matcher.rs
@@ -24,6 +24,7 @@ use crate::util::join_vector;
 pub enum MatchOp {
     Equal,
     NotEqual,
+    // TODO: do we need regex here?
     Re(Regex),
     NotRe(Regex),
 }
@@ -64,9 +65,21 @@ impl Hash for MatchOp {
     }
 }
 
+#[cfg(feature = "ser")]
+impl serde::Serialize for MatchOp {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
 // Matcher models the matching of a label.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub struct Matcher {
+    #[cfg_attr(feature = "ser", serde(rename = "type"))]
     pub op: MatchOp,
     pub name: String,
     pub value: String,
@@ -183,8 +196,10 @@ fn try_escape_for_repeat_re(re: &str) -> String {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub struct Matchers {
     pub matchers: Vec<Matcher>,
+    #[cfg_attr(feature = "ser", serde(skip_serializing_if = "<[_]>::is_empty"))]
     pub or_matchers: Vec<Vec<Matcher>>,
 }
 
diff --git a/src/label/mod.rs b/src/label/mod.rs
index 1bba6d2..8549816 100644
--- a/src/label/mod.rs
+++ b/src/label/mod.rs
@@ -73,6 +73,23 @@ impl fmt::Display for Labels {
     }
 }
 
+#[cfg(feature = "ser")]
+impl serde::Serialize for Labels {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeSeq;
+        let mut seq = serializer.serialize_seq(Some(self.labels.len()))?;
+
+        for l in &self.labels {
+            seq.serialize_element(&l)?;
+        }
+
+        seq.end()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index 2131388..141ad20 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -43,6 +43,7 @@ use std::time::{Duration, SystemTime};
 ///
 /// if empty listed labels, meaning no grouping
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub enum LabelModifier {
     Include(Labels),
     Exclude(Labels),
@@ -72,6 +73,8 @@ impl LabelModifier {
 /// The label list provided with the group_left or group_right modifier contains
 /// additional labels from the "one"-side to be included in the result metrics.
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", serde(rename_all = "kebab-case"))]
 pub enum VectorMatchCardinality {
     OneToOne,
     ManyToOne(Labels),
@@ -197,12 +200,91 @@ impl BinModifier {
     }
 }
 
+#[cfg(feature = "ser")]
+pub(crate) fn serialize_bin_modifier<S>(
+    this: &Option<BinModifier>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    use serde::ser::SerializeMap;
+    use serde_json::json;
+
+    let mut map = serializer.serialize_map(Some(2))?;
+
+    map.serialize_entry(
+        "bool",
+        &this.as_ref().map(|t| t.return_bool).unwrap_or(false),
+    )?;
+    if let Some(t) = this {
+        if let Some(labels) = &t.matching {
+            map.serialize_key("matching")?;
+
+            match labels {
+                LabelModifier::Include(labels) => {
+                    let value = json!({
+                        "card": t.card,
+                        "include": [],
+                        "labels": labels,
+                        "on": true,
+                    });
+                    map.serialize_value(&value)?;
+                }
+                LabelModifier::Exclude(labels) => {
+                    let value = json!({
+                        "card": t.card,
+                        "include": [],
+                        "labels": labels,
+                        "on": false,
+                    });
+                    map.serialize_value(&value)?;
+                }
+            }
+        } else {
+            let value = json!({
+                "card": t.card,
+                "include": [],
+                "labels": [],
+                "on": false,
+            });
+            map.serialize_entry("matching", &value)?;
+        }
+    } else {
+        map.serialize_entry("matching", &None::<bool>)?;
+    }
+
+    map.end()
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Offset {
     Pos(Duration),
     Neg(Duration),
 }
 
+impl Offset {
+    #[cfg(feature = "ser")]
+    pub(crate) fn as_millis(&self) -> i128 {
+        match self {
+            Self::Pos(dur) => dur.as_millis() as i128,
+            Self::Neg(dur) => -(dur.as_millis() as i128),
+        }
+    }
+
+    #[cfg(feature = "ser")]
+    pub(crate) fn serialize_offset<S>(
+        offset: &Option<Self>,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let value = offset.as_ref().map(|o| o.as_millis()).unwrap_or(0);
+        serializer.serialize_i128(value)
+    }
+}
+
 impl fmt::Display for Offset {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
@@ -211,6 +293,7 @@ impl fmt::Display for Offset {
         }
     }
 }
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum AtModifier {
     Start,
@@ -233,6 +316,40 @@ impl fmt::Display for AtModifier {
         }
     }
 }
+
+#[cfg(feature = "ser")]
+impl serde::Serialize for AtModifier {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeMap;
+        let mut map = serializer.serialize_map(Some(2))?;
+        match self {
+            AtModifier::Start => {
+                map.serialize_entry("startOrEnd", &Some("start"))?;
+                map.serialize_entry("timestamp", &None::<u128>)?;
+            }
+            AtModifier::End => {
+                map.serialize_entry("startOrEnd", &Some("end"))?;
+                map.serialize_entry("timestamp", &None::<u128>)?;
+            }
+            AtModifier::At(time) => {
+                map.serialize_entry("startOrEnd", &None::<&str>)?;
+                map.serialize_entry(
+                    "timestamp",
+                    &time
+                        .duration_since(SystemTime::UNIX_EPOCH)
+                        .unwrap_or(Duration::ZERO)
+                        .as_millis(),
+                )?;
+            }
+        }
+
+        map.end()
+    }
+}
+
 impl TryFrom<TokenId> for AtModifier {
     type Error = String;
 
@@ -339,6 +456,7 @@ impl fmt::Display for EvalStmt {
 ///
 /// parameter is only required for `count_values`, `quantile`, `topk` and `bottomk`.
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub struct AggregateExpr {
     /// The used aggregation operation.
     pub op: TokenType,
@@ -413,6 +531,21 @@ impl Prettier for UnaryExpr {
     }
 }
 
+#[cfg(feature = "ser")]
+impl serde::Serialize for UnaryExpr {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeMap;
+        let mut map = serializer.serialize_map(Some(2))?;
+        map.serialize_entry("op", "-")?;
+        map.serialize_entry("expr", &self.expr)?;
+
+        map.end()
+    }
+}
+
 /// Grammar:
 /// ``` norust
 /// <vector expr> <bin-op> ignoring(<label list>) group_left(<label list>) <vector expr>
@@ -421,6 +554,7 @@ impl Prettier for UnaryExpr {
 /// <vector expr> <bin-op> on(<label list>) group_right(<label list>) <vector expr>
 /// ```
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub struct BinaryExpr {
     /// The operation of the expression.
     pub op: TokenType,
@@ -428,7 +562,8 @@ pub struct BinaryExpr {
     pub lhs: Box<Expr>,
     /// The operands on the right sides of the operator.
     pub rhs: Box<Expr>,
-
+    #[cfg_attr(feature = "ser", serde(flatten))]
+    #[cfg_attr(feature = "ser", serde(serialize_with = "serialize_bin_modifier"))]
     pub modifier: Option<BinModifier>,
 }
 
@@ -490,6 +625,7 @@ impl Prettier for BinaryExpr {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub struct ParenExpr {
     pub expr: Box<Expr>,
 }
@@ -516,12 +652,23 @@ impl Prettier for ParenExpr {
 /// <instant_query> '[' <range> ':' [<resolution>] ']' [ @ <float_literal> ] [ offset <duration> ]
 /// ```
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub struct SubqueryExpr {
     pub expr: Box<Expr>,
+    #[cfg_attr(feature = "ser", serde(serialize_with = "Offset::serialize_offset"))]
     pub offset: Option<Offset>,
+    #[cfg_attr(feature = "ser", serde(flatten))]
     pub at: Option<AtModifier>,
+    #[cfg_attr(
+        feature = "ser",
+        serde(serialize_with = "crate::util::duration::serialize_duration")
+    )]
     pub range: Duration,
     /// Default is the global evaluation interval.
+    #[cfg_attr(
+        feature = "ser",
+        serde(serialize_with = "crate::util::duration::serialize_duration_opt")
+    )]
     pub step: Option<Duration>,
 }
 
@@ -603,6 +750,20 @@ impl fmt::Display for NumberLiteral {
     }
 }
 
+#[cfg(feature = "ser")]
+impl serde::Serialize for NumberLiteral {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeMap;
+        let mut map = serializer.serialize_map(Some(1))?;
+        map.serialize_entry("val", &self.to_string())?;
+
+        map.end()
+    }
+}
+
 impl Prettier for NumberLiteral {
     fn needs_split(&self, _max: usize) -> bool {
         false
@@ -610,6 +771,7 @@ impl Prettier for NumberLiteral {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub struct StringLiteral {
     pub val: String,
 }
@@ -627,10 +789,14 @@ impl Prettier for StringLiteral {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub struct VectorSelector {
     pub name: Option<String>,
+    #[cfg_attr(feature = "ser", serde(flatten))]
     pub matchers: Matchers,
+    #[cfg_attr(feature = "ser", serde(serialize_with = "Offset::serialize_offset"))]
     pub offset: Option<Offset>,
+    #[cfg_attr(feature = "ser", serde(flatten))]
     pub at: Option<AtModifier>,
 }
 
@@ -727,8 +893,14 @@ impl Prettier for VectorSelector {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub struct MatrixSelector {
+    #[cfg_attr(feature = "ser", serde(flatten))]
     pub vs: VectorSelector,
+    #[cfg_attr(
+        feature = "ser",
+        serde(serialize_with = "crate::util::duration::serialize_duration")
+    )]
     pub range: Duration,
 }
 
@@ -803,8 +975,10 @@ impl Prettier for MatrixSelector {
 ///  - tan()
 ///  - tanh()
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub struct Call {
     pub func: Function,
+    #[cfg_attr(feature = "ser", serde(flatten))]
     pub args: FunctionArgs,
 }
 
@@ -852,19 +1026,25 @@ impl PartialEq for Extension {
 impl Eq for Extension {}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", serde(tag = "type", rename_all = "camelCase"))]
 pub enum Expr {
     /// Aggregate represents an aggregation operation on a Vector.
+    #[cfg_attr(feature = "ser", serde(rename = "aggregateExpr"))]
     Aggregate(AggregateExpr),
 
     /// Unary represents a unary operation on another expression.
     /// Currently unary operations are only supported for Scalars.
+    #[cfg_attr(feature = "ser", serde(rename = "unaryExpr"))]
     Unary(UnaryExpr),
 
     /// Binary represents a binary expression between two child expressions.
+    #[cfg_attr(feature = "ser", serde(rename = "binaryExpr"))]
     Binary(BinaryExpr),
 
     /// Paren wraps an expression so it cannot be disassembled as a consequence
     /// of operator precedence.
+    #[cfg_attr(feature = "ser", serde(rename = "parenExpr"))]
     Paren(ParenExpr),
 
     /// SubqueryExpr represents a subquery.
@@ -887,6 +1067,7 @@ pub enum Expr {
 
     /// Extension represents an extension expression. It is for user to attach additional
     /// information to the AST. This parser won't generate Extension node.
+    #[cfg_attr(feature = "ser", serde(skip))]
     Extension(Extension),
 }
 
diff --git a/src/parser/function.rs b/src/parser/function.rs
index 7565a90..1b90fed 100644
--- a/src/parser/function.rs
+++ b/src/parser/function.rs
@@ -23,6 +23,7 @@ use crate::util::join_vector;
 
 /// called by func in Call
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
 pub struct FunctionArgs {
     pub args: Vec<Box<Expr>>,
 }
@@ -78,9 +79,15 @@ impl Prettier for FunctionArgs {
 
 /// Functions is a list of all functions supported by PromQL, including their types.
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", serde(rename_all = "camelCase"))]
 pub struct Function {
     pub name: &'static str,
     pub arg_types: Vec<ValueType>,
+    #[cfg_attr(
+        feature = "ser",
+        serde(serialize_with = "Function::serialize_variadic")
+    )]
     pub variadic: bool,
     pub return_type: ValueType,
 }
@@ -99,6 +106,18 @@ impl Function {
             return_type,
         }
     }
+
+    #[cfg(feature = "ser")]
+    pub(crate) fn serialize_variadic<S>(variadic: &bool, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if *variadic {
+            serializer.serialize_i8(1)
+        } else {
+            serializer.serialize_i8(0)
+        }
+    }
 }
 
 macro_rules! map {
diff --git a/src/parser/token.rs b/src/parser/token.rs
index 4f2ee52..6696bbc 100644
--- a/src/parser/token.rs
+++ b/src/parser/token.rs
@@ -24,6 +24,16 @@ pub type TokenId = u8;
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct TokenType(TokenId);
 
+#[cfg(feature = "ser")]
+impl serde::Serialize for TokenType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(token_display(self.0))
+    }
+}
+
 lazy_static! {
     static ref KEYWORDS: HashMap<&'static str, TokenId> =
         [
diff --git a/src/parser/value.rs b/src/parser/value.rs
index 3186cb5..5a74fc0 100644
--- a/src/parser/value.rs
+++ b/src/parser/value.rs
@@ -15,6 +15,8 @@
 use std::fmt::{self, Display};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "ser", derive(serde::Serialize))]
+#[cfg_attr(feature = "ser", serde(rename_all = "camelCase"))]
 pub enum ValueType {
     Vector,
     Scalar,
diff --git a/src/util/duration.rs b/src/util/duration.rs
index 32d9f17..472e3fd 100644
--- a/src/util/duration.rs
+++ b/src/util/duration.rs
@@ -135,6 +135,30 @@ pub fn display_duration(duration: &Duration) -> String {
     ss
 }
 
+#[cfg(feature = "ser")]
+pub(crate) fn serialize_duration<S>(dur: &Duration, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    let duration_millis = dur.as_millis();
+    serializer.serialize_u128(duration_millis)
+}
+
+#[cfg(feature = "ser")]
+pub(crate) fn serialize_duration_opt<S>(
+    dur: &Option<Duration>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    if let Some(dur) = dur {
+        serialize_duration(dur, serializer)
+    } else {
+        serializer.serialize_none()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/tests/ser.rs b/tests/ser.rs
new file mode 100644
index 0000000..b7346e2
--- /dev/null
+++ b/tests/ser.rs
@@ -0,0 +1,428 @@
+// Copyright 2023 Greptime Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![cfg(feature = "ser")]
+
+use promql_parser::parser::parse;
+
+macro_rules! assert_json_ser_eq {
+    ($promql: literal, $json: tt) => {
+        let ast = parse($promql).expect("Failed to parse");
+        assert_eq!(
+            serde_json::to_value(ast).expect("Failed to serialize"),
+            serde_json::json!($json)
+        );
+    };
+}
+
+#[test]
+fn test_serialize() {
+    assert_json_ser_eq!(
+        "prometheus_tsdb_wal_writes_failed_total",
+
+    {
+        "matchers": [],
+        "name": "prometheus_tsdb_wal_writes_failed_total",
+        "offset": 0,
+        "type": "vectorSelector"
+    });
+
+    assert_json_ser_eq!(
+        "prometheus_tsdb_wal_writes_failed_total{label != \"nice\"}",
+
+        {
+            "matchers": [
+                {
+                    "name": "label",
+                    "type": "!=",
+                    "value": "nice"
+                }
+            ],
+            "name": "prometheus_tsdb_wal_writes_failed_total",
+            "offset": 0,
+            "type": "vectorSelector"
+        }
+    );
+
+    assert_json_ser_eq!(
+        "prometheus_tsdb_wal_writes_failed_total{label =~ \"nice\"}",
+
+    {
+        "matchers": [
+            {
+                "name": "label",
+                "type": "=~",
+                "value": "nice"
+            }
+        ],
+        "name": "prometheus_tsdb_wal_writes_failed_total",
+        "offset": 0,
+        "type": "vectorSelector"
+    });
+
+    assert_json_ser_eq!(
+        "prometheus_tsdb_wal_writes_failed_total{label !~ \"nice\"}",
+
+    {
+        "matchers": [
+            {
+                "name": "label",
+                "type": "!~",
+                "value": "nice"
+            }
+        ],
+        "name": "prometheus_tsdb_wal_writes_failed_total",
+        "offset": 0,
+        "type": "vectorSelector"
+    });
+
+    assert_json_ser_eq!(
+        "prometheus_tsdb_wal_writes_failed_total offset 2s @ start()",
+
+    {
+        "matchers": [],
+        "name": "prometheus_tsdb_wal_writes_failed_total",
+        "offset": 2000,
+        "startOrEnd": "start",
+        "timestamp": null,
+        "type": "vectorSelector"
+    });
+
+    assert_json_ser_eq!(
+        "prometheus_tsdb_wal_writes_failed_total offset -2s @ end()",
+
+    {
+        "matchers": [],
+        "name": "prometheus_tsdb_wal_writes_failed_total",
+        "offset": -2000,
+        "startOrEnd": "end",
+        "timestamp": null,
+        "type": "vectorSelector"
+    });
+
+    assert_json_ser_eq!(
+        "prometheus_tsdb_wal_writes_failed_total @ 1000",
+
+    {
+        "matchers": [],
+        "name": "prometheus_tsdb_wal_writes_failed_total",
+        "offset": 0,
+        "startOrEnd": null,
+        "timestamp": 1000000,
+        "type": "vectorSelector"
+    });
+
+    assert_json_ser_eq!(
+            "rate(prometheus_tsdb_wal_writes_failed_total{instance = \"localhost:9090\"}[1m])",
+
+    {
+        "args": [
+            {
+                "matchers": [
+                    {
+                        "name": "instance",
+                        "type": "=",
+                        "value": "localhost:9090"
+                    }
+                ],
+                "name": "prometheus_tsdb_wal_writes_failed_total",
+                "offset": 0,
+                "range": 60000,
+                "type": "matrixSelector"
+            }
+        ],
+        "func": {
+            "argTypes": [
+                "matrix"
+            ],
+            "name": "rate",
+            "returnType": "vector",
+            "variadic": 0
+        },
+        "type": "call"
+    }
+
+    );
+
+    assert_json_ser_eq!("\"yes\"",
+    {
+        "type": "stringLiteral",
+        "val": "yes"
+    }
+    );
+
+    assert_json_ser_eq!("1",
+    {
+        "type": "numberLiteral",
+        "val": "1"
+    }
+    );
+
+    assert_json_ser_eq!("1+1",
+    {
+        "bool": false,
+        "lhs": {
+            "type": "numberLiteral",
+            "val": "1"
+        },
+        "op": "+",
+        "matching": null,
+        "rhs": {
+            "type": "numberLiteral",
+            "val": "1"
+        },
+        "type": "binaryExpr"
+    }
+    );
+
+    assert_json_ser_eq!("- process_cpu_seconds_total",
+        {
+            "expr": {
+                "matchers": [],
+                "name": "process_cpu_seconds_total",
+                "offset": 0,
+                "type": "vectorSelector"
+            },
+            "op": "-",
+            "type": "unaryExpr"
+        }
+    );
+
+    assert_json_ser_eq!(r#"1 - ((node_memory_MemAvailable_bytes{job="node"} or (node_memory_Buffers_bytes{job="node"} + node_memory_Cached_bytes{job="node"} + node_memory_MemFree_bytes{job="node"} + node_memory_Slab_bytes{job="node"}) ) / node_memory_MemTotal_bytes{job="node"})"#,
+        {
+            "bool": false,
+            "lhs": {
+                "type": "numberLiteral",
+                "val": "1"
+            },
+            "op": "-",
+            "matching": null,
+            "rhs": {
+                "expr": {
+                    "bool": false,
+                    "lhs": {
+                        "expr": {
+                            "bool": false,
+                            "lhs": {
+                                "matchers": [
+                                    {
+                                        "name": "job",
+                                        "type": "=",
+                                        "value": "node"
+                                    }
+                                ],
+                                "name": "node_memory_MemAvailable_bytes",
+                                "offset": 0,
+                                "type": "vectorSelector"
+                            },
+                            "matching": {
+                                "card": "many-to-many",
+                                "include": [],
+                                "labels": [],
+                                "on": false
+                            },
+                            "op": "or",
+                            "rhs": {
+                                "expr": {
+                                    "bool": false,
+                                    "lhs": {
+                                        "bool": false,
+                                        "lhs": {
+                                            "bool": false,
+                                            "lhs": {
+                                                "matchers": [
+                                                    {
+                                                        "name": "job",
+                                                        "type": "=",
+                                                        "value": "node"
+                                                    }
+                                                ],
+                                                "name": "node_memory_Buffers_bytes",
+                                                "offset": 0,
+                                                "type": "vectorSelector"
+                                            },
+                                            "matching": null,
+                                            "op": "+",
+                                            "rhs": {
+                                                "matchers": [
+                                                    {
+                                                        "name": "job",
+                                                        "type": "=",
+                                                        "value": "node"
+                                                    }
+                                                ],
+                                                "name": "node_memory_Cached_bytes",
+                                                "offset": 0,
+                                                "type": "vectorSelector"
+                                            },
+                                            "type": "binaryExpr"
+                                        },
+                                        "matching": null,
+                                        "op": "+",
+                                        "rhs": {
+                                            "matchers": [
+                                                {
+                                                    "name": "job",
+                                                    "type": "=",
+                                                    "value": "node"
+                                                }
+                                            ],
+                                            "name": "node_memory_MemFree_bytes",
+                                            "offset": 0,
+                                            "type": "vectorSelector"
+                                        },
+                                        "type": "binaryExpr"
+                                    },
+                                    "matching": null,
+                                    "op": "+",
+                                    "rhs": {
+                                        "matchers": [
+                                            {
+                                                "name": "job",
+                                                "type": "=",
+                                                "value": "node"
+                                            }
+                                        ],
+                                        "name": "node_memory_Slab_bytes",
+                                        "offset": 0,
+                                        "type": "vectorSelector"
+                                    },
+                                    "type": "binaryExpr"
+                                },
+                                "type": "parenExpr"
+                            },
+                            "type": "binaryExpr"
+                        },
+                        "type": "parenExpr"
+                    },
+                    "matching": null,
+                    "op": "/",
+                    "rhs": {
+                        "matchers": [
+                            {
+                                "name": "job",
+                                "type": "=",
+                                "value": "node"
+                            }
+                        ],
+                        "name": "node_memory_MemTotal_bytes",
+                        "offset": 0,
+                        "type": "vectorSelector"
+                    },
+                    "type": "binaryExpr"
+                },
+                "type": "parenExpr"
+            },
+            "type": "binaryExpr"
+        }
+    );
+
+    assert_json_ser_eq!("foo * on(branch) bar ",
+    {
+        "bool": false,
+        "lhs": {
+            "matchers": [],
+            "name": "foo",
+            "offset": 0,
+            "type": "vectorSelector"
+        },
+        "matching": {
+            "card": "one-to-one",
+            "include": [],
+            "labels": [
+            "branch"
+            ],
+            "on": true
+        },
+        "op": "*",
+        "rhs": {
+            "matchers": [],
+            "name": "bar",
+            "offset": 0,
+            "type": "vectorSelector"
+        },
+        "type": "binaryExpr"
+    });
+
+    assert_json_ser_eq!("foo * ignoring(branch) bar ",
+        {
+            "bool": false,
+            "lhs": {
+                "matchers": [],
+                "name": "foo",
+                "offset": 0,
+                "type": "vectorSelector"
+            },
+            "matching": {
+                "card": "one-to-one",
+                "include": [],
+                "labels": [
+                    "branch"
+                ],
+                "on": false
+            },
+            "op": "*",
+            "rhs": {
+                "matchers": [],
+                "name": "bar",
+                "offset": 0,
+                "type": "vectorSelector"
+            },
+            "type": "binaryExpr"
+        }
+    );
+
+    assert_json_ser_eq!("min_over_time( rate(http_requests_total[5m])[30m:1m] )",
+        {
+            "args": [
+                {
+                    "expr": {
+                        "args": [
+                            {
+                                "matchers": [],
+                                "name": "http_requests_total",
+                                "offset": 0,
+                                "range": 300000,
+                                "type": "matrixSelector"
+                            }
+                        ],
+                        "func": {
+                            "argTypes": [
+                                "matrix"
+                            ],
+                            "name": "rate",
+                            "returnType": "vector",
+                            "variadic": 0
+                        },
+                        "type": "call"
+                    },
+                    "offset": 0,
+                    "range": 1800000,
+                    "step": 60000,
+                    "type": "subquery"
+                }
+            ],
+            "func": {
+                "argTypes": [
+                    "matrix"
+                ],
+                "name": "min_over_time",
+                "returnType": "vector",
+                "variadic": 0
+            },
+            "type": "call"
+
+    }
+        );
+}