टेक्स्ट की तुलना करें

दो टेक्स्ट फ़ाइलों के बीच अंतर ढूंढें

प्रदर्शन

लेआउट

रियल-टाइम एडिटररिक्त स्थान छिपाएँअपरिवर्तित संक्षिप्त करेंलाइन रैप बंद

परिवर्तन हाइलाइट करें

सिंटैक्स

प्रोसेसिंग

Diffchecker Desktop Diffchecker चलाने का सबसे सुरक्षित तरीका। Diffchecker Desktop ऐप पाएं: आपके diffs कभी आपके कंप्यूटर से बाहर नहीं जाते!Desktop पाएं

datafusion #4873

बनाया गया 4 वर्ष पहलेDiff कभी समाप्त नहीं होता

6 हटाए गए

लाइनें
कुल
हटाया गया

अक्षर
कुल
हटाया गया

इस सुविधा का उपयोग जारी रखने के लिए, अपग्रेड करें Diffchecker Pro मूल्य देखें

524 लाइनें

6 जोड़े गए

लाइनें
कुल
जोड़ा गया

अक्षर
कुल
जोड़ा गया

इस सुविधा का उपयोग जारी रखने के लिए, अपग्रेड करें Diffchecker Pro मूल्य देखें

524 लाइनें

ProjectionExec {

expr: [

(

Column {

index: 1,

"col1",

(

Column {

index: 0,

"col2",

(

ScalarFunctionExpr {

fun: "<FUNC>",

args: [

CastExpr {

expr: Column {

index: 4,

cast_type: Float32,

cast_options: CastOptions {

safe: false,

Literal {

value: Float32(0),

return_type: Float32,

"sum_col3",

schema: Schema {

fields: [

Field {

data_type: Utf8,

nullable: true,

dict_id: 0,

dict_is_ordered: false,

metadata: {},

Field {

data_type: UInt64,

nullable: true,

dict_id: 0,

dict_is_ordered: false,

metadata: {},

Field {

data_type: Float32,

nullable: true,

dict_id: 0,

dict_is_ordered: false,

metadata: {},

input: CoalesceBatchesExec {

input: HashJoinExec {

left: CoalesceBatchesExec {

input: RepartitionExec {

input: CrossJoinExec {

left: CoalescePartitionsExec {

input: AggregateExec {

mode: FinalPartitioned,

group_by: PhysicalGroupBy {

expr: [

(

Column {

index: 0,

"col2",

null_expr: [],

groups: [

[

false,

aggr_expr: [],

input: CoalesceBatchesExec {

input: RepartitionExec {

input: AggregateExec {

mode: Partial,

group_by: PhysicalGroupBy {

सेव किए गए Diffs

ऑरिजनल टेक्स्ट

फ़ाइल खोलें

ProjectionExec {
    expr: [
        (
            Column {
                name: "col1",
                index: 1,
            },
            "col1",
        ),
        (
            Column {
                name: "col2",
                index: 0,
            },
            "col2",
        ),
        (
            ScalarFunctionExpr {
                fun: "<FUNC>",
                name: "coalesce",
                args: [
                    CastExpr {
                        expr: Column {
                            name: "sum_col3",
                            index: 4,
                        },
                        cast_type: Float32,
                        cast_options: CastOptions {
                            safe: false,
                        },
                    },
                    Literal {
                        value: Float32(0),
                    },
                ],
                return_type: Float32,
            },
            "sum_col3",
        ),
    ],
    schema: Schema {
        fields: [
            Field {
                name: "col1",
                data_type: Utf8,
                nullable: true,
                dict_id: 0,
                dict_is_ordered: false,
                metadata: {},
            },
            Field {
                name: "col2",
                data_type: UInt64,
                nullable: true,
                dict_id: 0,
                dict_is_ordered: false,
                metadata: {},
            },
            Field {
                name: "sum_col3",
                data_type: Float32,
                nullable: true,
                dict_id: 0,
                dict_is_ordered: false,
                metadata: {},
            },
        ],
        metadata: {},
    },
    input: CoalesceBatchesExec {
        input: HashJoinExec {
            left: CoalesceBatchesExec {
                input: RepartitionExec {
                    input: CrossJoinExec {
                        left: CoalescePartitionsExec {
                            input: AggregateExec {
                                mode: FinalPartitioned,
                                group_by: PhysicalGroupBy {
                                    expr: [
                                        (
                                            Column {
                                                name: "col2",
                                                index: 0,
                                            },
                                            "col2",
                                        ),
                                    ],
                                    null_expr: [],
                                    groups: [
                                        [
                                            false,
                                        ],
                                    ],
                                },
                                aggr_expr: [],
                                input: CoalesceBatchesExec {
                                    input: RepartitionExec {
                                        input: AggregateExec {
                                            mode: Partial,
                                            group_by: PhysicalGroupBy {
                                                expr: [
                                                    (
                                                        Column {
                                                            name: "col2",
                                                            index: 0,
                                                        },
                                                        "col2",
                                                    ),
                                                ],
                                                null_expr: [],
                                                groups: [
                                                    [
                                                        false,
                                                    ],
                                                ],
                                            },
                                            aggr_expr: [],
                                            input: RepartitionExec {
                                                input: partitions: [...]schema: Schema { fields: [Field { name: "col2", data_type: UInt64, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }], metadata: {} }projection: Some([1]),
                                                partitioning: RoundRobinBatch(
                                                    10,
                                                ),
                                                state: Mutex {
                                                    data: RepartitionExecState {
                                                        channels: {},
                                                        abort_helper: AbortOnDropMany(
                                                            [],
                                                        ),
                                                    },
                                                },
                                                metrics: ExecutionPlanMetricsSet {
                                                    inner: Mutex {
                                                        data: MetricsSet {
                                                            metrics: [],
                                                        },
                                                    },
                                                },
                                            },
                                            schema: Schema {
                                                fields: [
                                                    Field {
                                                        name: "col2",
                                                        data_type: UInt64,
                                                        nullable: true,
                                                        dict_id: 0,
                                                        dict_is_ordered: false,
                                                        metadata: {},
                                                    },
                                                ],
                                                metadata: {},
                                            },
                                            input_schema: Schema {
                                                fields: [
                                                    Field {
                                                        name: "col2",
                                                        data_type: UInt64,
                                                        nullable: true,
                                                        dict_id: 0,
                                                        dict_is_ordered: false,
                                                        metadata: {},
                                                    },
                                                ],
                                                metadata: {},
                                            },
                                            alias_map: {},
                                            metrics: ExecutionPlanMetricsSet {
                                                inner: Mutex {
                                                    data: MetricsSet {
                                                        metrics: [],
                                                    },
                                                },
                                            },
                                        },
                                        partitioning: Hash(
                                            [
                                                Column {
                                                    name: "col2",
                                                    index: 0,
                                                },
                                            ],
                                            10,
                                        ),
                                        state: Mutex {
                                            data: RepartitionExecState {
                                                channels: {},
                                                abort_helper: AbortOnDropMany(
                                                    [],
                                                ),
                                            },
                                        },
                                        metrics: ExecutionPlanMetricsSet {
                                            inner: Mutex {
                                                data: MetricsSet {
                                                    metrics: [],
                                                },
                                            },
                                        },
                                    },
                                    target_batch_size: 8192,
                                    metrics: ExecutionPlanMetricsSet {
                                        inner: Mutex {
                                            data: MetricsSet {
                                                metrics: [],
                                            },
                                        },
                                    },
                                },
                                schema: Schema {
                                    fields: [
                                        Field {
                                            name: "col2",
                                            data_type: UInt64,
                                            nullable: true,
                                            dict_id: 0,
                                            dict_is_ordered: false,
                                            metadata: {},
                                        },
                                    ],
                                    metadata: {},
                                },
                                input_schema: Schema {
                                    fields: [
                                        Field {
                                            name: "col2",
                                            data_type: UInt64,
                                            nullable: true,
                                            dict_id: 0,
                                            dict_is_ordered: false,
                                            metadata: {},
                                        },
                                    ],
                                    metadata: {},
                                },
                                alias_map: {},
                                metrics: ExecutionPlanMetricsSet {
                                    inner: Mutex {
                                        data: MetricsSet {
                                            metrics: [],
                                        },
                                    },
                                },
                            },
                            metrics: ExecutionPlanMetricsSet {
                                inner: Mutex {
                                    data: MetricsSet {
                                        metrics: [],
                                    },
                                },
                            },
                        },
                        right: AggregateExec {
                            mode: FinalPartitioned,
                            group_by: PhysicalGroupBy {
                                expr: [
                                    (
                                        Column {
                                            name: "col1",
                                            index: 0,
                                        },
                                        "col1",
                                    ),
                                ],
                                null_expr: [],
                                groups: [
                                    [
                                        false,
                                    ],
                                ],
                            },
                            aggr_expr: [],
                            input: CoalesceBatchesExec {
                                input: RepartitionExec {
                                    input: AggregateExec {
                                        mode: Partial,
                                        group_by: PhysicalGroupBy {
                                            expr: [
                                                (
                                                    Column {
                                                        name: "col1",
                                                        index: 0,
                                                    },
                                                    "col1",
                                                ),
                                            ],
                                            null_expr: [],
                                            groups: [
                                                [
                                                    false,
                                                ],
                                            ],
                                        },
                                        aggr_expr: [],
                                        input: RepartitionExec {
                                            input: partitions: [...]schema: Schema { fields: [Field { name: "col1", data_type: Utf8, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }], metadata: {} }projection: Some([0]),
                                            partitioning: RoundRobinBatch(
                                                10,
                                            ),
                                            state: Mutex {
                                                data: RepartitionExecState {
                                                    channels: {},
                                                    abort_helper: AbortOnDropMany(
                                                        [],
                                                    ),
                                                },
                                            },
                                            metrics: ExecutionPlanMetricsSet {
                                                inner: Mutex {
                                                    data: MetricsSet {
                                                        metrics: [],
                                                    },
                                                },
                                            },
                                        },
                                        schema: Schema {
                                            fields: [
                                                Field {
                                                    name: "col1",
                                                    data_type: Utf8,
                                                    nullable: true,
                                                    dict_id: 0,
                                                    dict_is_ordered: false,
                                                    metadata: {},
                                                },
                                            ],
                                            metadata: {},
                                        },
                                        input_schema: Schema {
                                            fields: [
                                                Field {
                                                    name: "col1",
                                                    data_type: Utf8,
                                                    nullable: true,
                                                    dict_id: 0,
                                                    dict_is_ordered: false,
                                                    metadata: {},
                                                },
                                            ],
                                            metadata: {},
                                        },
                                        alias_map: {},
                                        metrics: ExecutionPlanMetricsSet {
                                            inner: Mutex {
                                                data: MetricsSet {
                                                    metrics: [],
                                                },
                                            },
                                        },
                                    },
                                    partitioning: Hash(
                                        [
                                            Column {
                                                name: "col1",
                                                index: 0,
                                            },
                                        ],
                                        10,
                                    ),
                                    state: Mutex {
                                        data: RepartitionExecState {
                                            channels: {},
                                            abort_helper: AbortOnDropMany(
                                                [],
                                            ),
                                        },
                                    },
                                    metrics: ExecutionPlanMetricsSet {
                                        inner: Mutex {
                                            data: MetricsSet {
                                                metrics: [],
                                            },
                                        },
                                    },
                                },
                                target_batch_size: 8192,
                                metrics: ExecutionPlanMetricsSet {
                                    inner: Mutex {
                                        data: MetricsSet {
                                            metrics: [],
                                        },
                                    },
                                },
                            },
                            schema: Schema {
                                fields: [
                                    Field {
                                        name: "col1",
                                        data_type: Utf8,
                                        nullable: true,
                                        dict_id: 0,
                                        dict_is_ordered: false,
                                        metadata: {},
                                    },
                                ],
                                metadata: {},
                            },
                            input_schema: Schema {
                                fields: [
                                    Field {
                                        name: "col1",
                                        data_type: Utf8,
                                        nullable: true,
                                        dict_id: 0,
                                        dict_is_ordered: false,
                                        metadata: {},
                                    },
                                ],
                                metadata: {},
                            },
                            alias_map: {},
                            metrics: ExecutionPlanMetricsSet {
                                inner: Mutex {
                                    data: MetricsSet {
                                        metrics: [],
                                    },
                                },
                            },
                        },
                        schema: Schema {
                            fields: [
                                Field {
                                    name: "col2",
                                    data_type: UInt64,
                                    nullable: true,
                                    dict_id: 0,
                                    dict_is_ordered: false,
                                    metadata: {},
                                },
                                Field {
                                    name: "col1",
                                    data_type: Utf8,
                                    nullable: true,
                                    dict_id: 0,
                                    dict_is_ordered: false,
                                    metadata: {},
                                },
                            ],
                            metadata: {},
                        },
                        left_fut: OnceAsync,
                    },
                    partitioning: Hash(
                        [
                            Column {
                                name: "col1",
                                index: 1,
                            },
                            Column {
                                name: "col2",
                                index: 0,
                            },
                        ],
                        10,
                    ),
                    state: Mutex {
                        data: RepartitionExecState {
                            channels: {},
                            abort_helper: AbortOnDropMany(
                                [],
                            ),
                        },
                    },
                    metrics: ExecutionPlanMetricsSet {
                        inner: Mutex {
                            data: MetricsSet {
                                metrics: [],
                            },
                        },
                    },
                },
                target_batch_size: 8192,
                metrics: ExecutionPlanMetricsSet {
                    inner: Mutex {
                        data: MetricsSet {
                            metrics: [],
                        },
                    },
                },
            },
            right: ProjectionExec {
                expr: [
                    (
                        Column {
                            name: "col1",
                            index: 0,
                        },
                        "col1",
                    ),
                    (
                        Column {
                            name: "col2",
                            index: 1,
                        },
                        "col2",
                    ),
                    (
                        Column {
                            name: "SUM(tbl.col3)",
                            index: 2,
                        },
                        "sum_col3",
                    ),
                ],
                schema: Schema {
                    fields: [
                        Field {
                            name: "col1",
                            data_type: Utf8,
                            nullable: true,
                            dict_id: 0,
                            dict_is_ordered: false,
                            metadata: {},
                        },
                        Field {
                            name: "col2",
                            data_type: UInt64,
                            nullable: true,
                            dict_id: 0,
                            dict_is_ordered: false,
                            metadata: {},
                        },
                        Field {
                            name: "sum_col3",
                            data_type: UInt64,
                            nullable: true,
                            dict_id: 0,
                            dict_is_ordered: false,
                            metadata: {},
                        },
                    ],
                    metadata: {},
                },
                input: AggregateExec {
                    mode: FinalPartitioned,
                    group_by: PhysicalGroupBy {
                        expr: [
                            (
                                Column {
                                    name: "col1",
                                    index: 0,
                                },
                                "col1",
                            ),
                            (
                                Column {
                                    name: "col2",
                                    index: 1,
                                },
                                "col2",
                            ),
                        ],
                        null_expr: [],
                        groups: [
                            [
                                false,
                                false,
                            ],
                        ],
                    },
                    aggr_expr: [
                        Sum {
                            name: "SUM(tbl.col3)",
                            data_type: UInt64,
                            expr: Column {
                                name: "col3",
                                index: 2,
                            },
                            nullable: true,
                        },
                    ],
                    input: CoalesceBatchesExec {
                        input: RepartitionExec {
                            input: AggregateExec {
                                mode: Partial,
                                group_by: PhysicalGroupBy {
                                    expr: [
                                        (
                                            Column {
                                                name: "col1",
                                                index: 0,
                                            },
                                            "col1",
                                        ),
                                        (
                                            Column {
                                                name: "col2",
                                                index: 1,
                                            },
                                            "col2",
                                        ),
                                    ],
                                    null_expr: [],
                                    groups: [
                                        [
                                            false,
                                            false,
                                        ],
                                    ],
                                },
                                aggr_expr: [
                                    Sum {
                                        name: "SUM(tbl.col3)",
                                        data_type: UInt64,
                                        expr: Column {
                                            name: "col3",
                                            index: 2,
                                        },
                                        nullable: true,
                                    },
                                ],
                                input: RepartitionExec {
                                    input: partitions: [...]schema: Schema { fields: [Field { name: "col1", data_type: Utf8, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }, Field { name: "col2", data_type: UInt64, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }, Field { name: "col3", data_type: UInt64, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }], metadata: {} }projection: Some([0, 1, 2]),
                                    partitioning: RoundRobinBatch(
                                        10,
                                    ),
                                    state: Mutex {
                                        data: RepartitionExecState {
                                            channels: {},
                                            abort_helper: AbortOnDropMany(
                                                [],
                                            ),
                                        },
                                    },
                                    metrics: ExecutionPlanMetricsSet {
                                        inner: Mutex {
                                            data: MetricsSet {
                                                metrics: [],
                                            },
                                        },
                                    },
                                },
                                schema: Schema {
                                    fields: [
                                        Field {
                                            name: "col1",
                                            data_type: Utf8,
                                            nullable: true,
                                            dict_id: 0,
                                            dict_is_ordered: false,
                                            metadata: {},
                                        },
                                        Field {
                                            name: "col2",
                                            data_type: UInt64,
                                            nullable: true,
                                            dict_id: 0,
                                            dict_is_ordered: false,
                                            metadata: {},
                                        },
                                        Field {
                                            name: "SUM(tbl.col3)[sum]",
                                            data_type: UInt64,
                                            nullable: true,
                                            dict_id: 0,
                                            dict_is_ordered: false,
                                            metadata: {},
                                        },
                                        Field {
                                            name: "SUM(tbl.col3)[count]",
                                            data_type: UInt64,
                                            nullable: true,
                                            dict_id: 0,
                                            dict_is_ordered: false,
                                            metadata: {},
                                        },
                                    ],
                                    metadata: {},
                                },
                                input_schema: Schema {
                                    fields: [
                                        Field {
                                            name: "col1",
                                            data_type: Utf8,
                                            nullable: true,
                                            dict_id: 0,
                                            dict_is_ordered: false,
                                            metadata: {},
                                        },
                                        Field {
                                            name: "col2",
                                            data_type: UInt64,
                                            nullable: true,
                                            dict_id: 0,
                                            dict_is_ordered: false,
                                            metadata: {},
                                        },
                                        Field {
                                            name: "col3",
                                            data_type: UInt64,
                                            nullable: true,
                                            dict_id: 0,
                                            dict_is_ordered: false,
                                            metadata: {},
                                        },
                                    ],
                                    metadata: {},
                                },
                                alias_map: {},
                                metrics: ExecutionPlanMetricsSet {
                                    inner: Mutex {
                                        data: MetricsSet {
                                            metrics: [],
                                        },
                                    },
                                },
                            },
                            partitioning: Hash(
                                [
                                    Column {
                                        name: "col1",
                                        index: 0,
                                    },
                                    Column {
                                        name: "col2",
                                        index: 1,
                                    },
                                ],
                                10,
                            ),
                            state: Mutex {
                                data: RepartitionExecState {
                                    channels: {},
                                    abort_helper: AbortOnDropMany(
                                        [],
                                    ),
                                },
                            },
                            metrics: ExecutionPlanMetricsSet {
                                inner: Mutex {
                                    data: MetricsSet {
                                        metrics: [],
                                    },
                                },
                            },
                        },
                        target_batch_size: 8192,
                        metrics: ExecutionPlanMetricsSet {
                            inner: Mutex {
                                data: MetricsSet {
                                    metrics: [],
                                },
                            },
                        },
                    },
                    schema: Schema {
                        fields: [
                            Field {
                                name: "col1",
                                data_type: Utf8,
                                nullable: true,
                                dict_id: 0,
                                dict_is_ordered: false,
                                metadata: {},
                            },
                            Field {
                                name: "col2",
                                data_type: UInt64,
                                nullable: true,
                                dict_id: 0,
                                dict_is_ordered: false,
                                metadata: {},
                            },
                            Field {
                                name: "SUM(tbl.col3)",
                                data_type: UInt64,
                                nullable: true,
                                dict_id: 0,
                                dict_is_ordered: false,
                                metadata: {},
                            },
                        ],
                        metadata: {},
                    },
                    input_schema: Schema {
                        fields: [
                            Field {
                                name: "col1",
                                data_type: Utf8,
                                nullable: true,
                                dict_id: 0,
                                dict_is_ordered: false,
                                metadata: {},
                            },
                            Field {
                                name: "col2",
                                data_type: UInt64,
                                nullable: true,
                                dict_id: 0,
                                dict_is_ordered: false,
                                metadata: {},
                            },
                            Field {
                                name: "col3",
                                data_type: UInt64,
                                nullable: true,
                                dict_id: 0,
                                dict_is_ordered: false,
                                metadata: {},
                            },
                        ],
                        metadata: {},
                    },
                    alias_map: {},
                    metrics: ExecutionPlanMetricsSet {
                        inner: Mutex {
                            data: MetricsSet {
                                metrics: [],
                            },
                        },
                    },
                },
                output_ordering: None,
                alias_map: {
                    Column {
                        name: "SUM(tbl.col3)",
                        index: 2,
                    }: [
                        Column {
                            name: "sum_col3",
                            index: 2,
                        },
                    ],
                },
                metrics: ExecutionPlanMetricsSet {
                    inner: Mutex {
                        data: MetricsSet {
                            metrics: [],
                        },
                    },
                },
            },
            on: [
                (
                    Column {
                        name: "col1",
                        index: 1,
                    },
                    Column {
                        name: "col1",
                        index: 0,
                    },
                ),
                (
                    Column {
                        name: "col2",
                        index: 0,
                    },
                    Column {
                        name: "col2",
                        index: 1,
                    },
                ),
            ],
            filter: None,
            join_type: Left,
            schema: Schema {
                fields: [
                    Field {
                        name: "col2",
                        data_type: UInt64,
                        nullable: true,
                        dict_id: 0,
                        dict_is_ordered: false,
                        metadata: {},
                    },
                    Field {
                        name: "col1",
                        data_type: Utf8,
                        nullable: true,
                        dict_id: 0,
                        dict_is_ordered: false,
                        metadata: {},
                    },
                    Field {
                        name: "col1",
                        data_type: Utf8,
                        nullable: true,
                        dict_id: 0,
                        dict_is_ordered: false,
                        metadata: {},
                    },
                    Field {
                        name: "col2",
                        data_type: UInt64,
                        nullable: true,
                        dict_id: 0,
                        dict_is_ordered: false,
                        metadata: {},
                    },
                    Field {
                        name: "sum_col3",
                        data_type: UInt64,
                        nullable: true,
                        dict_id: 0,
                        dict_is_ordered: false,
                        metadata: {},
                    },
                ],
                metadata: {},
            },
            left_fut: OnceAsync,
            random_state: RandomState { .. },
            mode: Partitioned,
            metrics: ExecutionPlanMetricsSet {
                inner: Mutex {
                    data: MetricsSet {
                        metrics: [],
                    },
                },
            },
            column_indices: [
                ColumnIndex {
                    index: 0,
                    side: Left,
                },
                ColumnIndex {
                    index: 1,
                    side: Left,
                },
                ColumnIndex {
                    index: 0,
                    side: Right,
                },
                ColumnIndex {
                    index: 1,
                    side: Right,
                },
                ColumnIndex {
                    index: 2,
                    side: Right,
                },
            ],
            null_equals_null: false,
        },
        target_batch_size: 8192,
        metrics: ExecutionPlanMetricsSet {
            inner: Mutex {
                data: MetricsSet {
                    metrics: [],
                },
            },
        },
    },
    output_ordering: None,
    alias_map: {
        Column {
            name: "col1",
            index: 1,
        }: [
            Column {
                name: "col1",
                index: 0,
            },
        ],
        Column {
            name: "col2",
            index: 0,
        }: [
            Column {
                name: "col2",
                index: 1,
            },
        ],
    },
    metrics: ExecutionPlanMetricsSet {
        inner: Mutex {
            data: MetricsSet {
                metrics: [],
            },
        },
    },
}

परिवर्तित टेक्स्ट

फ़ाइल खोलें

ProjectionExec {
    expr: [
        (
            Column {
                name: "col1",
                index: 1,
            },
            "col1",
        ),
        (
            Column {
                name: "col2",
                index: 0,
            },
            "col2",
        ),
        (
            ScalarFunctionExpr {
                fun: "<FUNC>",
                name: "coalesce",
                args: [
                    CastExpr {
                        expr: Column {
                            name: "sum_col3",
                            index: 4,
                        },
                        cast_type: Float32,
                        cast_options: CastOptions {
                            safe: false,
                        },
                    },
                    Literal {
                        value: Float32(0),
                    },
                ],
                return_type: Float32,
            },
            "sum_col3",
        ),
    ],
    schema: Schema {
        fields: [
            Field {
                name: "col1",
                data_type: Utf8,
                nullable: true,
                dict_id: 0,
                dict_is_ordered: false,
                metadata: {},
            },
            Field {
                name: "col2",
                data_type: UInt64,
                nullable: true,
                dict_id: 0,
                dict_is_ordered: false,
                metadata: {},
            },
            Field {
                name: "sum_col3",
                data_type: Float32,
                nullable: true,
                dict_id: 0,
                dict_is_ordered: false,
                metadata: {},
            },
        ],
        metadata: {},
    },
    input: CoalesceBatchesExec {
        input: HashJoinExec {
            left: CoalesceBatchesExec {
                input: RepartitionExec {
                    input: CrossJoinExec {
                        left: CoalescePartitionsExec {
                            input: AggregateExec {
                                mode: FinalPartitioned,
                                group_by: PhysicalGroupBy {
                                    expr: [
                                        (
                                            Column {
                                                name: "col2",
                                                index: 0,
                                            },
                                            "col2",
                                        ),
                                    ],
                                    null_expr: [],
                                    groups: [
                                        [
                                            false,
                                        ],
                                    ],
                                },
                                aggr_expr: [],
                                input: CoalesceBatchesExec {
                                    input: RepartitionExec {
                                        input: AggregateExec {
                                            mode: Partial,
                                            group_by: PhysicalGroupBy {
                                                expr: [
                                                    (
                                                        Column {
                                                            name: "col2",
                                                            index: 0,
                                                        },
                                                        "col2",
                                                    ),
                                                ],
                                                null_expr: [],
                                                groups: [
                                                    [
                                                        false,
                                                    ],
                                                ],
                                            },
                                            aggr_expr: [],
                                            input: RepartitionExec {
                                                input: partitions: [...]schema: Schema { fields: [Field { name: "col2", data_type: UInt64, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }], metadata: {} }projection: Some([1]),
                                                partitioning: RoundRobinBatch(
                                                    10,
                                                ),
                                                state: Mutex {
                                                    data: RepartitionExecState {
                                                        channels: {},
                                                        abort_helper: AbortOnDropMany(
                                                            [],
                                                        ),
                                                    },
                                                },
                                                metrics: ExecutionPlanMetricsSet {
                                                    inner: Mutex {
                                                        data: MetricsSet {
                                                            metrics: [],
                                                        },
                                                    },
                                                },
                                            },
                                            schema: Schema {
                                                fields: [
                                                    Field {
                                                        name: "col2",
                                                        data_type: UInt64,
                                                        nullable: true,
                                                        dict_id: 0,
                                                        dict_is_ordered: false,
                                                        metadata: {},
                                                    },
                                                ],
                                                metadata: {},
                                            },
                                            input_schema: Schema {
                                                fields: [
                                                    Field {
                                                        name: "col2",
                                                        data_type: UInt64,
                                                        nullable: true,
                                                        dict_id: 0,
                                                        dict_is_ordered: false,
                                                        metadata: {},
                                                    },
                                                ],
                                                metadata: {},
                                            },
                                            alias_map: {},
                                            metrics: ExecutionPlanMetricsSet {
                                                inner: Mutex {
                                                    data: MetricsSet {
                                                        metrics: [],
                                                    },
                                                },
                                            },
                                        },
                                        partitioning: Hash(
                                            [
                                                Column {
                                                    name: "col2",
                                                    index: 0,
                                                },
                                            ],
                                            10,
                                        ),
                                        state: Mutex {
                                            data: RepartitionExecState {
                                                channels: {},
                                                abort_helper: AbortOnDropMany(
                                                    [],
                                                ),
                                            },
                                        },
                                        metrics: ExecutionPlanMetricsSet {
                                            inner: Mutex {
                                                data: MetricsSet {
                                                    metrics: [],
                                                },
                                            },
                                        },
                                    },
                                    target_batch_size: 8192,
                                    metrics: ExecutionPlanMetricsSet {
                                        inner: Mutex {
                                            data: MetricsSet {
                                                metrics: [],
                                            },
                                        },
                                    },
                                },
                                schema: Schema {
                                    fields: [
                                        Field {
                                            name: "col2",
                                            data_type: UInt64,
                                            nullable: true,
                                            dict_id: 0,
                                            dict_is_ordered: false,
                                            metadata: {},
                                        },
                                    ],
                                    metadata: {},
                                },
                                input_schema: Schema {
                                    fields: [
                                        Field {
                                            name: "col2",
                                            data_type: UInt64,
                                            nullable: true,
                                            dict_id: 0,
                                            dict_is_ordered: false,
                                            metadata: {},
                                        },
                                    ],
                                    metadata: {},
                                },
                                alias_map: {},
                                metrics: ExecutionPlanMetricsSet {
                                    inner: Mutex {
                                        data: MetricsSet {
                                            metrics: [],
                                        },
                                    },
                                },
                            },
                            metrics: ExecutionPlanMetricsSet {
                                inner: Mutex {
                                    data: MetricsSet {
                                        metrics: [],
                                    },
                                },
                            },
                        },
                        right: AggregateExec {
                            mode: FinalPartitioned,
                            group_by: PhysicalGroupBy {
                                expr: [
                                    (
                                        Column {
                                            name: "col1",
                                            index: 0,
                                        },
                                        "col1",
                                    ),
                                ],
                                null_expr: [],
                                groups: [
                                    [
                                        false,
                                    ],
                                ],
                            },
                            aggr_expr: [],
                            input: CoalesceBatchesExec {
                                input: RepartitionExec {
                                    input: AggregateExec {
                                        mode: Partial,
                                        group_by: PhysicalGroupBy {
                                            expr: [
                                                (
                                                    Column {
                                                        name: "col1",
                                                        index: 0,
                                                    },
                                                    "col1",
                                                ),
                                            ],
                                            null_expr: [],
                                            groups: [
                                                [
                                                    false,
                                                ],
                                            ],
                                        },
                                        aggr_expr: [],
                                        input: RepartitionExec {
                                            input: partitions: [...]schema: Schema { fields: [Field { name: "col1", data_type: Utf8, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }], metadata: {} }projection: Some([0]),
                                            partitioning: RoundRobinBatch(
                                                10,
                                            ),
                                            state: Mutex {
                                                data: RepartitionExecState {
                                                    channels: {},
                                                    abort_helper: AbortOnDropMany(
                                                        [],
                                                    ),
                                                },
                                            },
                                            metrics: ExecutionPlanMetricsSet {
                                                inner: Mutex {
                                                    data: MetricsSet {
                                                        metrics: [],
                                                    },
                                                },
                                            },
                                        },
                                        schema: Schema {
                                            fields: [
                                                Field {
                                                    name: "col1",
                                                    data_type: Utf8,
                                                    nullable: true,
                                                    dict_id: 0,
                                                    dict_is_ordered: false,
                                                    metadata: {},
                                                },
                                            ],
                                            metadata: {},
                                        },
                                        input_schema: Schema {
                                            fields: [
                                                Field {
                                                    name: "col1",
                                                    data_type: Utf8,
                                                    nullable: true,
                                                    dict_id: 0,
                                                    dict_is_ordered: false,
                                                    metadata: {},
                                                },
                                            ],
                                            metadata: {},
                                        },
                                        alias_map: {},
                                        metrics: ExecutionPlanMetricsSet {
                                            inner: Mutex {
                                                data: MetricsSet {
                                                    metrics: [],
                                                },
                                            },
                                        },
                                    },
                                    partitioning: Hash(
                                        [
                                            Column {
                                                name: "col1",
                                                index: 0,
                                            },
                                        ],
                                        10,
                                    ),
                                    state: Mutex {
                                        data: RepartitionExecState {
                                            channels: {},
                                            abort_helper: AbortOnDropMany(
                                                [],
                                            ),
                                        },
                                    },
                                    metrics: ExecutionPlanMetricsSet {
                                        inner: Mutex {
                                            data: MetricsSet {
                                                metrics: [],
                                            },
                                        },
                                    },
                                },
                                target_batch_size: 8192,
                                metrics: ExecutionPlanMetricsSet {
                                    inner: Mutex {
                                        data: MetricsSet {
                                            metrics: [],
                                        },
                                    },
                                },
                            },
                            schema: Schema {
                                fields: [
                                    Field {
                                        name: "col1",
                                        data_type: Utf8,
                                        nullable: true,
                                        dict_id: 0,
                                        dict_is_ordered: false,
                                        metadata: {},
                                    },
                                ],
                                metadata: {},
                            },
                            input_schema: Schema {
                                fields: [
                                    Field {
                                        name: "col1",
                                        data_type: Utf8,
                                        nullable: true,
                                        dict_id: 0,
                                        dict_is_ordered: false,
                                        metadata: {},
                                    },
                                ],
                                metadata: {},
                            },
                            alias_map: {},
                            metrics: ExecutionPlanMetricsSet {
                                inner: Mutex {
                                    data: MetricsSet {
                                        metrics: [],
                                    },
                                },
                            },
                        },
                        schema: Schema {
                            fields: [
                                Field {
                                    name: "col2",
                                    data_type: UInt64,
                                    nullable: true,
                                    dict_id: 0,
                                    dict_is_ordered: false,
                                    metadata: {},
                                },
                                Field {
                                    name: "col1",
                                    data_type: Utf8,
                                    nullable: true,
                                    dict_id: 0,
                                    dict_is_ordered: false,
                                    metadata: {},
                                },
                            ],
                            metadata: {},
                        },
                        left_fut: OnceAsync,
                    },
                    partitioning: Hash(
                        [
                            Column {
                                name: "col2",
                                index: 0,
                            },
                            Column {
                                name: "col1",
                                index: 1,
                            },
                        ],
                        10,
                    ),
                    state: Mutex {
                        data: RepartitionExecState {
                            channels: {},
                            abort_helper: AbortOnDropMany(
                                [],
                            ),
                        },
                    },
                    metrics: ExecutionPlanMetricsSet {
                        inner: Mutex {
                            data: MetricsSet {
                                metrics: [],
                            },
                        },
                    },
                },
                target_batch_size: 8192,
                metrics: ExecutionPlanMetricsSet {
                    inner: Mutex {
                        data: MetricsSet {
                            metrics: [],
                        },
                    },
                },
            },
            right: ProjectionExec {
                expr: [
                    (
                        Column {
                            name: "col1",
                            index: 0,
                        },
                        "col1",
                    ),
                    (
                        Column {
                            name: "col2",
                            index: 1,
                        },
                        "col2",
                    ),
                    (
                        Column {
                            name: "SUM(tbl.col3)",
                            index: 2,
                        },
                        "sum_col3",
                    ),
                ],
                schema: Schema {
                    fields: [
                        Field {
                            name: "col1",
                            data_type: UInt64,
                            nullable: true,
                            dict_id: 0,
                            dict_is_ordered: false,
                            metadata: {},
                        },
                        Field {
                            name: "col2",
                            data_type: Utf8,
                            nullable: true,
                            dict_id: 0,
                            dict_is_ordered: false,
                            metadata: {},
                        },
                        Field {
                            name: "sum_col3",
                            data_type: UInt64,
                            nullable: true,
                            dict_id: 0,
                            dict_is_ordered: false,
                            metadata: {},
                        },
                    ],
                    metadata: {},
                },
                input: ProjectionExec {
                    expr: [
                        (
                            Column {
                                name: "col1",
                                index: 1,
                            },
                            "col1",
                        ),
                        (
                            Column {
                                name: "col2",
                                index: 0,
                            },
                            "col2",
                        ),
                        (
                            Column {
                                name: "SUM(tbl.col3)",
                                index: 2,
                            },
                            "SUM(tbl.col3)",
                        ),
                    ],
                    schema: Schema {
                        fields: [
                            Field {
                                name: "col1",
                                data_type: UInt64,
                                nullable: true,
                                dict_id: 0,
                                dict_is_ordered: false,
                                metadata: {},
                            },
                            Field {
                                name: "col2",
                                data_type: Utf8,
                                nullable: true,
                                dict_id: 0,
                                dict_is_ordered: false,
                                metadata: {},
                            },
                            Field {
                                name: "SUM(tbl.col3)",
                                data_type: UInt64,
                                nullable: true,
                                dict_id: 0,
                                dict_is_ordered: false,
                                metadata: {},
                            },
                        ],
                        metadata: {},
                    },
                    input: AggregateExec {
                        mode: FinalPartitioned,
                        group_by: PhysicalGroupBy {
                            expr: [
                                (
                                    Column {
                                        name: "col2",
                                        index: 1,
                                    },
                                    "col2",
                                ),
                                (
                                    Column {
                                        name: "col1",
                                        index: 0,
                                    },
                                    "col1",
                                ),
                            ],
                            null_expr: [],
                            groups: [
                                [
                                    false,
                                    false,
                                ],
                            ],
                        },
                        aggr_expr: [
                            Sum {
                                name: "SUM(tbl.col3)",
                                data_type: UInt64,
                                expr: Column {
                                    name: "col3",
                                    index: 2,
                                },
                                nullable: true,
                            },
                        ],
                        input: CoalesceBatchesExec {
                            input: RepartitionExec {
                                input: AggregateExec {
                                    mode: Partial,
                                    group_by: PhysicalGroupBy {
                                        expr: [
                                            (
                                                Column {
                                                    name: "col2",
                                                    index: 1,
                                                },
                                                "col2",
                                            ),
                                            (
                                                Column {
                                                    name: "col1",
                                                    index: 0,
                                                },
                                                "col1",
                                            ),
                                        ],
                                        null_expr: [],
                                        groups: [
                                            [
                                                false,
                                                false,
                                            ],
                                        ],
                                    },
                                    aggr_expr: [
                                        Sum {
                                            name: "SUM(tbl.col3)",
                                            data_type: UInt64,
                                            expr: Column {
                                                name: "col3",
                                                index: 2,
                                            },
                                            nullable: true,
                                        },
                                    ],
                                    input: RepartitionExec {
                                        input: partitions: [...]schema: Schema { fields: [Field { name: "col1", data_type: Utf8, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }, Field { name: "col2", data_type: UInt64, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }, Field { name: "col3", data_type: UInt64, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }], metadata: {} }projection: Some([0, 1, 2]),
                                        partitioning: RoundRobinBatch(
                                            10,
                                        ),
                                        state: Mutex {
                                            data: RepartitionExecState {
                                                channels: {},
                                                abort_helper: AbortOnDropMany(
                                                    [],
                                                ),
                                            },
                                        },
                                        metrics: ExecutionPlanMetricsSet {
                                            inner: Mutex {
                                                data: MetricsSet {
                                                    metrics: [],
                                                },
                                            },
                                        },
                                    },
                                    schema: Schema {
                                        fields: [
                                            Field {
                                                name: "col2",
                                                data_type: UInt64,
                                                nullable: true,
                                                dict_id: 0,
                                                dict_is_ordered: false,
                                                metadata: {},
                                            },
                                            Field {
                                                name: "col1",
                                                data_type: Utf8,
                                                nullable: true,
                                                dict_id: 0,
                                                dict_is_ordered: false,
                                                metadata: {},
                                            },
                                            Field {
                                                name: "SUM(tbl.col3)[sum]",
                                                data_type: UInt64,
                                                nullable: true,
                                                dict_id: 0,
                                                dict_is_ordered: false,
                                                metadata: {},
                                            },
                                            Field {
                                                name: "SUM(tbl.col3)[count]",
                                                data_type: UInt64,
                                                nullable: true,
                                                dict_id: 0,
                                                dict_is_ordered: false,
                                                metadata: {},
                                            },
                                        ],
                                        metadata: {},
                                    },
                                    input_schema: Schema {
                                        fields: [
                                            Field {
                                                name: "col1",
                                                data_type: Utf8,
                                                nullable: true,
                                                dict_id: 0,
                                                dict_is_ordered: false,
                                                metadata: {},
                                            },
                                            Field {
                                                name: "col2",
                                                data_type: UInt64,
                                                nullable: true,
                                                dict_id: 0,
                                                dict_is_ordered: false,
                                                metadata: {},
                                            },
                                            Field {
                                                name: "col3",
                                                data_type: UInt64,
                                                nullable: true,
                                                dict_id: 0,
                                                dict_is_ordered: false,
                                                metadata: {},
                                            },
                                        ],
                                        metadata: {},
                                    },
                                    alias_map: {
                                        Column {
                                            name: "col2",
                                            index: 1,
                                        }: [
                                            Column {
                                                name: "col2",
                                                index: 0,
                                            },
                                        ],
                                        Column {
                                            name: "col1",
                                            index: 0,
                                        }: [
                                            Column {
                                                name: "col1",
                                                index: 1,
                                            },
                                        ],
                                    },
                                    metrics: ExecutionPlanMetricsSet {
                                        inner: Mutex {
                                            data: MetricsSet {
                                                metrics: [],
                                            },
                                        },
                                    },
                                },
                                partitioning: Hash(
                                    [
                                        Column {
                                            name: "col2",
                                            index: 0,
                                        },
                                        Column {
                                            name: "col1",
                                            index: 1,
                                        },
                                    ],
                                    10,
                                ),
                                state: Mutex {
                                    data: RepartitionExecState {
                                        channels: {},
                                        abort_helper: AbortOnDropMany(
                                            [],
                                        ),
                                    },
                                },
                                metrics: ExecutionPlanMetricsSet {
                                    inner: Mutex {
                                        data: MetricsSet {
                                            metrics: [],
                                        },
                                    },
                                },
                            },
                            target_batch_size: 8192,
                            metrics: ExecutionPlanMetricsSet {
                                inner: Mutex {
                                    data: MetricsSet {
                                        metrics: [],
                                    },
                                },
                            },
                        },
                        schema: Schema {
                            fields: [
                                Field {
                                    name: "col2",
                                    data_type: Utf8,
                                    nullable: true,
                                    dict_id: 0,
                                    dict_is_ordered: false,
                                    metadata: {},
                                },
                                Field {
                                    name: "col1",
                                    data_type: UInt64,
                                    nullable: true,
                                    dict_id: 0,
                                    dict_is_ordered: false,
                                    metadata: {},
                                },
                                Field {
                                    name: "SUM(tbl.col3)",
                                    data_type: UInt64,
                                    nullable: true,
                                    dict_id: 0,
                                    dict_is_ordered: false,
                                    metadata: {},
                                },
                            ],
                            metadata: {},
                        },
                        input_schema: Schema {
                            fields: [
                                Field {
                                    name: "col1",
                                    data_type: Utf8,
                                    nullable: true,
                                    dict_id: 0,
                                    dict_is_ordered: false,
                                    metadata: {},
                                },
                                Field {
                                    name: "col2",
                                    data_type: UInt64,
                                    nullable: true,
                                    dict_id: 0,
                                    dict_is_ordered: false,
                                    metadata: {},
                                },
                                Field {
                                    name: "col3",
                                    data_type: UInt64,
                                    nullable: true,
                                    dict_id: 0,
                                    dict_is_ordered: false,
                                    metadata: {},
                                },
                            ],
                            metadata: {},
                        },
                        alias_map: {
                            Column {
                                name: "col2",
                                index: 1,
                            }: [
                                Column {
                                    name: "col2",
                                    index: 0,
                                },
                            ],
                            Column {
                                name: "col1",
                                index: 0,
                            }: [
                                Column {
                                    name: "col1",
                                    index: 1,
                                },
                            ],
                        },
                        metrics: ExecutionPlanMetricsSet {
                            inner: Mutex {
                                data: MetricsSet {
                                    metrics: [],
                                },
                            },
                        },
                    },
                    output_ordering: None,
                    alias_map: {
                        Column {
                            name: "col1",
                            index: 1,
                        }: [
                            Column {
                                name: "col1",
                                index: 0,
                            },
                        ],
                        Column {
                            name: "col2",
                            index: 0,
                        }: [
                            Column {
                                name: "col2",
                                index: 1,
                            },
                        ],
                    },
                    metrics: ExecutionPlanMetricsSet {
                        inner: Mutex {
                            data: MetricsSet {
                                metrics: [],
                            },
                        },
                    },
                },
                output_ordering: None,
                alias_map: {
                    Column {
                        name: "SUM(tbl.col3)",
                        index: 2,
                    }: [
                        Column {
                            name: "sum_col3",
                            index: 2,
                        },
                    ],
                },
                metrics: ExecutionPlanMetricsSet {
                    inner: Mutex {
                        data: MetricsSet {
                            metrics: [],
                        },
                    },
                },
            },
            on: [
                (
                    Column {
                        name: "col2",
                        index: 0,
                    },
                    Column {
                        name: "col2",
                        index: 1,
                    },
                ),
                (
                    Column {
                        name: "col1",
                        index: 1,
                    },
                    Column {
                        name: "col1",
                        index: 0,
                    },
                ),
            ],
            filter: None,
            join_type: Left,
            schema: Schema {
                fields: [
                    Field {
                        name: "col2",
                        data_type: UInt64,
                        nullable: true,
                        dict_id: 0,
                        dict_is_ordered: false,
                        metadata: {},
                    },
                    Field {
                        name: "col1",
                        data_type: Utf8,
                        nullable: true,
                        dict_id: 0,
                        dict_is_ordered: false,
                        metadata: {},
                    },
                    Field {
                        name: "col1",
                        data_type: UInt64,
                        nullable: true,
                        dict_id: 0,
                        dict_is_ordered: false,
                        metadata: {},
                    },
                    Field {
                        name: "col2",
                        data_type: Utf8,
                        nullable: true,
                        dict_id: 0,
                        dict_is_ordered: false,
                        metadata: {},
                    },
                    Field {
                        name: "sum_col3",
                        data_type: UInt64,
                        nullable: true,
                        dict_id: 0,
                        dict_is_ordered: false,
                        metadata: {},
                    },
                ],
                metadata: {},
            },
            left_fut: OnceAsync,
            random_state: RandomState { .. },
            mode: Partitioned,
            metrics: ExecutionPlanMetricsSet {
                inner: Mutex {
                    data: MetricsSet {
                        metrics: [],
                    },
                },
            },
            column_indices: [
                ColumnIndex {
                    index: 0,
                    side: Left,
                },
                ColumnIndex {
                    index: 1,
                    side: Left,
                },
                ColumnIndex {
                    index: 0,
                    side: Right,
                },
                ColumnIndex {
                    index: 1,
                    side: Right,
                },
                ColumnIndex {
                    index: 2,
                    side: Right,
                },
            ],
            null_equals_null: false,
        },
        target_batch_size: 8192,
        metrics: ExecutionPlanMetricsSet {
            inner: Mutex {
                data: MetricsSet {
                    metrics: [],
                },
            },
        },
    },
    output_ordering: None,
    alias_map: {
        Column {
            name: "col1",
            index: 1,
        }: [
            Column {
                name: "col1",
                index: 0,
            },
        ],
        Column {
            name: "col2",
            index: 0,
        }: [
            Column {
                name: "col2",
                index: 1,
            },
        ],
    },
    metrics: ExecutionPlanMetricsSet {
        inner: Mutex {
            data: MetricsSet {
                metrics: [],
            },
        },
    },
}

टेक्स्ट की तुलना करें

प्रदर्शन

प्रोसेसिंग

datafusion #4873 @keyframes loading-circle-spin { 100% { transform: rotate(360deg); } }

datafusion #4873