Deal with the cases when type infer is not precise in Gremlin queries in GOpt

[BingqingLyu]

Is your feature request related to a problem? Please describe.

Currently, in gremlin queries, the type infer may not be precise (for the operators those are not in match()) in GOpt.
For example,

g.V().hasLabel("PERSON").out("KNOWS").count()

The query plan looks like (we focus on the types here, and omit most fields in the plan):

    operations: [                                                                                                                                                                                                                   [738/1968]
        PhysicalOpr {
            opr: Scan(
                Scan {
                    scan_opt: Vertex,
                    alias: None,
                    params: Some(
                        QueryParams {
                            tables: [
                                NameOrId {
                                    item: Some(
                                        Id(
                                            1,
                                        ),
                                    ),
                                },
                            ],
                            ...
                        },
                    ),
                    ...
                },
            ),
        },
        PhysicalOpr {
            opr: Edge(
                EdgeExpand {
                    v_tag: None,
                    direction: Out,
                    params: Some(
                        QueryParams {
                            tables: [
                                NameOrId {
                                    item: Some(
                                        Id(
                                            12,
                                        ),
                                    ),
                                },
                            ],
                            columns: [
                                NameOrId {
                                    item: Some(
                                        Name(
                                            "creationDate",
                                        ),
                                    ),
                                },
                            ],
                            is_all_columns: false,
                            limit: None,
                            predicate: None,
                            sample_ratio: 1.0,
                            extra: {},
                        },
                    ),
                    alias: None,
                    expand_opt: Edge,
                    is_optional: false,
                },
            ),
        },
        PhysicalOpr {
            opr: Vertex(
                GetV {
                    tag: None,
                    opt: End,
                    params: Some(
                        QueryParams {
                            tables: [
                                NameOrId {
                                    item: Some(
                                        Id(
                                            0,
                                        ),
                                    ),
                                },
                                NameOrId {
                                    item: Some(
                                        Id(
                                            1,
                                        ),
                                    ),
                                },
                                NameOrId {
                                    item: Some(
                                        Id(
                                            2,
                                        ),
                                    ),
                                },
                                NameOrId {
                                    item: Some(
                                        Id(
                                            3,
                                        ),
                                    ),
                                },
                                NameOrId {
                                    item: Some(
                                        Id(
                                            4,
                                        ),
                                    ),
                                },
                                NameOrId {
                                    item: Some(
                                        Id(
                                            5,
                                        ),
                                    ),
                                },
                                NameOrId {
                                    item: Some(
                                        Id(
                                            6,
                                        ),
                                    ),
                                },
                                NameOrId {
                                    item: Some(
                                        Id(
                                            7,
                                        ),
                                    ),
                                },
                            ],
                            columns: [],
                            is_all_columns: false,
                            limit: None,
                            predicate: None,
                            sample_ratio: 1.0,
                            extra: {},
                        },
                    ),
                    alias: None,
                },
            ),
        },

Here, the GetV's query params contains all vertex types, which will involve extra unnecessary computation in Runtime (to check if the expanded vertices satisfy the constraints in query param).

However, this seems common in Gremlin queries (users may not always query like g.V().hasLabel("PERSON").out("KNOWS").hasLabel("PERSON").count()). Try to optimize such cases.

[siyuan0322]

fixed by #3804