3D_TQ_jv_query_pit.xml

<?xml version="1.0" encoding="UTF-8"?>
<template xmlns="http://www.wherescape.com/xml/Template" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.wherescape.com/xml/Template template_2.xsd">
  <xml_version>2</xml_version>
  <name>jv_query_pit</name>
  <type>query</type>
  <metatags>
    <metatag name="Version">1.0</metatag>
  </metatags>
  <content><![CDATA[{#- ======================================== -#}
{#- Generates the data warehouse query       -#}
{#- ======================================== -#}


{%- import "ws3d_common_utility" -%}
{%- import "ws3d_query_utility" -%}
{%- import "jv_query_utility" -%}

{#- ======================================== -#}
{#- Pre-declared parameters                  -#}
{#-    Should be provided by process         -#}
{#- ======================================== -#}
{%- declare caseStyle = "actual" -%}{#- actual | upper | lower -#}
{%- declare copyQueryWhereClause = false -%}
{%- declare encapsulate = true -%}
{%- declare forcedSchema = null -%}
{%- declare retainWhereClause = true -%}

{%- declare additionalColumns = [] -%}
{%- declare additionalWhereClauses = [] -%}
{%- declare allColumns = false -%}
{%- declare generateSurrogates = false -%}
{%- declare hasDimDate = false -%}
{%- declare queryColumnNames = {} -%}

{%- if not encapsulate -%}
    {%- set ECS_AO = "" -%}{#- Encapsulation for Alias Open -#}
    {%- set ECS_AC = "" -%}{#- Encapsulation for Alias Close -#}
    {%- set ECS_SO = "" -%}{#- Encapsulation for Schema Open -#}
    {%- set ECS_SC = "" -%}{#- Encapsulation for Schema Close -#}
    {%- set ECS_TO = "" -%}{#- Encapsulation for Table Open -#}
    {%- set ECS_TC = "" -%}{#- Encapsulation for Table Close -#}
    {%- set ECS_CO = "" -%}{#- Encapsulation for Column Open -#}
    {%- set ECS_CC = "" -%}{#- Encapsulation for Column Close -#}
{%- else -%}
    {%- declare ECS_AO = "\"" -%}{#- Encapsulation for Alias Open -#}
    {%- declare ECS_AC = "\"" -%}{#- Encapsulation for Alias Close -#}
    {%- declare ECS_SO = "\"" -%}{#- Encapsulation for Schema Open -#}
    {%- declare ECS_SC = "\"" -%}{#- Encapsulation for Schema Close -#}
    {%- declare ECS_TO = "\"" -%}{#- Encapsulation for Table Open -#}
    {%- declare ECS_TC = "\"" -%}{#- Encapsulation for Table Close -#}
    {%- declare ECS_CO = "\"" -%}{#- Encapsulation for Column Open -#}
    {%- declare ECS_CC = "\"" -%}{#- Encapsulation for Column Close -#}
{%- endif -%}

{#- ======================================== -#}
{#- Parameters                               -#}
{#- ======================================== -#}
{%- set dataQuery = false -%}
{%- set defaultJoin = "LEFT OUTER JOIN" -%}
{%- set denormalize = false -%}

{#- ======================================== -#}
{#- Generate the query                       -#}
{#- ======================================== -#}
{%- set graphs = createSourceGraph(table, dataQuery, denormalize) -%}

{%- if graphs | length > 0 -%}

    {#- ======================================== -#}
    {#- Combine similar graphs                   -#}
    {#- ======================================== -#}
    {%- set combinedGraphsTables = {} -%}
    {%- set combinedGraphsRoots = {} -%}
    {{- combineGraphs(graphs, combinedGraphsTables, combinedGraphsRoots) -}}

    {%- for combinedGraph in combinedGraphsTables -%}
        {%- set graphTablesOrig = combinedGraph.value -%}
        {%- set pkTables = [] -%}
        {%- for fkRelation in table.fkRelations -%}
            {%- if fkRelation.relationshipTypes is empty -%}
                {%- list pkTables add fkRelation.pkTable -%}
            {%- endif -%}
        {%- endfor -%}
        {%- set graphTables = [] -%}
        {%- for graphTable in graphTablesOrig -%}
            {%- if not pkTables contains graphTable.table -%}
                {%- list graphTables add graphTable -%}
            {%- endif -%}
        {%- endfor -%}
        {%- map combinedGraphsTables put combinedGraph.key = graphTables -%}
    {%- endfor -%}

    {%- for combinedGraph in combinedGraphsTables -%}
        {%- set seenJoins = [] -%}
        {%- set seenTables = [] -%}
        {%- set hasFirstColumn = false -%}

        {%- if not loop.first -%}
            ;{%- br -%}
            {%- br -%}
        {%- endif -%}

        {#- Determine if the generated query may require unions -#}
        {%- set generateWithUnion = false -%}
        {%- for merge in table.queryMergeType -%}
            {%- if merge.value == "SET-MERGE" -%}
                {%- set generateWithUnion = true -%}
            {%- endif -%}
        {%- endfor -%}

        {#- Setup for union or not -#}
        {%- if generateWithUnion -%}
            {%- set allGraphTables = [] -%}
            {{- splitSourceGraphIntoConnectedGraphs(combinedGraph.value, allGraphTables) -}}
        {%- else -%}
            {%- set allGraphTables = [ combinedGraph.value ] -%}
        {%- endif -%}

        {%- for graphTables in allGraphTables -%}
            {%- set seenJoins = [] -%}
            {%- set seenTables = [] -%}
            {%- set hasFirstColumn = false -%}

            {%- if loop.first and generateWithUnion -%}
                ({%- br -%}
            {%- elseif not loop.first -%}
                {%- if generateWithUnion -%}
                    ){%- br -%}
                    UNION{%- br -%}
                    ({%- br -%}
                {%- else -%}
                    ;{%- br -%}{%- br -%}
                {%- endif -%}
            {%- endif -%}

            {#- ======================================== -#}
            {#- Print Select clause                      -#}
            {#- ======================================== -#}
            SELECT{%- br -%}
            {%- for graphTable in combinedGraphsRoots.get(combinedGraph.key) -%}
                {%- for col in graphTable.columns -%}
                    {%- if (col.sourceColumns | length > 0) -%}
                        {#- ===== Sourced columns ===== -#}
                        {%- set hasAddedColumn = false -%}
                        {%- for srcTable in graphTables -%}
                            {%- if col is hasSourceTable(srcTable.table) -%}
                                {%- indent -%}
                                {%- if hasFirstColumn -%}, {% else -%}{%- set hasFirstColumn = true -%}{%- endif -%}
                                {%- set found = false -%}
                                {%- for srcCol in srcTable.table.columns -%}
                                    {%- if col is hasSourceColumn(srcCol) and (not found) -%}
                                        {%- set fqn = ECS_AO + toCase(srcTable.alias, caseStyle) + ECS_AC + "." + ECS_CO + srcCol.name + ECS_CC -%}
                                        {#- ===== Data transformations ===== -#}
                                        {%- if col.dataTransformations | length > 0 -%}
                                            {%- for dt in col.dataTransformations -%}
                                                {%- set fqn = dt.change.replace(dt.VARIABLE, fqn) -%}
                                            {%- endfor -%}
                                        {%- endif -%}
                                        {{ fqn }} as {{ printName(col.name, ECS_AO, ECS_AC, caseStyle) -}}{%- br -%}
                                        {%- set found = true -%}
                                    {%- endif -%}
                                {%- endfor -%}
                                {%- if found -%}
                                    {%- set hasAddedColumn = true -%}
                                {%- endif -%}
                            {%- endif -%}
                        {%- endfor -%}
                        {%- if (not hasAddedColumn) and generateWithUnion -%}
                            {%- indent -%}
                            {%- if hasFirstColumn -%}, {% else -%}{%- set hasFirstColumn = true -%}{%- endif -%}
                            NULL as {{ printName(col.name, ECS_AO, ECS_AC, caseStyle) -}}{%- br -%}
                        {%- endif -%}
                    {%- elseif col.dataTransformations is not empty -%}
                        {#- ===== Data transformations ===== -#}
                        {%- indent -%}
                        {%- if hasFirstColumn -%}, {% else -%}{%- set hasFirstColumn = true -%}{%- endif -%}
                        {%- set fqn = "" -%}
                        {%- for dt in col.dataTransformations -%}
                            {%- set fqn = dt.change.replace(dt.VARIABLE, fqn) -%}
                        {%- endfor -%}
                        {{ fqn }} as {{ printName(col.name, ECS_AO, ECS_AC, caseStyle) -}}{%- br -%}
                    {%- endif -%}
                {%- endfor -%}
            {%- endfor -%}
            {%- if not hasFirstColumn -%}
                {%- indent -%}*{%- br -%}
            {%- endif -%}

            FROM{%- br -%}
            {%- for t in graphTables -%}

                {#- ======================================== -#}
                {#- Print query join type                    -#}
                {#- ======================================== -#}
                {%- if not loop.first -%}
                    {{- addQueryJoinType(t, seenTables, defaultJoin) -}}
                {%- endif -%}

                {#- ======================================== -#}
                {#- Print table name                         -#}
                {#- ======================================== -#}
                {%- if loop.first -%}
                    {%- if graphTables | length > 1 -%}
                        {%- indent 2 -%}
                    {%- else -%}
                        {%- indent 1 -%}
                    {%- endif -%}
                {%- else %} {% endif -%}
                {%- if forcedSchema is empty -%}
                    {%- if t.table.schema is not empty -%}
                        {{- printName(t.table.schema, ECS_SO, ECS_SC) -}}.
                    {%- endif -%}
                {%- else -%}
                    {{- printName(forcedSchema, ECS_SO, ECS_SC) -}}.
                {%- endif -%}
                {{- printName(t.table.name, ECS_TO, ECS_TC) }} {{ printName(t.alias, ECS_AO, ECS_AC, caseStyle) -}}{%- br -%}
                {%- list seenTables add t -%}

                {#- ======================================== -#}
                {#- Print table joins                        -#}
                {#- ======================================== -#}
                {%- if not loop.first -%}
                    {{- addPITQueryJoins(t, seenTables, seenJoins, ECS_AO, ECS_AC, ECS_CO, ECS_CC, caseStyle) -}}
                {%- endif -%}
            {%- endfor -%}

            {#- ======================================== -#}
            {#- Print Where clause                       -#}
            {#- ======================================== -#}
            {%- set hasWhere = false -%}
            {%- set hasGroupBy = false -%}
            {%- set hasHaving = false -%}
            {%- set hasOrderBy = false -%}
            {%- if retainWhereClause and table.dwquery is not empty -%}
                {%- set parsed = parseQuery(table.dwquery) -%}
                {%- if parsed is not empty -%}
                    {%- set parsed = parsed[0] -%}
                {%- else -%}
                    {%- set parsed = null -%}
                {%- endif -%}
            {%- else -%}
                {%- set parsed = null -%}
            {%- endif -%}
            {%- if copyQueryWhereClause and table.query is not empty -%}
                {%- set parsedQuery = parseQuery(table.query) -%}
                {%- if parsedQuery is not empty -%}
                    {%- set parsedQuery = parsedQuery[0] -%}
                {%- else -%}
                    {%- set parsedQuery = null -%}
                {%- endif -%}
            {%- else -%}
                {%- set parsedQuery = null -%}
            {%- endif -%}
            {%- if parsed is not null or parsedQuery is not null -%}
                {%- if parsed is not null and parsed is instanceof("SelectDefinition") and parsed.where is not empty -%}
                    WHERE{%- br -%}
                    {%- indent -%}{{ parsed.where }}{%- br -%}
                    {%- set hasWhere = true -%}
                {%- elseif parsedQuery is not null and parsedQuery is instanceof("SelectDefinition") and parsedQuery.where is not empty -%}
                    WHERE{%- br -%}
                    {%- indent -%}{{ parsedQuery.where }}{%- br -%}
                    {%- set hasWhere = true -%}
                {%- endif -%}

                {%- if parsed is not null and parsed is instanceof("SelectDefinition") and parsed.groupBy is not empty -%}
                    GROUP BY{%- br -%}
                    {%- indent -%}{{ parsed.groupBy | join(", ") }}{%- br -%}
                    {%- set hasGroupBy = true -%}
                {%- elseif parsedQuery is not null and parsedQuery is instanceof("SelectDefinition") and parsedQuery.groupBy is not empty -%}
                    GROUP BY{%- br -%}
                    {%- indent -%}{{ parsedQuery.groupBy | join(", ") }}{%- br -%}
                    {%- set hasGroupBy = true -%}
                {%- endif -%}

                {%- if parsed is not null and parsed is instanceof("SelectDefinition") and parsed.having is not empty -%}
                    HAVING{%- br -%}
                    {%- indent -%}{{ parsed.having }}{%- br -%}
                    {%- set hasHaving = true -%}
                {%- elseif parsedQuery is not null and parsedQuery is instanceof("SelectDefinition") and parsedQuery.having is not empty -%}
                    HAVING{%- br -%}
                    {%- indent -%}{{ parsedQuery.having }}{%- br -%}
                    {%- set hasHaving = true -%}
                {%- endif -%}

                {%- if parsed is not null and (not generateWithUnion) and parsed.orderBy is not empty -%}
                    ORDER BY{%- br -%}
                    {%- indent -%}{{ parsed.orderBy }}{%- br -%}
                    {%- set hasOrderBy = true -%}
                {%- elseif parsedQuery is not null and (not generateWithUnion) and parsedQuery.orderBy is not empty -%}
                    ORDER BY{%- br -%}
                    {%- indent -%}{{ parsedQuery.orderBy }}{%- br -%}
                    {%- set hasOrderBy = true -%}
                {%- endif -%}
            {%- endif -%}

            {%- if loop.last and generateWithUnion -%}
                ){%- br -%}

                {%- if parsed is not null or parsedQuery is not null -%}
                    {%- if parsed is not null and parsed.orderBy is not empty -%}
                        ORDER BY{%- br -%}
                        {%- indent -%}{{ parsed.orderBy }}{%- br -%}
                        {%- set hasOrderBy = true -%}
                    {%- elseif parsedQuery is not null and parsedQuery.orderBy is not empty -%}
                        ORDER BY{%- br -%}
                        {%- indent -%}{{ parsedQuery.orderBy }}{%- br -%}
                        {%- set hasOrderBy = true -%}
                    {%- endif -%}
                {%- endif -%}
            {%- endif -%}
        {%- endfor -%}
    {%- endfor -%}
{%- endif -%}
]]></content>
</template>