@quillsql/react 2.12.30 → 2.12.32

package/dist/esm/components/ReportBuilder/convert.uspec.js

@@ -1,1152 +0,0 @@
-import { convertASTToPivotData, convertGroupBy } from './convert';
-import { convertColumnInfoToColumnInternal } from '../../utils/columnProcessing';
-function generateCaseWhenColumnAst(columnField, valueField, caseValue) {
-    const defaultCaseWhen = {
-        type: 'expr',
-        expr: {
-            type: 'aggr_func',
-            name: 'SUM',
-            args: {
-                expr: {
-                    type: 'case',
-                    expr: null,
-                    args: [
-                        {
-                            type: 'when',
-                            cond: {
-                                type: 'binary_expr',
-                                operator: '=',
-                                left: {
-                                    type: 'column_ref',
-                                    table: null,
-                                    column: 'category',
-                                },
-                                right: {
-                                    type: 'single_quote_string',
-                                    value: 'Food',
-                                },
-                            },
-                            result: {
-                                type: 'column_ref',
-                                table: null,
-                                column: 'amount',
-                            },
-                        },
-                        {
-                            type: 'else',
-                            result: {
-                                type: 'number',
-                                value: 0,
-                            },
-                        },
-                    ],
-                },
-            },
-            over: null,
-        },
-        as: 'total_food_spend',
-    };
-    defaultCaseWhen.expr.args.expr.args[0].cond.left.column = columnField;
-    defaultCaseWhen.expr.args.expr.args[0].result.column = valueField;
-    defaultCaseWhen.expr.args.expr.args[0].cond.right.value = caseValue;
-    return defaultCaseWhen;
-}
-describe('convert', () => {
-    const emptySelect = {
-        with: null,
-        type: 'select',
-        options: null,
-        distinct: null,
-        columns: [],
-        from: [
-            {
-                db: null,
-                table: 'transactions',
-                as: null,
-            },
-        ],
-        where: null,
-        groupby: null,
-        having: null,
-        orderby: null,
-        limit: null,
-    };
-    const schema = [
-        {
-            viewQuery: 'SELECT * FROM transactions',
-            name: 'transactions',
-            isVisible: true,
-            _id: '1',
-            clientId: 'dummy',
-            displayName: 'transactions',
-            columns: [
-                {
-                    name: 'created_at',
-                    fieldType: 'date',
-                    displayName: 'created_at',
-                    isVisible: true,
-                    _id: '1',
-                },
-                {
-                    name: 'amount',
-                    fieldType: 'int4',
-                    displayName: 'amount',
-                    isVisible: true,
-                    _id: '2',
-                },
-                {
-                    name: 'merchant',
-                    fieldType: 'text',
-                    displayName: 'merchant',
-                    isVisible: true,
-                    _id: '3',
-                },
-                {
-                    name: 'user_name',
-                    fieldType: 'text',
-                    displayName: 'user_name',
-                    isVisible: true,
-                    _id: '4',
-                },
-            ],
-        },
-    ];
-    describe('convertGroupBy', () => {
-        const defaultSelectAST = {
-            with: null,
-            type: 'select',
-            options: null,
-            distinct: null,
-            columns: [
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'column_ref',
-                        table: null,
-                        column: 'created_at',
-                    },
-                    as: null,
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'column_ref',
-                        table: null,
-                        column: 'amount',
-                    },
-                    as: null,
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'column_ref',
-                        table: null,
-                        column: 'merchant',
-                    },
-                    as: null,
-                },
-            ],
-            from: [
-                {
-                    db: null,
-                    table: 'transactions',
-                    as: null,
-                },
-            ],
-            where: null,
-            groupby: null,
-            having: null,
-            orderby: null,
-            limit: null,
-        };
-        const sumAggAST = {
-            type: 'expr',
-            expr: {
-                type: 'aggr_func',
-                name: 'SUM',
-                args: {
-                    expr: {
-                        type: 'column_ref',
-                        table: null,
-                        column: 'amount',
-                    },
-                },
-                over: null,
-            },
-            as: 'amount',
-        };
-        it('should process the aggregation, value and row fields from the ast', () => {
-            const pivotAST = { ...defaultSelectAST };
-            pivotAST.columns = [...pivotAST.columns, sumAggAST];
-            pivotAST.groupby = [
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: {
-                        expr: {
-                            type: 'default',
-                            value: 'created_at',
-                        },
-                    },
-                },
-            ];
-            const result = convertGroupBy(pivotAST, null, schema);
-            expect(result?.pivot?.rowField).toEqual('created_at');
-            expect(result?.pivot?.valueField).toEqual('amount');
-            // @ts-ignore
-            expect(result.ast.groupby).toEqual(null);
-            // @ts-ignore
-            expect(result.ast.columns.length).toEqual(3);
-        });
-        it('should process an ast with 2 group by columns for the 2d pivot information from the ast and modify the ast to only have basic column selections', () => {
-            const pivotAST = { ...defaultSelectAST };
-            pivotAST.columns = [...pivotAST.columns, sumAggAST];
-            pivotAST.groupby = [
-                {
-                    type: 'double_quote_string',
-                    value: 'merchant',
-                },
-                {
-                    type: 'double_quote_string',
-                    value: 'created_at',
-                },
-            ];
-            const result = convertGroupBy(pivotAST, null, schema);
-            expect(result?.pivot?.rowField).toEqual('created_at');
-            expect(result?.pivot?.columnField).toEqual('merchant');
-            expect(result?.pivot?.valueField).toEqual('amount');
-            // @ts-ignore
-            expect(result.ast.groupby).toEqual(null);
-            // @ts-ignore
-            expect(result.ast.columns.length).toEqual(3);
-        });
-        it('should process an ast with case when columns for the 2d pivot information from the ast and modify the ast to only have basic column selections', () => {
-            const pivotAST = { ...defaultSelectAST };
-            pivotAST.columns = [
-                ...pivotAST.columns,
-                generateCaseWhenColumnAst('merchant', 'amount', 'Food'),
-                generateCaseWhenColumnAst('merchant', 'amount', 'Clothing'),
-            ];
-            pivotAST.groupby = [
-                {
-                    type: 'double_quote_string',
-                    value: 'created_at',
-                },
-            ];
-            const result = convertGroupBy(pivotAST, null, schema);
-            expect(result?.pivot?.rowField).toEqual('created_at');
-            expect(result?.pivot?.columnField).toEqual('merchant');
-            expect(result?.pivot?.valueField).toEqual('amount');
-            // @ts-ignore
-            expect(result.ast.groupby).toEqual(null);
-            // @ts-ignore
-            expect(result.ast.columns.length).toEqual(3);
-        });
-        it('should maintain columns that are in the schema but convert them to a basic ast column select format', () => {
-            const dateTruncAst = { ...defaultSelectAST };
-            const schemaInfo = [...schema];
-            // @ts-ignore
-            schemaInfo[0].columns.push({
-                name: 'updated_at',
-                fieldType: 'date',
-                displayName: 'updated_at',
-                isVisible: true,
-                _id: '3',
-            });
-            dateTruncAst.columns = [
-                ...defaultSelectAST.columns,
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'function',
-                        name: 'DATE_TRUNC',
-                        args: {
-                            type: 'expr_list',
-                            value: [
-                                {
-                                    type: 'single_quote_string',
-                                    value: 'month',
-                                },
-                                {
-                                    type: 'column_ref',
-                                    table: null,
-                                    column: 'updated_at',
-                                },
-                            ],
-                        },
-                    },
-                    as: 'month',
-                },
-            ];
-            const result = convertGroupBy(dateTruncAst, null, schemaInfo);
-            // @ts-ignore
-            expect(result.ast.columns.length).toEqual(4);
-        });
-        it('should parse out extract columns from the ast column list and replace them with the basic column select', () => {
-            const extractAst = { ...defaultSelectAST };
-            const schemaInfo = [...schema];
-            // @ts-ignore
-            schemaInfo[0].columns.push({
-                name: 'updated_at',
-                fieldType: 'date',
-                displayName: 'updated_at',
-                isVisible: true,
-                _id: '3',
-            });
-            extractAst.columns = [
-                ...defaultSelectAST.columns,
-                {
-                    expr: {
-                        type: 'extract',
-                        args: {
-                            field: 'month',
-                            source: {
-                                type: 'column_ref',
-                                table: null,
-                                column: 'updated_at',
-                            },
-                        },
-                    },
-                    as: 'month',
-                },
-            ];
-            extractAst.groupby = [
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'user_name',
-                },
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'updated_at',
-                },
-            ];
-            const result = convertGroupBy(extractAst, null, schemaInfo);
-            // @ts-ignore
-            expect(result.ast.columns.length).toEqual(5);
-        });
-        it('should take field type into account and apply a numeric value field if it is present', () => {
-            const extractAst = emptySelect;
-            extractAst.columns = [
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'created_at',
-                    },
-                    as: 'created_at',
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'amount',
-                    },
-                    as: 'amount',
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'user_name',
-                    },
-                    as: 'user_name',
-                },
-            ];
-            extractAst.groupby = [
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'created_at',
-                },
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'amount',
-                },
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'user_name',
-                },
-            ];
-            const result = convertGroupBy(extractAst, null, schema);
-            // @ts-ignore
-            expect(result.pivot.valueField).toEqual('amount');
-            // @ts-ignore
-            expect(result.pivot.rowField).toEqual('created_at');
-        });
-        it('should set aggregation type to count if there is no numeric field', () => {
-            const extractAst = emptySelect;
-            extractAst.columns = [
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'created_at',
-                    },
-                    as: 'created_at',
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'user_name',
-                    },
-                    as: 'user_name',
-                },
-            ];
-            extractAst.groupby = [
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'created_at',
-                },
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'amount',
-                },
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'user_name',
-                },
-            ];
-            const result = convertGroupBy(extractAst, null, schema);
-            // @ts-ignore
-            expect(result.pivot.aggregationType).toEqual('count');
-            // @ts-ignore
-            expect(result.pivot.rowField).toEqual('created_at');
-        });
-        it('should extract out non numeric value fields and replace it with null and set the aggregation type to count', () => {
-            const extractAst = {
-                with: null,
-                type: 'select',
-                options: null,
-                distinct: null,
-                columns: [
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'column_ref',
-                            table: null,
-                            column: 'user_name',
-                        },
-                        as: null,
-                    },
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'aggr_func',
-                            name: 'SUM',
-                            args: {
-                                expr: {
-                                    type: 'case',
-                                    expr: null,
-                                    args: [
-                                        {
-                                            type: 'when',
-                                            cond: {
-                                                type: 'binary_expr',
-                                                operator: '=',
-                                                left: {
-                                                    type: 'column_ref',
-                                                    table: null,
-                                                    column: 'category',
-                                                },
-                                                right: {
-                                                    type: 'single_quote_string',
-                                                    value: 'Food',
-                                                },
-                                            },
-                                            result: {
-                                                type: 'number',
-                                                value: 1,
-                                            },
-                                        },
-                                        {
-                                            type: 'else',
-                                            result: {
-                                                type: 'number',
-                                                value: 0,
-                                            },
-                                        },
-                                    ],
-                                },
-                            },
-                            over: null,
-                        },
-                        as: 'total_food_spend',
-                    },
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'aggr_func',
-                            name: 'SUM',
-                            args: {
-                                expr: {
-                                    type: 'case',
-                                    expr: null,
-                                    args: [
-                                        {
-                                            type: 'when',
-                                            cond: {
-                                                type: 'binary_expr',
-                                                operator: '=',
-                                                left: {
-                                                    type: 'column_ref',
-                                                    table: null,
-                                                    column: 'category',
-                                                },
-                                                right: {
-                                                    type: 'single_quote_string',
-                                                    value: 'Fuel',
-                                                },
-                                            },
-                                            result: {
-                                                type: 'number',
-                                                value: 1,
-                                            },
-                                        },
-                                        {
-                                            type: 'else',
-                                            result: {
-                                                type: 'number',
-                                                value: 0,
-                                            },
-                                        },
-                                    ],
-                                },
-                            },
-                            over: null,
-                        },
-                        as: 'total_fuel_spend',
-                    },
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'function',
-                            name: 'DATE_TRUNC',
-                            args: {
-                                type: 'expr_list',
-                                value: [
-                                    {
-                                        type: 'single_quote_string',
-                                        value: 'month',
-                                    },
-                                    {
-                                        type: 'column_ref',
-                                        table: null,
-                                        column: 'created_at',
-                                    },
-                                ],
-                            },
-                        },
-                        as: 'month',
-                    },
-                ],
-                from: [
-                    {
-                        db: null,
-                        table: 'transactions',
-                        as: null,
-                    },
-                ],
-                where: null,
-                groupby: [
-                    {
-                        type: 'column_ref',
-                        table: null,
-                        column: 'user_name',
-                    },
-                    {
-                        type: 'function',
-                        name: 'DATE_TRUNC',
-                        args: {
-                            type: 'expr_list',
-                            value: [
-                                {
-                                    type: 'single_quote_string',
-                                    value: 'month',
-                                },
-                                {
-                                    type: 'column_ref',
-                                    table: null,
-                                    column: 'created_at',
-                                },
-                            ],
-                        },
-                    },
-                ],
-                having: null,
-                orderby: [
-                    {
-                        expr: {
-                            type: 'column_ref',
-                            table: null,
-                            column: 'user_name',
-                        },
-                        type: 'ASC',
-                    },
-                    {
-                        expr: {
-                            type: 'function',
-                            name: 'DATE_TRUNC',
-                            args: {
-                                type: 'expr_list',
-                                value: [
-                                    {
-                                        type: 'single_quote_string',
-                                        value: 'month',
-                                    },
-                                    {
-                                        type: 'column_ref',
-                                        table: null,
-                                        column: 'created_at',
-                                    },
-                                ],
-                            },
-                        },
-                        type: 'ASC',
-                    },
-                ],
-                limit: null,
-            };
-            const result = convertGroupBy(extractAst, null, schema);
-            // @ts-ignore
-            expect(result.pivot.aggregationType).toEqual('count');
-            // @ts-ignore
-            expect(result.pivot.rowField).toEqual('created_at');
-        });
-        it('should be able to handle this case', () => {
-            const newAST = {
-                with: null,
-                type: 'select',
-                options: null,
-                distinct: {
-                    type: null,
-                },
-                columns: [
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'function',
-                            name: 'DATE_TRUNC',
-                            args: {
-                                type: 'expr_list',
-                                value: [
-                                    {
-                                        type: 'single_quote_string',
-                                        value: 'week',
-                                    },
-                                    {
-                                        type: 'double_quote_string',
-                                        value: 'created_at',
-                                    },
-                                ],
-                            },
-                        },
-                        as: 'week_start',
-                    },
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'aggr_func',
-                            name: 'SUM',
-                            args: {
-                                expr: {
-                                    type: 'double_quote_string',
-                                    value: 'amount',
-                                },
-                            },
-                            over: null,
-                        },
-                        as: 'total_amount',
-                    },
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'aggr_func',
-                            name: 'COUNT',
-                            args: {
-                                expr: {
-                                    type: 'star',
-                                    value: '*',
-                                },
-                            },
-                            over: null,
-                        },
-                        as: 'transaction_count',
-                    },
-                ],
-                from: [
-                    {
-                        db: null,
-                        table: 'transactions',
-                        as: null,
-                    },
-                ],
-                where: null,
-                groupby: [
-                    {
-                        type: 'function',
-                        name: 'DATE_TRUNC',
-                        args: {
-                            type: 'expr_list',
-                            value: [
-                                {
-                                    type: 'single_quote_string',
-                                    value: 'week',
-                                },
-                                {
-                                    type: 'double_quote_string',
-                                    value: 'created_at',
-                                },
-                            ],
-                        },
-                    },
-                ],
-                having: null,
-                orderby: null,
-                limit: null,
-                window: null,
-            };
-            // @ts-ignore
-            const result = convertGroupBy(newAST, null, schema);
-            // @ts-ignore
-            expect(result.pivot.aggregationType).toEqual('sum');
-            // @ts-ignore
-            expect(result.pivot.rowField).toEqual('created_at');
-        });
-        it('should extract any date_trunc, timestamp_trunc and date_part to row field', () => {
-            const extractAst = {
-                with: null,
-                type: 'select',
-                options: null,
-                distinct: null,
-                columns: [
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'function',
-                            name: {
-                                name: [
-                                    {
-                                        type: 'default',
-                                        value: 'date_trunc',
-                                    },
-                                ],
-                            },
-                            args: {
-                                type: 'expr_list',
-                                value: [
-                                    {
-                                        type: 'single_quote_string',
-                                        value: 'year',
-                                    },
-                                    {
-                                        type: 'column_ref',
-                                        table: null,
-                                        column: {
-                                            expr: {
-                                                type: 'double_quote_string',
-                                                value: 'created_at',
-                                            },
-                                        },
-                                    },
-                                ],
-                            },
-                        },
-                        as: 'year',
-                    },
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'column_ref',
-                            table: null,
-                            column: {
-                                expr: {
-                                    type: 'double_quote_string',
-                                    value: 'id',
-                                },
-                            },
-                        },
-                        as: null,
-                    },
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'column_ref',
-                            table: null,
-                            column: {
-                                expr: {
-                                    type: 'double_quote_string',
-                                    value: 'amount',
-                                },
-                            },
-                        },
-                        as: null,
-                    },
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'column_ref',
-                            table: null,
-                            column: {
-                                expr: {
-                                    type: 'double_quote_string',
-                                    value: 'merchant',
-                                },
-                            },
-                        },
-                        as: null,
-                    },
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'column_ref',
-                            table: null,
-                            column: {
-                                expr: {
-                                    type: 'double_quote_string',
-                                    value: 'user_name',
-                                },
-                            },
-                        },
-                        as: null,
-                    },
-                    {
-                        type: 'expr',
-                        expr: {
-                            type: 'column_ref',
-                            table: null,
-                            column: {
-                                expr: {
-                                    type: 'double_quote_string',
-                                    value: 'category',
-                                },
-                            },
-                        },
-                        as: null,
-                    },
-                ],
-                from: [
-                    {
-                        db: null,
-                        table: 'transactions',
-                        as: null,
-                    },
-                ],
-                where: null,
-                groupby: null,
-                having: null,
-                orderby: null,
-                limit: {
-                    seperator: '',
-                    value: [],
-                },
-            };
-            const result = convertGroupBy(extractAst, null, schema);
-            // @ts-ignore
-            expect(result.pivot.aggregationType).toEqual('sum');
-            // @ts-ignore
-            expect(result.pivot.valueField).toEqual('amount');
-            // @ts-ignore
-            expect(result.pivot.rowField).toEqual('created_at');
-        });
-    });
-    describe('convertASTToPivotData', () => {
-        it('should convert an aggregate function to a value field only pivot', () => {
-            const extractAst = emptySelect;
-            extractAst.columns = [
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'aggr_func',
-                        name: 'SUM',
-                        args: {
-                            expr: {
-                                type: 'column_ref',
-                                table: null,
-                                column: 'amount',
-                            },
-                        },
-                        over: null,
-                    },
-                    as: null,
-                },
-            ];
-            // @ts-ignore
-            const columnInteralArray = schema[0].columns.map((column) => {
-                return convertColumnInfoToColumnInternal(column);
-            });
-            const result = convertASTToPivotData(extractAst, columnInteralArray);
-            expect(result).toBeDefined();
-            expect(result?.valueField).toEqual('amount');
-        });
-        it('should convert a CASE WHEN function to the right pivot', () => {
-            const extractAst = emptySelect;
-            extractAst.columns = [
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'user_name',
-                    },
-                    as: null,
-                },
-                generateCaseWhenColumnAst('merchant', 'amount', 'Food'),
-            ];
-            extractAst.groupby = [
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'user_name',
-                },
-            ];
-            // @ts-ignore
-            const columnInteralArray = schema[0].columns.map((column) => {
-                return convertColumnInfoToColumnInternal(column);
-            });
-            const result = convertASTToPivotData(extractAst, columnInteralArray);
-            expect(result).toBeDefined();
-            expect(result?.valueField).toEqual('amount');
-            expect(result?.rowField).toEqual('user_name');
-            expect(result?.columnField).toEqual('merchant');
-        });
-        it('should use the first two group by fields as the pivot row field and column field', () => {
-            const extractAst = emptySelect;
-            extractAst.columns = [
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'aggr_func',
-                        name: 'SUM',
-                        args: {
-                            expr: {
-                                type: 'column_ref',
-                                table: null,
-                                column: 'amount',
-                            },
-                        },
-                        over: null,
-                    },
-                    as: null,
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'user_name',
-                    },
-                    as: null,
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'merchant',
-                    },
-                    as: null,
-                },
-            ];
-            extractAst.groupby = [
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'user_name',
-                },
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'merchant',
-                },
-            ];
-            // @ts-ignore
-            const columnInteralArray = schema[0].columns.map((column) => {
-                return convertColumnInfoToColumnInternal(column);
-            });
-            const result = convertASTToPivotData(extractAst, columnInteralArray);
-            expect(result).toBeDefined();
-            expect(result?.valueField).toEqual('amount');
-            expect(result?.rowField).toEqual('user_name');
-            expect(result?.columnField).toEqual('merchant');
-        });
-        it('should always use date_trunc columns as the row field', () => {
-            const extractAst = emptySelect;
-            extractAst.columns = [
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'aggr_func',
-                        name: 'SUM',
-                        args: {
-                            expr: {
-                                type: 'column_ref',
-                                table: null,
-                                column: 'amount',
-                            },
-                        },
-                        over: null,
-                    },
-                    as: null,
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'user_name',
-                    },
-                    as: null,
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'created_at',
-                    },
-                    as: null,
-                },
-            ];
-            extractAst.groupby = [
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'user_name',
-                },
-                {
-                    type: 'function',
-                    name: 'date_trunct',
-                    args: {
-                        type: 'expr_list',
-                        value: [
-                            {
-                                type: 'single_quote_string',
-                                value: 'month',
-                            },
-                            {
-                                type: 'column_ref',
-                                table: null,
-                                column: 'created_at',
-                            },
-                        ],
-                    },
-                },
-            ];
-            // @ts-ignore
-            const columnInteralArray = schema[0].columns.map((column) => {
-                return convertColumnInfoToColumnInternal(column);
-            });
-            const result = convertASTToPivotData(extractAst, columnInteralArray);
-            expect(result).toBeDefined();
-            expect(result?.valueField).toEqual('amount');
-            expect(result?.rowField).toEqual('created_at');
-            expect(result?.columnField).toEqual('user_name');
-        });
-        it('should process aliasing properly for pivots', () => {
-            const extractAst = emptySelect;
-            extractAst.columns = [
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'aggr_func',
-                        name: 'SUM',
-                        args: {
-                            expr: {
-                                type: 'column_ref',
-                                table: null,
-                                column: 'amount',
-                            },
-                        },
-                        over: null,
-                    },
-                    as: 'total_sum',
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'created_at',
-                    },
-                    as: 'date_info',
-                },
-            ];
-            extractAst.groupby = [
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'date_info',
-                },
-            ];
-            // @ts-ignore
-            const columnInteralArray = schema[0].columns.map((column) => {
-                return convertColumnInfoToColumnInternal(column);
-            });
-            const result = convertASTToPivotData(extractAst, columnInteralArray);
-            expect(result).toBeDefined();
-            expect(result?.valueField).toEqual('amount');
-            expect(result?.rowField).toEqual('created_at');
-            expect(result?.aggregationType).toEqual('sum');
-            expect(result?.rowFieldType).toEqual('date');
-            expect(result?.sortFieldType).toEqual('date');
-        });
-        it('should not sign a numeric type to row or column field', () => {
-            const extractAst = emptySelect;
-            extractAst.columns = [
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'created_at',
-                    },
-                    as: 'created_at',
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'amount',
-                    },
-                    as: 'amount',
-                },
-                {
-                    type: 'expr',
-                    expr: {
-                        type: 'double_quote_string',
-                        column: 'user_name',
-                    },
-                    as: 'user_name',
-                },
-            ];
-            extractAst.groupby = [
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'created_at',
-                },
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'amount',
-                },
-                {
-                    type: 'column_ref',
-                    table: null,
-                    column: 'user_name',
-                },
-            ];
-            // @ts-ignore
-            const columnInteralArray = schema[0].columns.map((column) => {
-                return convertColumnInfoToColumnInternal(column);
-            });
-            const result = convertASTToPivotData(extractAst, columnInteralArray);
-            expect(result).toBeDefined();
-            expect(result?.rowField).toEqual('created_at');
-            expect(result?.aggregationType).toEqual(undefined);
-            expect(result?.rowFieldType).toEqual('date');
-            expect(result?.columnField).toEqual('user_name');
-        });
-    });
-});