@quillsql/react 2.12.29 → 2.12.31

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

@@ -0,0 +1,1419 @@
+import { convertASTToPivotData, convertGroupBy, convertUnaryToBinary, } 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).toBeDefined();
+            expect(result.pivot?.rowField).toEqual('created_at');
+            expect(result.pivot?.valueField).toEqual('amount');
+            expect(result.ast).toBeDefined();
+            // @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];
+            schemaInfo[0] &&
+                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');
+        });
+    });
+    describe('convertUnaryToBinary', () => {
+        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,
+        };
+        it('should not change a binary_expr where node', () => {
+            const ast = {
+                ...defaultSelectAST,
+                where: {
+                    type: 'binary_expr',
+                    operator: 'AND',
+                    left: {
+                        type: 'binary_expr',
+                        operator: '>',
+                        left: {
+                            type: 'column_ref',
+                            table: null,
+                            column: 'amount',
+                        },
+                        right: {
+                            type: 'number',
+                            value: 100,
+                        },
+                    },
+                    right: {
+                        type: 'binary_expr',
+                        operator: '<',
+                        left: {
+                            type: 'column_ref',
+                            table: null,
+                            column: 'created_at',
+                        },
+                        right: {
+                            type: 'function',
+                            name: {
+                                name: [],
+                                schema: {
+                                    type: 'default',
+                                    value: 'DATE_SUB',
+                                },
+                            },
+                            args: {
+                                type: 'expr_list',
+                                value: [
+                                    {
+                                        type: 'function',
+                                        name: {
+                                            name: [],
+                                            schema: {
+                                                type: 'default',
+                                                value: 'CURDATE',
+                                            },
+                                        },
+                                        args: {
+                                            type: 'expr_list',
+                                            value: [],
+                                        },
+                                        over: null,
+                                    },
+                                    {
+                                        type: 'interval',
+                                        expr: {
+                                            type: 'number',
+                                            value: 1,
+                                        },
+                                        unit: 'month',
+                                    },
+                                ],
+                            },
+                            over: null,
+                        },
+                    },
+                },
+            };
+            const result = convertUnaryToBinary(ast);
+            expect(result).toBeDefined();
+            expect(result).toEqual(ast);
+        });
+        it('should replace a unary_expr where node', () => {
+            const astWithUnary = {
+                ...defaultSelectAST,
+                where: {
+                    type: 'unary_expr',
+                    operator: 'NOT',
+                    expr: {
+                        type: 'column_ref',
+                        table: null,
+                        column: 'is_something',
+                    },
+                },
+            };
+            const result = convertUnaryToBinary(astWithUnary);
+            expect(result).toBeDefined();
+            expect(result?.where?.type).toEqual('binary_expr');
+        });
+        it('should replace a direct column_ref where node', () => {
+            const astWithDirectRef = {
+                ...defaultSelectAST,
+                where: {
+                    type: 'column_ref',
+                    table: null,
+                    column: 'something',
+                },
+            };
+            const result = convertUnaryToBinary(astWithDirectRef);
+            expect(result).toBeDefined();
+            expect(result?.where?.type).toEqual('binary_expr');
+        });
+        it('should replace a unary_expr nested in a where node', () => {
+            const astWithNestedUnary = {
+                ...defaultSelectAST,
+                where: {
+                    type: 'binary_expr',
+                    operator: 'AND',
+                    left: {
+                        type: 'binary_expr',
+                        operator: '>',
+                        left: {
+                            type: 'column_ref',
+                            table: null,
+                            column: 'amount',
+                        },
+                        right: {
+                            type: 'number',
+                            value: 100,
+                        },
+                    },
+                    right: {
+                        type: 'unary_expr',
+                        operator: 'NOT',
+                        expr: {
+                            type: 'column_ref',
+                            table: null,
+                            column: 'something',
+                        },
+                    },
+                },
+            };
+            const result = convertUnaryToBinary(astWithNestedUnary);
+            expect(result).toBeDefined();
+            expect(result?.where?.type).toEqual('binary_expr');
+            expect(result?.where?.left?.type).toEqual('binary_expr');
+            expect(result?.where?.right?.type).toEqual('binary_expr');
+        });
+        it('should replace a direct column_ref nested in a where node', () => {
+            const astWithNestedRef = {
+                ...defaultSelectAST,
+                where: {
+                    type: 'binary_expr',
+                    operator: 'AND',
+                    left: {
+                        type: 'binary_expr',
+                        operator: '>',
+                        left: {
+                            type: 'column_ref',
+                            table: null,
+                            column: 'amount',
+                        },
+                        right: {
+                            type: 'number',
+                            value: 100,
+                        },
+                    },
+                    right: {
+                        type: 'column_ref',
+                        table: null,
+                        column: 'something',
+                    },
+                },
+            };
+            const result = convertUnaryToBinary(astWithNestedRef);
+            expect(result).toBeDefined();
+            expect(result?.where?.type).toEqual('binary_expr');
+            expect(result?.where?.left?.type).toEqual('binary_expr');
+            expect(result?.where?.right?.type).toEqual('binary_expr');
+        });
+        it('should replace all unary and direct column_ref in a where node', () => {
+            const astWithUnaryAndRef = {
+                ...defaultSelectAST,
+                where: {
+                    type: 'binary_expr',
+                    operator: 'OR',
+                    left: {
+                        type: 'binary_expr',
+                        operator: 'AND',
+                        left: {
+                            type: 'unary_expr',
+                            operator: 'NOT',
+                            expr: {
+                                type: 'column_ref',
+                                table: null,
+                                column: 'is_something',
+                            },
+                        },
+                        right: {
+                            type: 'column_ref',
+                            table: null,
+                            column: 'something_else',
+                        },
+                    },
+                    right: {
+                        type: 'binary_expr',
+                        operator: '=',
+                        left: {
+                            type: 'column_ref',
+                            table: null,
+                            column: 'this',
+                        },
+                        right: {
+                            type: 'bool',
+                            value: true,
+                        },
+                    },
+                },
+            };
+            const result = convertUnaryToBinary(astWithUnaryAndRef);
+            expect(result).toBeDefined();
+            expect(result?.where?.type).toEqual('binary_expr');
+            expect(result?.where?.left?.type).toEqual('binary_expr');
+            expect(result?.where?.right?.type).toEqual('binary_expr');
+            expect(result?.where?.left?.left?.type).toEqual('binary_expr');
+            expect(result?.where?.left?.right?.type).toEqual('binary_expr');
+        });
+    });
+});