query_test.go

package sqlparser

import (
	"encoding/json"
	"fmt"
	"os"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/viant/parsly"
	"github.com/viant/sqlparser/expr"
	"github.com/viant/sqlparser/node"
	"github.com/viant/sqlparser/query"
)

func TestBinaryWalk(t *testing.T) {
	query, _ := ParseQuery("SELECT * FROM t WHERE a = 1  AND (c IN(1,2))")
	binary, ok := query.Qualify.X.(*expr.Binary)
	if !assert.True(t, ok) {
		return
	}
	var actualColumns = make([]string, 0)
	binary.Walk(func(ident node.Node, values *expr.Values, operator, parentOperator string) error {
		actualColumns = append(actualColumns, Stringify(ident))
		return nil
	})
	assert.EqualValues(t, []string{"a", "c"}, actualColumns)

}

func TestParseSelect(t *testing.T) {

	{

		var testCases = []struct {
			description string
			SQL         string
			expect      string
			hasError    bool
			options     []Option
		}{

			{
				description: "except",
				SQL:         "SELECT main.* EXCEPT(Id), cast(main AS Record), cardinality(main, 'One') AS main FROM ta",
				expect:      "SELECT main.* EXCEPT Id, cast(main AS Record), cardinality(main, 'One') AS main FROM ta",
			},
			{
				description: "except group",
				SQL:         "SELECT main.* EXCEPT (Id,Name), cast(main AS Record), cardinality(main, 'One') AS main FROM ta",
				expect:      "SELECT main.* EXCEPT (Id, Name), cast(main AS Record), cardinality(main, 'One') AS main FROM ta",
			},

			{
				description: "criteria with  expr",
				SQL:         "SELECT Name FROM BAR WHERE ${predicate}",
				expect:      "SELECT Name FROM BAR WHERE ${predicate}",
			},
			{
				description: "quoted from expr",
				SQL:         "SELECT Name,Active FROM `/Records[Active = true]`",
				expect:      "SELECT Name, Active FROM `/Records[Active = true]`",
			},
			{
				description: "quoted from expr",
				SQL:         "SELECT * FROM $abc",
				expect:      "SELECT * FROM $abc",
			},
			{
				description: "with syntax",
				SQL: `WITH p AS (SELECT * FROM product), v AS (SELECT * FROM vendor)
				SELECT p.*, v.* FROM p JOIN v ON p.VENDOR_ID = v.ID`,
				expect: `WITH p AS (SELECT * FROM product), v AS (SELECT * FROM vendor) SELECT p.*, v.* FROM p JOIN v ON p.VENDOR_ID = v.ID`,
			},
			{
				description: "with recursive syntax",
				SQL:         `WITH RECURSIVE sub AS (SELECT 1 AS id FROM DUAL UNION ALL SELECT id + 1 AS id FROM sub WHERE id < 5) SELECT t.id FROM sub t WHERE 1=1`,
				expect:      `WITH RECURSIVE sub AS (SELECT 1 AS id FROM DUAL UNION ALL SELECT id + 1 AS id FROM sub WHERE id < 5) SELECT t.id FROM sub t WHERE 1 = 1`,
			},
			{
				description: "with recursive multi-cte",
				SQL:         `WITH RECURSIVE sub AS (SELECT t.ID, t.PARENT_ID, t.NAME, t.ID AS LEVEL_ID FROM APP_CATEGORY t UNION ALL SELECT c.ID, c.PARENT_ID, c.NAME, sub.LEVEL_ID FROM APP_CATEGORY c JOIN sub ON c.PARENT_ID = sub.ID), level AS (SELECT t.ID, t.PROVIDER_ID, t.PARENT_ID, t.NAME, t.PROVIDER_KEY, t.DESCRIPTION, t.PROVIDER_FEE_ID, t.CUSTOMER_ID, t.CREATED, t.UPDATED, t.TARGETABLE, t.STATUS FROM APP_CATEGORY t JOIN (SELECT DISTINCT LEVEL_ID FROM sub WHERE LOWER(sub.NAME) LIKE CONCAT('%', LOWER($Name), '%')) hit ON hit.LEVEL_ID = t.ID), parents AS (SELECT l.ID AS NODE_ID, p.ID AS CUR_ID, p.PARENT_ID AS NEXT_ID, p.NAME AS NAME, 1 AS DEPTH FROM level l JOIN APP_CATEGORY p ON p.ID = l.PARENT_ID WHERE l.PARENT_ID IS NOT NULL AND l.PARENT_ID <> 0 UNION ALL SELECT parents.NODE_ID, p.ID AS CUR_ID, p.PARENT_ID AS NEXT_ID, p.NAME AS NAME, parents.DEPTH + 1 AS DEPTH FROM parents JOIN APP_CATEGORY p ON p.ID = parents.NEXT_ID WHERE parents.NEXT_ID IS NOT NULL AND parents.NEXT_ID <> 0), parent_paths AS (SELECT NODE_ID, JSON_ARRAYAGG(NAME ORDER BY DEPTH ASC) AS PARENT_PATH FROM parents GROUP BY NODE_ID) SELECT l.ID, l.PROVIDER_ID, l.PARENT_ID, l.NAME, l.PROVIDER_KEY, l.DESCRIPTION, l.PROVIDER_FEE_ID, l.CUSTOMER_ID, l.CREATED, l.UPDATED, l.TARGETABLE, l.STATUS, (CASE l.Status WHEN 0 THEN 'Inactive' WHEN 1 THEN 'Active' WHEN 2 THEN 'Archived' ELSE '' END) AS STATUS_NAME, COALESCE(pp.PARENT_PATH, JSON_ARRAY()) AS PARENT_PATH, '' AS PROVIDER_THIRD_PARTY FROM level l LEFT JOIN parent_paths pp ON pp.NODE_ID = l.ID`,
				expect:      `WITH RECURSIVE sub AS (SELECT t.ID, t.PARENT_ID, t.NAME, t.ID AS LEVEL_ID FROM APP_CATEGORY t UNION ALL SELECT c.ID, c.PARENT_ID, c.NAME, sub.LEVEL_ID FROM APP_CATEGORY c JOIN sub ON c.PARENT_ID = sub.ID), level AS (SELECT t.ID, t.PROVIDER_ID, t.PARENT_ID, t.NAME, t.PROVIDER_KEY, t.DESCRIPTION, t.PROVIDER_FEE_ID, t.CUSTOMER_ID, t.CREATED, t.UPDATED, t.TARGETABLE, t.STATUS FROM APP_CATEGORY t JOIN (SELECT DISTINCT LEVEL_ID FROM sub WHERE LOWER(sub.NAME) LIKE CONCAT('%', LOWER($Name), '%')) hit ON hit.LEVEL_ID = t.ID), parents AS (SELECT l.ID AS NODE_ID, p.ID AS CUR_ID, p.PARENT_ID AS NEXT_ID, p.NAME AS NAME, 1 AS DEPTH FROM level l JOIN APP_CATEGORY p ON p.ID = l.PARENT_ID WHERE l.PARENT_ID IS NOT NULL AND l.PARENT_ID <> 0 UNION ALL SELECT parents.NODE_ID, p.ID AS CUR_ID, p.PARENT_ID AS NEXT_ID, p.NAME AS NAME, parents.DEPTH + 1 AS DEPTH FROM parents JOIN APP_CATEGORY p ON p.ID = parents.NEXT_ID WHERE parents.NEXT_ID IS NOT NULL AND parents.NEXT_ID <> 0), parent_paths AS (SELECT NODE_ID, JSON_ARRAYAGG(NAME ORDER BY DEPTH ASC) AS PARENT_PATH FROM parents GROUP BY NODE_ID) SELECT l.ID, l.PROVIDER_ID, l.PARENT_ID, l.NAME, l.PROVIDER_KEY, l.DESCRIPTION, l.PROVIDER_FEE_ID, l.CUSTOMER_ID, l.CREATED, l.UPDATED, l.TARGETABLE, l.STATUS, (CASE l.Status WHEN 0 THEN 'Inactive' WHEN 1 THEN 'Active' WHEN 2 THEN 'Archived' ELSE '' END) AS STATUS_NAME, COALESCE(pp.PARENT_PATH, JSON_ARRAY()) AS PARENT_PATH, '' AS PROVIDER_THIRD_PARTY FROM level l LEFT JOIN parent_paths pp ON pp.NODE_ID = l.ID`,
			},
			{
				description: "with join alias",
				SQL: `WITH audiences AS (SELECT 1 AS id)
  				SELECT ar.id FROM foo f JOIN audiences ar ON ar.id = f.id`,
				expect: `WITH audiences AS (SELECT 1 AS id) SELECT ar.id FROM foo f JOIN audiences ar ON ar.id = f.id`,
			},

			{
				description: "group by",
				SQL:         `SELECT ID, SUM(amount) FROM product u GROUP BY 1`,
				expect:      `SELECT ID, SUM(amount) FROM product u GROUP BY 1`,
			},

			{
				description: "group by",
				SQL:         `SELECT ID, SUM(amount) FROM product u GROUP BY 1`,
				expect:      `SELECT ID, SUM(amount) FROM product u GROUP BY 1`,
			},
			{
				description: "group by, having",
				SQL:         `SELECT ID, SUM(amount) FROM product u GROUP BY 1 HAVING COUNT(DISTINCT zz) > 2`,
				expect:      `SELECT ID, SUM(amount) FROM product u GROUP BY 1 HAVING COUNT(DISTINCT zz) > 2`,
			},
			{
				description: "union all",
				SQL:         `SELECT user.* FROM user1 u UNION ALL SELECT user.* FROM user2 u`,
				expect:      `SELECT user.* FROM user1 u UNION ALL SELECT user.* FROM user2 u`,
			},
			{
				description: "expr with comments",
				SQL:         `SELECT user.* FROM (SELECT t.* FROM USER t  ) user /* {"Self":{"Holder":"Team", "Child":"ID", "Parent":"MGR_ID" }} */ `,
				expect:      `SELECT user.* FROM  (SELECT t.* FROM USER t  )  user /* {"Self":{"Holder":"Team", "Child":"ID", "Parent":"MGR_ID" }} */`,
			},
			{
				description: "legacy-sql hint in subquery",
				SQL: `SELECT
				    a.*
				FROM (
				    SELECT /*+ {\"UseLegacySql\": true} +*/
				        '' AS a
				) a`,
				expect: `SELECT a.* FROM  (
				    SELECT /*+ {\"UseLegacySql\": true} +*/
				        '' AS a
				)  a`,
			},

			{
				description: "bq table select",
				SQL:         "SELECT c1 /* comment */, c2 FROM `proj.dataset.table` t",
				expect:      "SELECT c1 /* comment */, c2 FROM `proj.dataset.table` t",
			},
			{
				description: "start with comments",
				SQL:         "SELECT t.* /* some comments */ FROM tableX t",
				expect:      "SELECT t.* /* some comments */ FROM tableX t",
			},

			{
				description: "bq table select",
				SQL:         "SELECT c1 AS a1 , c2 FROM `proj.dataset.table` t",
				expect:      "SELECT c1 AS a1, c2 FROM `proj.dataset.table` t",
			},

			{
				description: "except select",
				SQL:         "SELECT c1 /* comment */, c2 FROM x t",
				expect:      "SELECT c1 /* comment */, c2 FROM x t",
			},
			{
				description: "except select",
				SQL:         "SELECT * EXCEPT c1,c2 FROM x t",
				expect:      "SELECT * EXCEPT (c1, c2) FROM x t",
			},

			{
				description: "except select",
				SQL:         "SELECT t1.* EXCEPT c1,c2, t2.* EXCEPT c3  FROM x t1 JOIN y AS t2 ON t1.ID=t2.ID",
				expect:      "SELECT t1.* EXCEPT (c1, c2), t2.* EXCEPT c3 FROM x t1 JOIN y t2 ON t1.ID = t2.ID",
			},

			{
				description: "placeholder",
				SQL:         `SELECT ISBN, Name FROM Publication t WHERE (ISBN = ?) AND  1=1`,
				expect:      `SELECT ISBN, Name FROM Publication t WHERE (ISBN = ?) AND 1 = 1`,
			},

			{
				description: "error - extra coma",
				SQL:         `SELECT TOUPPER(name) AS Name, FROM user u`,
				hasError:    true,
			},
			{
				description: "fun call",
				SQL:         `SELECT TOUPPER(name) AS Name FROM user u`,
				expect:      `SELECT TOUPPER(name) AS Name FROM user u`,
			},

			{
				description: "cast call",
				SQL:         `SELECT CAST(name AS TEXT) AS Name FROM user u`,
				expect:      `SELECT CAST(name AS TEXT) AS Name FROM user u`,
			},
			{
				description: "comments",
				SQL:         `SELECT user.* FROM user u -- extra comments `,
				expect:      `SELECT user.* FROM user u`,
			},

			{
				description: "expr with comments",
				SQL:         `SELECT user.* FROM (SELECT t.* FROM USER t  ) user /* {"Self":{"Holder":"Team", "Child":"ID", "Parent":"MGR_ID" }} */ `,
				expect:      `SELECT user.* FROM  (SELECT t.* FROM USER t  )  user /* {"Self":{"Holder":"Team", "Child":"ID", "Parent":"MGR_ID" }} */`,
			},

			{
				description: "bq table select",
				SQL:         "SELECT c1 /* comment */, c2 FROM `proj.dataset.table` t",
				expect:      "SELECT c1 /* comment */, c2 FROM `proj.dataset.table` t",
			},
			{
				description: "start with comments",
				SQL:         "SELECT t.* /* some comments */ FROM tableX t",
				expect:      "SELECT t.* /* some comments */ FROM tableX t",
			},

			{
				description: "bq table select",
				SQL:         "SELECT c1 AS a1 , c2 FROM `proj.dataset.table` t",
				expect:      "SELECT c1 AS a1, c2 FROM `proj.dataset.table` t",
			},

			{
				description: "except select",
				SQL:         "SELECT c1 /* comment */, c2 FROM x t",
				expect:      "SELECT c1 /* comment */, c2 FROM x t",
			},
			{
				description: "except select",
				SQL:         "SELECT * EXCEPT c1,c2 FROM x t",
				expect:      "SELECT * EXCEPT (c1, c2) FROM x t",
			},

			{
				description: "except select",
				SQL:         "SELECT t1.* EXCEPT c1,c2, t2.* EXCEPT c3  FROM x t1 JOIN y AS t2 ON t1.ID=t2.ID",
				expect:      "SELECT t1.* EXCEPT (c1, c2), t2.* EXCEPT c3 FROM x t1 JOIN y t2 ON t1.ID = t2.ID",
			},

			{
				description: "* select",
				SQL:         "SELECT * FROM x",
				expect:      "SELECT * FROM x",
			},
			{
				description: "* select with $",
				SQL:         "SELECT * FROM x WHERE id= $id",
				expect:      "SELECT * FROM x WHERE id = $id",
			},

			{
				description: "basic select",
				SQL:         "SELECT col1, t.col2, col3 AS col FROM x t",
				expect:      "SELECT col1, t.col2, col3 AS col FROM x t",
			},

			{
				description: "JOIN select",
				SQL:         "SELECT t.* FROM x1 t join x2 z ON t.ID = z.ID",
				expect:      "SELECT t.* FROM x1 t join x2 z ON t.ID = z.ID",
			},
			{
				description: "JOIN select with collate",
				SQL:         "SELECT * FROM a JOIN b ON a.brand COLLATE utf8mb4_bin = b.brand COLLATE utf8mb4_bin",
				expect:      "SELECT * FROM a JOIN b ON a.brand COLLATE utf8mb4_bin = b.brand COLLATE utf8mb4_bin",
			},
			{
				description: "JOIN select with collate parenthesis",
				SQL:         "SELECT * FROM a JOIN b ON (a.brand COLLATE utf8mb4_bin) = (b.brand COLLATE utf8mb4_bin)",
				expect:      "SELECT * FROM a JOIN b ON (a.brand COLLATE utf8mb4_bin) = (b.brand COLLATE utf8mb4_bin)",
			},
			{
				description: "JOIN select",
				SQL:         "SELECT t.* FROM x1 t join x2 z ON t.ID = z.ID LEFT JOIN x3 y ON t.ID = x3.ID",
				expect:      "SELECT t.* FROM x1 t join x2 z ON t.ID = z.ID LEFT JOIN x3 y ON t.ID = x3.ID",
			},

			{
				description: "select with WHERE",
				SQL:         "SELECT t.* FROM x t WHERE 1=1 AND (x=2)",
				expect:      "SELECT t.* FROM x t WHERE 1 = 1 AND (x=2)",
			},
			{
				description: "where not equal with order by",
				SQL:         "SELECT t.* FROM x t WHERE a <> b ORDER BY c",
				expect:      "SELECT t.* FROM x t WHERE a <> b ORDER BY c",
			},
			{
				description: "where not equal without spaces with order by",
				SQL:         "SELECT t.* FROM x t WHERE a<>b ORDER BY c",
				expect:      "SELECT t.* FROM x t WHERE a <> b ORDER BY c",
			},
			{
				description: "where not equal placeholder with order by",
				SQL:         "SELECT t.* FROM x t WHERE a <> $b ORDER BY c",
				expect:      "SELECT t.* FROM x t WHERE a <> $b ORDER BY c",
			},

			{
				description: "func call select",
				SQL:         "SELECT COALESCE(t.PARENT_ID,0) AS PARENT, t.col2, col3 AS col FROM x t",
				expect:      "SELECT COALESCE(t.PARENT_ID,0) AS PARENT, t.col2, col3 AS col FROM x t",
			},
			{
				description: "exists select",
				SQL:         "SELECT 1 FROM x t WHERE col IN (1,2,3)",
				expect:      "SELECT 1 FROM x t WHERE col IN (1,2,3)",
			},

			{
				description: "unary operand select",
				SQL:         "SELECT NOT t.col FROM x t",
				expect:      "SELECT  NOT t.col FROM x t",
			},
			{
				description: "basic expr",
				SQL:         "SELECT col1 + col2 AS z, t.col2, col3 AS col FROM x t",
				expect:      "SELECT col1 + col2 AS z, t.col2, col3 AS col FROM x t",
			},
			{
				description: "between criteria select",
				SQL:         "SELECT c1 FROM table t WHERE a BETWEEN 1 AND 2",
				expect:      "SELECT c1 FROM table t WHERE a BETWEEN 1 AND 2",
			},
			{
				description: "between criteria select 2",
				SQL:         "SELECT c1 FROM table t WHERE a BETWEEN 1 AND 2 AND 1=1",
				expect:      "SELECT c1 FROM table t WHERE a BETWEEN 1 AND 2 AND 1 = 1",
			},
			{
				description: "join comments",
				SQL:         "SELECT * FROM tab1 t1 JOIN tab2 t2  /* my comment */  ON t1.ID = t2.ID ",
				expect:      "SELECT * FROM tab1 t1 JOIN tab2 t2 /* my comment */ ON t1.ID = t2.ID",
			},
			{
				description: "table comments",
				SQL:         "SELECT * FROM tab1 t1 /* my comment */ JOIN tab2 t2  ON t1.ID = t2.ID ",
				expect:      "SELECT * FROM tab1 t1 /* my comment */ JOIN tab2 t2 ON t1.ID = t2.ID",
			},

			{
				description: "criteria with additional expr",
				SQL:         "SELECT Name FROM BAR WHERE 1 = 1 ${expr}",
				expect:      "SELECT Name FROM BAR WHERE 1 = 1 ${expr}",
			},
			{
				description: "",
				expect:      `SELECT ID, Name, Price FROM dataset-name.abc.table-name v GROUP BY 1, 2`,
				SQL: `
                           select ID,
                                  Name,
                                  Price 
                           from dataset-name.abc.table-name v
                           group by 1, 2
                       `,
			},
			{
				description: "",
				SQL:         `select agegroup_id, name from (select id agegroup_id, name from CI_AGEGROUP) v #if($Has.AgeIncl)  where $criteria.In("v.agegroup_id", $AgeIncl) #end `,
				expect:      `SELECT agegroup_id, name FROM  (select id agegroup_id, name from CI_AGEGROUP)  v #if($Has.AgeIncl)  where $criteria.In("v.agegroup_id", $AgeIncl) #end`,
				options: []Option{
					WithErrorHandler(func(err error, cur *parsly.Cursor, destNode interface{}) error {
						fromNode, ok := destNode.(*query.From)
						if !ok {
							return err
						}
						input := string(cur.Input[cur.Pos:])
						if strings.HasPrefix(input, "#if") {
							index := strings.LastIndex(input, "#end")
							if index == -1 {
								return err
							}
							input = input[:index+4]
							fromNode.Unparsed = input + " "
							cur.Pos += index + 4
							return nil
						}
						return err
					}),
				},
			},

			{
				description: "",
				SQL:         `SELECT col1, col2 FROM table1 t, UNNEST(b) v`,
				expect:      `SELECT col1, col2 FROM table1 t , UNNEST(b) v`,
			},
			{
				description: "bigquery unnest relation",
				SQL: `SELECT
    si.event_date,
    si.order_id,
    si.group_id,
    fr.feature,
    si.indexed_count,
    si.selected_count,
    si.error_count,
    fr.item_error_total,
    fr.group_error_total,
    fr.item_ratio,
    fr.estimated_errors,
    SAFE_DIVIDE(fr.estimated_errors, NULLIF(si.error_count, 0)) AS error_share
FROM ` + "`" + `example-project.analytics.event_metrics` + "`" + ` si,  UNNEST(si.measurements) fr
WHERE si.event_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 3 DAY)`,
				expect: "SELECT si.event_date, si.order_id, si.group_id, fr.feature, si.indexed_count, si.selected_count, si.error_count, fr.item_error_total, fr.group_error_total, fr.item_ratio, fr.estimated_errors, SAFE_DIVIDE(fr.estimated_errors, NULLIF(si.error_count, 0)) AS error_share FROM `example-project.analytics.event_metrics` si , UNNEST(si.measurements) fr WHERE si.event_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 3 DAY)",
			},

			{
				description: "",
				SQL:         `SELECT               ID,NAME  FROM AAA               ORDER BY 2 DESC, 1 ASC`,
				expect:      `SELECT ID, NAME FROM AAA ORDER BY 2 DESC, 1 ASC`,
			},

			{
				description: "",
				SQL:         `SELECT col1, col2 FROM table1/tt t JOIN xx/e v ON v.ID=t.ID`,
				expect:      `SELECT col1, col2 FROM table1/tt t JOIN xx/e v ON v.ID = t.ID`,
			},
			{
				description: "",
				SQL:         `SELECT col1, col2 FROM table1[id=?].tt t JOIN xx/e v ON v.ID=t.ID`,
				expect:      `SELECT col1, col2 FROM table1[id=?].tt t JOIN xx/e v ON v.ID = t.ID`,
			},
		}

		for _, testCase := range testCases {
			//for _, testCase := range testCases {
			query, err := ParseQuery(testCase.SQL, testCase.options...)
			if testCase.hasError {
				assert.NotNilf(t, err, testCase.description)
				continue
			}
			if !assert.Nil(t, err) {
				fmt.Println(err)
				fmt.Printf("%v\n", testCase.SQL)
				continue
			}

			actual := strings.TrimSpace(Stringify(query))
			if !assert.EqualValues(t, testCase.expect, actual) {
				data, _ := json.Marshal(query)
				fmt.Printf("failed test case: %s\n", testCase.description)
				fmt.Printf("%s\n", data)
			}
		}
	}
}

func TestParseSelect_BigQueryRawRegexLiteral(t *testing.T) {
	sql := `SELECT LOWER(REGEXP_REPLACE(COALESCE(NULLIF(TRIM(s.NAME), ''), NULLIF(TRIM(s.MOBILE_URL), ''), ''),r'^(?:https?://)?(?:www\.)?', '')) AS site_domain FROM CI_SITE s`

	parsed, err := ParseQuery(sql)
	if !assert.NoError(t, err) {
		return
	}

	actual := strings.TrimSpace(Stringify(parsed))
	assert.Equal(t, sql, actual)
}

func TestParseSelect_BigQueryUnnestJoinTarget(t *testing.T) {
	sql := "SELECT si.event_date FROM `example-project.analytics.event_metrics` si, UNNEST(si.measurements) fr"
	parsed, err := ParseQuery(sql)
	if !assert.NoError(t, err) {
		return
	}
	if !assert.Len(t, parsed.Joins, 1) {
		return
	}
	call, ok := parsed.Joins[0].With.(*expr.Call)
	if !assert.Truef(t, ok, "expected UNNEST relation target to parse as *expr.Call, got %T", parsed.Joins[0].With) {
		return
	}
	assert.Equal(t, "UNNEST", Stringify(call.X))
	assert.Len(t, call.Args, 1)
	assert.Equal(t, "si.measurements", Stringify(call.Args[0]))
	assert.Equal(t, "fr", parsed.Joins[0].Alias)
}

func TestParseSelect_RankedMetricsWholeQuery(t *testing.T) {
	data, err := os.ReadFile("testdata/ranked_metrics.sql")
	if !assert.NoError(t, err) {
		return
	}
	sql := string(data)

	parsed, err := ParseQuery(sql)
	if !assert.NoError(t, err) {
		return
	}

	actual := strings.TrimSpace(Stringify(parsed))
	assert.Contains(t, actual, "r'^(?:https?://)?(?:www\\.)?'")
	assert.Contains(t, actual, "ORDER BY v.rn")
	qualifyCount, windowCount := 0, 0
	Traverse(parsed, func(n node.Node) bool {
		switch value := n.(type) {
		case *query.Select:
			if value.QualifyClause != nil {
				qualifyCount++
			}
		case *expr.Window:
			windowCount++
		}
		return true
	})
	assert.Equal(t, 1, qualifyCount)
	assert.Equal(t, 2, windowCount)
}